Replace all references to "class" with "type"

compiler/src/docs.rs

@@ -319,7 +319,7 @@ impl<'a> GenerateDocumentation<'a> {
         doc.add("documentation", Json::String(docs));
         doc.add("constants", self.constants());
         doc.add("methods", self.module_methods());
-        doc.add("classes", self.types());
+        doc.add("types", self.types());
         doc.add("traits", self.traits());
 
         let path =

docs/inko.pkg

@@ -1,4 +1,4 @@
 require https://github.com/yorickpeterse/inko-wobsite 0.19.0 fa5e47733423aa6a902028e69de5a374a1757377
 require https://github.com/yorickpeterse/inko-builder 0.13.0 7a38803e1fcd80e19ad2ea8fd90b9babf70e93a6
 require https://github.com/yorickpeterse/inko-markdown 0.21.0 3726c10b499242cb3febc931a82e35217e2f987a
-require https://github.com/yorickpeterse/inko-syntax 0.14.0 ef03ca1958a17560082495ec6367bd50b02d3fde
+require https://github.com/yorickpeterse/inko-syntax 0.16.0 21cd93afb84c093c28bb3629e0b8b9441f6b1822

docs/menu.json

@@ -18,7 +18,7 @@
     "getting-started/control-flow.md",
     "getting-started/variables.md",
     "getting-started/methods.md",
-    "getting-started/classes.md",
+    "getting-started/types.md",
     "getting-started/traits.md",
     "getting-started/visibility.md",
     "getting-started/modules.md",

docs/source/design/compiler.md

@@ -29,7 +29,7 @@ The compilation process consists of the following steps:
 
 Parsing is a topic extensively covered in computer science, so we won't go over
 it in much detail. Inko uses a handwritten LL(1) recursive descend parser, and a
-separate lexer/tokeniser. Each type of thing to parse (e.g. a class or an array
+separate lexer/tokeniser. Each type of thing to parse (e.g. a type or an array
 literal) typically has a corresponding function in the parser. AST nodes are
 just plain structures.
 
@@ -325,8 +325,8 @@ refreshed automatically. Incremental compilation can be disabled using
 
 ### Methods
 
-As part of code generation, methods are stored in a class such that we can
-efficiently perform dynamic dispatch. Each class has a table for its method,
+As part of code generation, methods are stored in a type such that we can
+efficiently perform dynamic dispatch. Each type has a table for its method,
 with the size being a power of two. Each method is given a globally unique hash
 code based on its name. This means different methods with the same name share
 the same hash code, but this is OK because a type can only define a method with

docs/source/getting-started/arrays.md

@@ -30,7 +30,7 @@ The `get` method returns an immutable borrow to a value, while `get_mut` returns
 a mutable borrow:
 
 ```inko
-class Person {
+type Person {
   let @name: String
 }
 
@@ -43,7 +43,7 @@ people.get_mut(0) # => mut Person(name: 'Alice')
 If the index is out of bounds, `get` and `get_mut` panic:
 
 ```inko
-class Person {
+type Person {
   let @name: String
 }
 
@@ -56,7 +56,7 @@ The `opt` and `opt_mut` methods are similar to `get` and `get_mut`, except they
 wrap the return values in an `Option` value:
 
 ```inko
-class Person {
+type Person {
   let @name: String
 }
 

docs/source/getting-started/concurrency.md

@@ -15,10 +15,10 @@ as these guides explain the basics of what we'll build upon in this guide.
 
 To recap, Inko uses lightweight processes for concurrency. These processes don't
 share memory, instead values are _moved_ between processes. Processes are
-defined using `class async`:
+defined using `type async`:
 
 ```inko
-class async Counter {
+type async Counter {
   let @number: Int
 }
 ```
@@ -27,7 +27,7 @@ Interacting with processes is done using `async` methods. Such methods are
 defined like so:
 
 ```inko
-class async Counter {
+type async Counter {
   let @number: Int
 
   fn async mut increment(amount: Int) {
@@ -157,7 +157,7 @@ Here's a more complicated example:
 import std.net.ip (IpAddress)
 import std.net.socket (TcpServer)
 
-class async Main {
+type async Main {
   fn async main {
     let server = recover TcpServer
       .new(IpAddress.v4(127, 0, 0, 1), port: 40_000)
@@ -190,11 +190,11 @@ isn't available.
 When spawning a process, the values assigned to its fields must be sendable:
 
 ```inko
-class async Example {
+type async Example {
   let @numbers: Array[Int]
 }
 
-class async Main {
+type async Main {
   fn async main {
     Example(numbers: recover [10, 20])
   }
@@ -217,7 +217,7 @@ methods:
 ```inko
 import std.sync (Future, Promise)
 
-class async Counter {
+type async Counter {
   let @value: Int
 
   fn async mut increment {
@@ -229,7 +229,7 @@ class async Counter {
   }
 }
 
-class async Main {
+type async Main {
   fn async main {
     let counter = Counter(value: 0)
 

docs/source/getting-started/control-flow.md

@@ -14,7 +14,7 @@ For conditionals we use `if`:
 ```inko
 import std.stdio (Stdout)
 
-class async Main {
+type async Main {
   fn async main {
     let out = Stdout.new
     let num = 42
@@ -32,7 +32,7 @@ Inko also supports `else if` like so:
 ```inko
 import std.stdio (Stdout)
 
-class async Main {
+type async Main {
   fn async main {
     let out = Stdout.new
     let num = 50
@@ -56,7 +56,7 @@ keywords:
 ```inko
 import std.stdio (Stdout)
 
-class async Main {
+type async Main {
   fn async main {
     let out = Stdout.new
     let num = 50
@@ -85,7 +85,7 @@ Here we use a conditional loop to print a number 10 times:
 ```inko
 import std.stdio (Stdout)
 
-class async Main {
+type async Main {
   fn async main {
     let out = Stdout.new
     let mut num = 0
@@ -121,7 +121,7 @@ import std.process (sleep)
 import std.stdio (Stdout)
 import std.time (Duration)
 
-class async Main {
+type async Main {
   fn async main {
     let out = Stdout.new
     let mut num = 0
@@ -142,7 +142,7 @@ the inner-most loop:
 ```inko
 import std.stdio (Stdout)
 
-class async Main {
+type async Main {
   fn async main {
     let out = Stdout.new
 

docs/source/getting-started/destructors.md

@@ -12,7 +12,7 @@ Types can define a method to run when before they are dropped, known as a
 import std.drop (Drop)
 import std.stdio (Stdout)
 
-class Person {
+type Person {
   let @name: String
 }
 
@@ -22,7 +22,7 @@ impl Drop for Person {
   }
 }
 
-class async Main {
+type async Main {
   fn async main {
     Person(name: 'Alice')
   }
@@ -44,7 +44,7 @@ dropped escaping the `drop` call:
 import std.drop (Drop)
 import std.stdio (Stdout)
 
-class Person {
+type Person {
   let @name: String
   let @people: mut Array[ref Person]
 }
@@ -56,7 +56,7 @@ impl Drop for Person {
   }
 }
 
-class async Main {
+type async Main {
   fn async main {
     let people = []
     let person = Person(name: 'Alice', people: people)