Keyword	Usage
and	Logical AND (short-circuit): x and y
as	Type cast: x as f64
break	Exit enclosing for loop: break if i >= 10
catch	Inline error handling: expr catch err { fallback }
const	Compile-time constant: const N: i64 = 42
ctl	Control effect operation (captures continuation)
data	Declare a data type (sum type): Point :: data .{ .x: i32, .y: i32 }
effect	Declare an algebraic effect
else	Default arm: else => ..., or inline: if x then a else b
error	Error set modifier: data E = error ..., or error value: error.NotFound
false	Boolean literal
final	Final effect operation (never resumes)
fn	Declare a function, or a tail-resumptive effect operation
forall	Universal quantifier for scoped type variables: forall<s> fn() -> ...
handler	Define an effect handler
if	Conditional: if x > 0 then ..., guard-style: if { cond => ... }, postfix: break if x
ignot	Package/crate root in paths
in	Named effect containment: named effect ref<s, a> in heap<s>
let	Bind an immutable value to a name
for	Loop: for, for cond, for i in 0..n, for x in coll, for x, i in coll, for x in coll where f(x)
mask	Hide an effect from the current scope
match	Pattern matching: match x { pat => body }
mod	Declare a module
named	Named effect modifier: named effect ref<s, a>
nil	Absence of value (for ?T optional types)
not	Logical NOT: not x
or	Logical OR (short-circuit): x or y
orelse	Optional default: expr orelse fallback
override	Re-handle an effect in scope
pvt	Mark an item as private (public by default)
resume	Resume continuation in ctl handler: resume(value)
return	Return a value from a function early: return error.X if cond
scoped	Scoped effect modifier: scoped effect heap<s::S>
super	Parent module in paths
then	Inline if branch: if cond then expr else expr
true	Boolean literal
try	Error propagation: try expr
type	Declare a type alias: type Id = i32
unsafe	Unsafe block
use	Import items from a module
var	Mutable binding: var x = 5
with	Install an effect handler

Symbol	Usage
@	Intrinsic prefix: @add(x, y), @sizeof(T)
!	Error union type prefix: !T
?	Optional type prefix: ?T
=>	Arm separator in match/if: pattern => body
#[...]	Attribute annotation
|...|	Lambda parameters: |x| x + 1
|	Pipe separator in data variants: data Color = Red | Green
::	Path separator or kind annotation: Foo::bar, s::S
..	Spread in literals, range in patterns
->	Return type separator
<-	Handler binding: with r <- named handler
_	Wildcard pattern