6Control Flow

6.1 If / Else#

Conditions are parenthesised and bodies are always braced; there is no single-statement form.

import std::fmt::{ println };

if (x > 0) {
    println("positive");
} else if (x < 0) {
    println("negative");
} else {
    println("zero");
}

if may also be used as an expression that evaluates to the value of the chosen branch. When used this way, both arms are required and must produce the same type. An arm that is null converts to any pointer, so the expression has the other arm's type, whichever arm the null is in: if (c) { null } else { b } is a B* for b: B*, and is refused where an unrelated pointer type is declared. The conditional form c ? x : y follows the same rule.

const is_even: boolean = if (n % 2 == 0) { true } else { false };

The expression form has exactly two arms and no else if chain: if (a) { 1 } else if (b) { 2 } else { 3 } is a parse error in expression position. Nest the second if inside the else arm's braces, or use a match:

const sign: i32 = if (n > 0) { 1 } else { if (n < 0) { -1 } else { 0 } };

else if is fine in the statement form above.

6.2 While Loops#

import std::fmt::{ printf };

mut i: int = 0;
while (i < 10) {
    printf("%d\n", i);
    i = i + 1;
}

6.3 For Loops#

A C-style for with three components: declare-initialiser, condition, post-update. The loop variable is scoped to the loop body.

import std::fmt::{ printf };

for (mut i: int = 0; i < 10; i++) {
    printf("%d\n", i);
}

for (x in <expr>) iterates a sequence. The expression is evaluated exactly once and bound to a hidden mutable local; the parser lowers the loop to a loop { match (iter.next()) { Some(x) => { ... } None => break; } }, where next is std::core::iter::Iterator's and Some/None are std::core::option::Option's - a module that declares its own Option or Iterator changes nothing about the loop. break, continue, and return inside the body bind to the synthesised loop, and the iterator binding is dropped at the end of the enclosing block.

The scrutinee may be:

• An Iterator directly - a type that implement trait Iterator<T>, including the stdlib's Range<T> / RangeInclusive<T>, or a type parameter bounded by Iterator. A method that is merely spelled next does not make a type iterable: the loop refuses it (E0306, "does not implement Iterator").
• A range literal a..b (half-open) or a..=b (inclusive). These are sugar for Range::new(a, b) / RangeInclusive::new(a, b); see the precedence table in section 5.7.
• An iterable that exposes iter() returning an iterator - Array<T> and Slice<T> (their iter() is gated where T: Copy). The lowering inserts the .iter() call.
• A fixed-size array [T; N]. The lowering views it as a Slice<T> over its N elements.

mut sum: i32 = 0;
for (i in 0..5) {            // range literal; 0,1,2,3,4
    sum = sum + i;
}
// sum == 10

const xs: [i32; 3] = [7, 8, 9];
for (x in xs) {              // fixed-size array
    sum = sum + x;
}

Range literals are ordinary expressions and may appear anywhere, not only in a for header: const r: Range<i32> = 2..7;. .. binds looser than the arithmetic operators, so a..b + 1 parses as a..(b + 1).

6.4 Loop#

loop { ... } is an unconditional infinite loop. Prefer it over while (true); it communicates "this runs until something inside breaks out" without misdirection.

import std::fmt::{ printf };

mut count: int = 0;
loop {
    if (count >= 5) { break; }
    printf("%d\n", count);
    count = count + 1;
}

6.5 Do-While#

do {
    body();
} while (condition);

The body executes at least once, then the condition is checked.

6.6 Break and Continue#

break exits the innermost loop. continue skips to the next iteration.

import std::fmt::{ printf };

for (mut i: int = 0; i < 20; i++) {
    if (i % 2 == 0) { continue; }
    if (i > 10)     { break; }
    printf("%d\n", i);
}

6.7 Match: Statement Form#

match is the language's primary discriminator. It branches on enum variants, integer values, and other patterns; the compiler enforces that every case is covered.

