Language reference

Declare values, shadow names, and manage resources with use.

Built-in types, type annotations, constraints, and casts.

Handle null, narrow with patterns, and suppress nullability.

Write strings, numbers, tuples, default values, and type expressions.

Create collections and spread elements into them.

How expressions produce values and acquire their types.

Look up operator order, indexing, arithmetic, and comparisons.

Declare functions, return values, and capture local state.

Write anonymous functions and pass behavior as a value.

Invoke functions and methods with positional or named arguments.

Define signatures and choose among overloads.

Declare callable .NET types.

Pass a value through a sequence of calls.

Choose an object-oriented type and find its member rules.

Initialize types, declare fields, and control visibility.

Declare data types with record semantics.

Model alternatives with case-specific payloads.

Declare named constant values.

Define contracts implemented by types.

Declare storage and computed properties, indexers, and events.

Extend types, override members, and define closed hierarchies.

Add members to existing types.

Construct values and copy them with changes.

Test values and bind their parts.

Write match arms and guards.

Match constants, types, ranges, and comparisons; capture with let.

Match collections and object properties.

Match positional values and union payloads.

Match keys and values in dictionaries.

Understand missing cases and complete matches.

Choose a branch, loop, or transfer of control.

Branch on conditions and iterate over values.

Update storage and use expressions as statements.

Return from functions and produce iterator values.

Control iteration and jump to labels.

Declare asynchronous functions and await work.

Throw exceptions and handle them with structured blocks.

Capture exceptions as values and propagate absence or errors.

Read token, identifier, comment, and trivia rules.

Understand the basic parts of a Raven program.

Organize names and import types or members.

Start an executable and organize file-level code.

Consult the non-normative EBNF syntax grammar.

Expand syntax and use attached or freestanding macros.

Find memory and low-level programming features.

Work with spans and stack-allocated memory.

Understand references, lifetimes, and escape restrictions.

Use pointers and call native code.

See how Raven constructs map to the CLR.