Module auto-imported

`Keywords`

Keywords are recognized by position. Contextual keywords such as self, result, old or from are only special where their page says, and stay ordinary identifiers elsewhere. Avoid using any of them as a name anyway: true, false and typeof always parse as keywords in an expression.

Built into the compiler.

Keywords#

Name	Description
`fn`	Declares a function, a method, or (written in an expression) an anonymous function.
`let`	Declares a mutable local variable.
`const`	Declares a binding that cannot be reassigned: a local, a module constant, or a class field that is set only by `new`.
`static`	Declares a module-level or class-level slot shared by the whole program, or a method without `self`.
`readonly`	A read-only view of a value: nothing reachable through it can be changed.
`if`	Runs a block when a `bool` condition is true.
`else`	Introduces the branch of an `if` that runs when its condition is false (or its pattern does not match).
`while`	Repeats a block while a `bool` condition is true.
`for`	Iterates over the values of an array, `Vec`, range, coroutine or any `IntoIterator`.
`in`	Separates the loop variable from the iterated value in a `for` loop.
`break`	Leaves the innermost `while` or `for` loop at once.
`continue`	Skips the rest of the current iteration and goes on with the next one.
`return`	Leaves the current function, optionally with a value.
`raise`	Returns early from the current function with `Result::Err(e)`.
`panic`	Aborts with a message: `panic "message"`.
`typeof`	Gives the static type of an expression as a `string`, at compile time.
`comptime`	Computes an expression while compiling; the program gets its value.
`enum`	Declares a sum type: a value is exactly one of its variants.
`match`	Compares a value against patterns and evaluates the first arm that matches.
`default`	The catch-all arm of a `match`: `default => …`.
`type`	Declares a type alias, or an associated type in a trait or `impl`.
`use`	Imports items from a module, or lists the outer variables a lambda or `defer` captures.
`as`	Renames an import, or converts a value between primitive types.
`mod`	Loads a module file without importing any of its names: `mod name;`.
`extern`	Binds C functions from a native library at compile time: `extern "lib" { fn …; }`.
`class`	Declares a class: a named heap type with fields, constructed with `new`.
`impl`	Adds methods to a type (`impl Type { … }`) or implements a trait for it (`impl Trait for Type { … }`).
`pub`	Makes a class field or method accessible from outside the type.
`new`	Constructs a class instance: `new Class(args)`.
`defer`	Schedules a block to run when the enclosing function exits.
`true`	The `bool` value true.
`false`	The `bool` value false.
`gen`	Declares a generator function (a coroutine): `gen fn name(…) { … }`.
`async`	Removed.
`yield`	Suspends a generator and hands a value to the code that resumed it.
`resume`	Runs a coroutine until its next `yield` or its end, and gives the yielded or returned value.
`with`	Sends a value into a coroutine as part of `resume`: `resume h with value`.
`where`	Adds trait constraints to a generic function: `where Trait<A, B>`.
`pure`	Declares that a function has no effects: `pure fn name(…)`.
`uses`	Declares the effects a function may have: `uses {read, write}`.
`requires`	States a precondition, checked when the function is entered: `requires cond, "message"`.
`ensures`	States a postcondition, checked on every return: `ensures cond, "message"`.
`invariant`	States a condition that must always hold for a class’s instances, or each time a loop tests its condition.
`decreases`	States an `int` that every iteration of a `while` loop makes smaller, without going negative.
`trait`	Declares a trait: a set of functions that types implement with `impl Trait for Type`.
`test`	Declares a test case run by `coil test`: `test("name") { … }`.
`forall`	Writes a polymorphic (higher-rank) function type: `forall T. T -> T`.
`from`	Delegates a generator to another coroutine: `yield from other()`.
`struct`	Declares a C struct layout for FFI: `extern struct Name { field: type, … };`.
`attr`	Declares an attribute macro: `attr name(FnDecl f, …) -> Code { … }`.
`derive`	Declares a derive macro: `derive Name(TypeDecl t) -> Code { … }`, used as `#[derive(Name)]`.
`macro`	Declares a function-style macro: `macro name(Expr a, …) -> Code { … }`, used as `name!(…)`.
`quote`	Builds generated code inside a macro: `quote items\|expr\|stmts\|type { template }`.
`attrs`	Lists the field and variant attributes a derive macro owns: `derive Name(TypeDecl t) -> Code attrs(names) { … }`.
`done`	Tells whether a coroutine has finished: `done(handle)` returns a `bool`.
`self`	The receiver of a method: the instance the method was called on.
`result`	The value being returned, inside an `ensures` clause.
`old`	The value an expression had when the function was entered, inside an `ensures` clause: `old(e)`.
`Constraint`	The kind of a constraint, in a kind annotation: `c: * -> Constraint`.