import std::fmt::{ println };

match (color) {
    Color::Red   => { println("red"); }
    Color::Green => { println("green"); }
    Color::Blue  => { println("blue"); }
}

There is no fallthrough between arms. See section 7 for the full pattern language.

6.8 Match: Expression Form#

Used as an expression, match evaluates to the value of the matching arm. All arms must produce the same type.

const name: string = match (n) {
    1 => { "one" }
    2 => { "two" }
    _ => { "other" }
};

6.9 Ternary#

const abs: int = x >= 0 ? x : -x;

The ternary is right-associative: a ? b : c ? d : e parses as a ? b : (c ? d : e).

6.10 Return#

function add(a: int, b: int) -> int {
    return a + b;
}

return exits the current function. If the function has a non-void return type, a value is required.

6.11 Unsafe Blocks#

unsafe { ... } is recognised at parse time and lowers identically to a plain block. It serves as a documentation marker: a visible signal that the enclosed code performs raw pointer arithmetic, calls extern functions, or otherwise sits at the edge of the language's safety story. The compiler does not currently impose any extra restriction outside an unsafe block, and does not relax any check inside one - every operation Cryo permits today is permitted everywhere.

import std::core::intrinsics::{ malloc };

unsafe {
    const raw: void* = malloc(64);
    // raw pointer manipulation here
}

This is the committed 1.0 behavior: unsafe is a documentation marker and nothing more. It is not reserved to silently become enforcing - 1.0 code will not break under a future release on account of unsafe. Should later versions add safety checks around raw pointer dereference, raw-to-pointer as-casts, or extern calls, they would arrive compatibly (as an opt-in lint/warning first), not as a breaking change to code that already compiles.

6.12 Inline Assembly#

asm { ... } embeds target assembly directly, lowering to an LLVM inline-assembly call. The block body is raw assembly - written without string quoting - and Cryo values are bound into it through ${ ... } operand holes. Bare { and } are literal assembly text, so target syntax that uses braces (AVX-512 mask registers such as {k1}, for instance) passes straight through.

A mandatory ![arch(<arch>, <dialect>)] directive must appear immediately above the block. It names the target architecture (which gates the block - see below) and the assembly dialect (intel or att):

![arch(x86_64, intel)]
asm {
    mov ${=out}, ${in}
}

Operands. Each ${ ... } hole binds a Cryo variable. A prefix selects its direction and an optional : suffix pins a register or constraint class:

Referencing the same variable more than once collapses to a single operand, and a variable used as both an input and an output is promoted to in-out. Operands must be register-sized scalars or pointers.

Clobbers. Registers, flags, or memory that the block overwrites but doesn't name as operands are declared with ![clobber(...)], so the compiler doesn't assume their values survive the block:

![arch(x86_64, intel)]
![clobber(rcx, r11, flags, memory)]
asm {
    mov rax, ${v}
    add rax, rax
    mov ${=out}, rax
}

Outputs and results. An asm block is a statement; values leave it through ${=x} / ${+x} operands, and a block may have any number of outputs.

Dialects. intel is destination-first and prefix-less (mov rax, 60); att is source-first with % registers and $ immediates (movq $60, %rax). The dialect is always stated explicitly in the ![arch(...)] directive.

Arch gating. <arch> is matched against the compile target: a block whose arch differs from the target is dropped, exactly like a ![linux] / ![windows] gate. This lets per-architecture blocks sit side by side, each written for its own target:

![arch(x86_64, intel)]
asm { syscall }

