keywords

Reserved Keywords (α1)

These identifiers are reserved and cannot be used as variable, function, or type names:

Declarations

Keyword	Purpose
`const`	immutable binding
`var`	mutable binding
`function`	function declaration
`type`	type alias/definition
`error`	error type declaration
`domain`	error domain declaration
`capability`	capability declaration
`impl`	implementation block

Modifiers

Keyword	Purpose
`inout`	by-reference parameter
`export`	public symbol
`import`	module import
`package`	package declaration
`use`	module-level defaults
`effects`	effect declaration
`cap`	capability parameter
`pub`	public visibility
`opaque`	opaque type modifier

Control Flow

Keyword	Purpose
`if`	conditional
`else`	conditional branch
`match`	pattern matching
`check`	unwrap result, used with `match check`
`for`	iteration
`while`	loop
`break`	exit loop
`continue`	skip iteration
`return`	function return
`defer`	deferred execution
`scope`	scoped effect handler block
`on`	effect handler clause in scope blocks
`propagate`	re-raise an effect in a handler
`retry`	re-enter a scope block

Error Handling

Keyword	Purpose
`ok`	success construction
`err`	error construction
`check`	unwrap or propagate
`ensure`	guard clause

Type System

Keyword	Purpose
`where`	type constraints/refinement
`is`	type narrowing
`in`	contravariant
`out`	covariant
`infer`	type inference in conditionals
`map`	mapped types
`distribute`	distributive conditional

Compile-Time

Keyword	Purpose
`comptime`	compile-time evaluation
`when`	conditional compilation block

Memory and Safety

Keyword	Purpose
`unsafe`	unsafe block
`move`	explicit ownership transfer
`copy`	explicit copy annotation
`clone`	explicit clone
`static`	static allocation

Other

Keyword	Purpose
`with`	context/capability modifier
`context`	context ledger
`as`	aliasing
`asm`	inline assembly
`component`	wasm component
`unknown`	dynamic type requiring narrowing
`Unit`	unit type/value

Planned Keywords (α2)

Keyword	Purpose
`derive`	auto-derive implementations
`test`	test block declaration
`packed`	packed struct layout
`extern`	c-compatible struct layout
`transmute`	bit reinterpretation

Removed Keywords

These were in earlier drafts but are not in α1:

Removed	Reason
`role`	replaced by record-based polymorphism
`trait`	never used
`self`	functions use explicit first parameter
`fn`	use `function` for all functions
`===`	use `==` for equality (no triple equals)
`!==`	use `!=` for inequality
`null`	use `None` variant of `Maybe<T>` instead
`unsafe_cast`	replaced by `unsafe` block + transmute
`error` (as function clause)	replaced by `fail<E>` in effects; `error` keyword still used for error type declarations

Contextual Keywords

Some identifiers have special meaning only in specific contexts:

Identifier	Context	Meaning
`self`	refinement `where` clause	the value being refined
`to`	`view.move`, `view.copy`	destination parameter
`using`	`map_error`	transform function
`volatile`	inline assembly	prevent optimization
`clobber`	inline assembly	register clobber list
`mut`	`View<mut T>`	mutable view
`fail`	effects list `fail<E>`	fallible effect
`suspend`	effects list	suspension effect
`yield`	generator functions	yield a value
`parallel`	scope block kind	parallel execution
`race`	scope block kind	first-to-finish execution
`blocking`	scope block kind	blocking scope
`timeout`	scope block kind	timeout-bounded scope
`transaction`	scope block kind	transactional scope

These can still be used as regular identifiers outside their special contexts.

Literals

Literal	Type
`true`	`Bool`
`false`	`Bool`
`Unit`	`Unit` type value

Note: None is not a literal but a union variant constructor for Maybe<T>. Use None directly when constructing optional values: const x: u32? = None;

Operators as Keywords

These are operators, not keywords, but are reserved:

+ - * / %
& | ^ ~ << >>
&& || !
== != < <= > >=
++ 
-> =>
...

On this page