## Types
-The basic types include the usual boolean, integral, and floating point types.
+The basic types include the usual boolean, integral, and floating-point types.
------------------------- -----------------------------------------------
`()` Nil, the type that has only a single value
`i8`, `i16`, `i32`, `i64` Signed integers with a specific size (in bits)
`u8`, `u16`, `u32`, `u64` Unsigned integers with a specific size
`float` The largest floating-point type efficiently supported on the target machine
-`f32`, `f64` Floating-point types with a specific size.
-`char` A Unicode character (32 bits).
+`f32`, `f64` Floating-point types with a specific size
+`char` A Unicode character (32 bits)
------------------------- -----------------------------------------------
These can be combined in composite types, which will be described in
------------------------- -----------------------------------------------
`[T * N]` Vector (like an array in other languages) with N elements
`[mut T * N]` Mutable vector with N elements
-`(T1, T2)` Tuple type. Any arity above 1 is supported
+`(T1, T2)` Tuple type; any arity above 1 is supported
`&T`, `~T`, `@T` [Pointer types](#boxes-and-pointers)
------------------------- -----------------------------------------------
~~~~
fn line(a: int, b: int, x: int) -> int {
- return a*x + b;
+ return a * x + b;
}
~~~~
~~~~
fn line(a: int, b: int, x: int) -> int {
- a*x + b
+ a * x + b
}
~~~~
Ending the function with a semicolon like so is equivalent to returning `()`.
~~~~
-fn line(a: int, b: int, x: int) -> int { a*x + b }
-fn oops(a: int, b: int, x: int) -> () { a*x + b; }
+fn line(a: int, b: int, x: int) -> int { a * x + b }
+fn oops(a: int, b: int, x: int) -> () { a * x + b; }
-assert 8 == line(5,3,1);
-assert () == oops(5,3,1);
+assert 8 == line(5, 3, 1);
+assert () == oops(5, 3, 1);
~~~~
Methods are like functions, except that they are defined for a specific
type. They support most of the same allocation options as
vectors, though the string literal without a storage sigil, e.g.
`"foo"` is treated differently than a comparable vector (`[foo]`).
-Wheras plain vectors are stack-allocated fixed length vectors,
+Whereas plain vectors are stack-allocated fixed-length vectors,
plain strings are region pointers to read-only memory.
~~~