![arch(aarch64, att)]
asm { svc #0 }

Module-level assembly. An asm { ... } written at module scope (outside any function, with no operands) emits module-level inline assembly - for naked/global stubs, .globl symbols, or raw data.

A write system call on x86_64 Linux, pulling the buffer and length in as operands:

![arch(x86_64, att)]
![clobber(rcx, r11, memory)]
asm {
    movq $1, %rax        // SYS_write
    movq $1, %rdi        // fd = stdout
    movq ${buf}, %rsi    // buffer pointer
    movq ${len}, %rdx    // length
    syscall
}

Note. LLVM passes the assembly text through to the target assembler unchanged - Cryo does not parse it - so a typo in a mnemonic or register name surfaces as an assembler error at build time, not a Cryo diagnostic. Only ${ ... } introduces an operand; a literal $ (an AT&T immediate such as $60) and bare { / } are emitted verbatim.

import a::b;
import a::b::{ X, Y };
import a::b as c;
import a::b::*;

namespace std;

namespace std::fmt;

function println(text: String) -> void

if (condition) { ... } else if (condition) { ... } else { ... }

if (condition) { ... } else { ... }

const NAME: Type = value;

const is_even: boolean

primitive boolean

true

false

const sign: i32

primitive i32

function printf(fmt: string, args...) -> i32

mut name: Type = value;

mut i: int

primitive int

while (condition) { ... }

mut i: int

for (mut i: i32 = 0; i < n; i++) { ... }
for (item in iterable) { ... }

mut i: int

mut sum: i32

i

for (item in iterable) { ... }

start..end

mut sum: i32

i

const xs: [i32; 3]

x

const xs: [i32; 3]

x

mut count: int

loop { ... }

mut count: int

break;

do { ... } while (condition);

mut i: int

continue;

match (subject) {
    Pattern(x) => { ... }
    _          => { ... }
}

pattern => { body }

const name: string

primitive string

_

const abs: int

function name<T>(param: Type) -> Ret { ... }

function add(a: int, b: int) -> int

(parameter) a: int

(parameter) b: int

return value;

(parameter) a: int

(parameter) b: int

namespace std::core;

namespace std::core::intrinsics;

intrinsic function malloc(size: u64) -> void*

unsafe { ... }

const name: Type = value;

const raw: void*

primitive void

![arch(x86_64, intel)]
asm {
    mov ${=out}, ${in}
}

function add(a: int, b: int) -> int

extern "C" function syscall(number: Syscall, ...) -> i64

null

Option::Some(T)

function name(count: i32, args...)

Option::None

namespace std::core::iter;

type trait Iterator {
    type Item;
    next(mut &this) -> Option<This::Item>;
    count(mut &this) -> u64;
    fold<Acc>(mut &this, initial: Acc, f: (Acc, This::Item) -> Acc) -> Acc;
    for_each(mut &this, f: (This::Item) -> void) -> void;
    take(this, n: u64) -> TakeIter<This>;
    skip(this, n: u64) -> SkipIter<This>;
    map<B>(this, f: (This::Item) -> B) -> MapIter<This, B>;
    filter(this, pred: (&This::Item) -> boolean) -> FilterIter<This>;
    chain<J>(this, other: J) -> ChainIter<This, J>;
    // … 7 more
}

namespace std::core::option;

type enum Option<T> {
    Some(T);
    None;
}

implement struct Name { ... }
implement trait Trait for Type { ... }
implement u64 { ... }

implement trait Trait for Type { ... }

type struct Range<T> {
    start: T;
    end: T;
}

type struct RangeInclusive<T> {
    start: T;
    end: T;
    exhausted: boolean;
}

start..=end

static Range::new(start: T, end: T) -> Range<T>

static RangeInclusive::new(start: T, end: T) -> RangeInclusive<T>

type struct Array<T, A = GlobalAlloc> where A: Allocator {
    ptr: T*;
    length: i64;
    capacity: i64;
    alloc: A;
}

type struct Slice<T> {
    ptr: T*;
    length: u64;
}

where T: Ord + Clone, U: Hash

type trait Copy {}

const r: Range<i32>

extern function exit(code: i32) -> void;
extern "C" {
    function puts(s: string) -> i32;
}

value as Type