value

type struct Name { ... }
type enum Name { ... }
type trait Name { ... }
type union Name { ... }

Begins a type declaration; the keyword that follows says which kind. On its own, type Name = Existing; declares an alias.

type enum Name {
    Unit,
    Payload(T),
    Named { x: i32 },
}

An algebraic data type. Variants may be bare or carry a tuple or struct payload, and a match on an enum must cover every variant. Name::Variant names a variant; methods are added with implement enum Name { ... }.

type enum JsonValue {
    Null;
    Bool(boolean);
    Number(JsonNumber);
    String(String);
    Array(Array<JsonValue>);
    Object(JsonObject);
}

One JSON value. Recursive through Array and Object.

primitive boolean

true / false. Not interchangeable with integers. 1 byte.

type enum JsonNumber {
    Int(i64);
    UInt(u64);
    Float(f64);
}

JSON's single number type, split by source representation so integers round-trip exactly. Int covers signed values that fit i64; UInt carries values in (i64::MAX, u64::MAX]; everything else (decimals, exponents, NaN-shaped inputs the parser accepts as floats) is Float.

type struct String<A = GlobalAlloc> {
    buffer: RawBuffer<u8, A>;
    length: u64;
}

String: owned, heap-allocated, length-typed UTF-8.

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

Array<T, A>: growable, heap-backed, contiguous sequence.

type enum JsonValue {
    Null;
    Bool(boolean);
    Number(JsonNumber);
    String(String);
    Array(Array<JsonValue>);
    Object(JsonObject);
}

One JSON value. Recursive through Array and Object.

type struct JsonObject {
    keys: Array<String>;
    values: Array<JsonValue>;
    index: HashMap<String, u64>;
}

JSON object. Insertion-ordered keys + parallel value array; a HashMap from String to slot index gives O(1) lookup. Owning; callers must drop before discarding.

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

Adds methods to a type outside its declaration. implement struct T (or enum, or a bare primitive) opens an inherent block; implement trait Tr for T supplies a trait's methods for one type. Resolution is at compile time - no dynamic dispatch.

implement enum Name { ... }

Names the enum an inherent block extends - the only way to give an enum methods.

static name(param: Type) -> Ret { ... }

A method that belongs to the type rather than an instance, called as Type::name(..). For structs, static new(..) returning a struct literal is the idiomatic constructor.

primitive i64

64-bit signed integer.

primitive u64

64-bit unsigned integer.

primitive f64

Double-precision IEEE 754 float.

static JsonValue::string_value(s: String) -> JsonValue

Take ownership of s.

// reserved

A reserved keyword with no syntax of its own in the current grammar. The standard library uses it freely as a method and parameter name (Str::from, from: u64).

static JsonValue::string_array(items: &[string]) -> JsonValue

JSON array of strings from a raw [string]. Each element is escaped at serialize time.

primitive string

NUL-terminated raw string (u8*), matching the C ABI. Length-typed text is Str / String.

&this
mut &this
this

The receiver of a method. Its first parameter declares how the method takes it: &this borrows read-only, mut &this borrows exclusively, and this / mut this move the value in and consume it. In the body, this.field reaches the members.

JsonValue::get(&this, key: Str) -> Option<JsonValue*>

obj.get("key") for object variants; None for everything else.

type struct Str {
    bytes: u8*;
    length: u64;
}

Str: a borrowed UTF-8 string slice.

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

Option: a value that may be absent.

JsonValue::at(&this, index: u64) -> Option<JsonValue*>

Array index access.

JsonValue::length(&this) -> u64

Number of children (object entries / array elements). 0 for scalars.

type trait Name : Base {
    method(&this, other: &This) -> Ret;
}

Names a set of methods a type may implement. Inside the body This is the implementing type; methods may carry default bodies, and a trait may require a base trait (type trait Ord : Eq). Generic code asks for a trait with where T: Name.

type trait JsonExtract {
    as<T>(&this) -> Option<T>
    where T: TryFrom<&JsonValue>;
}

Typed scalar extraction from a JsonValue, dispatched on the requested type T. json.as<i64>() yields Some when the value is a number representable as i64, else None; likewise as<boolean>, as<u64>, as<f64>, and as<Str> (a borrow into the value's owned string, valid for the JsonValue's lifetime).

value as Type

Explicit conversion: between numeric types, or reinterpreting one pointer type as another. Cryo never converts implicitly, and as inserts no range checks - a narrowing cast is the programmer's responsibility.

where T: Ord + Clone, U: Hash

Constrains generic parameters to types that implement the listed traits, which is what makes those traits' methods callable on T. Bounds on one parameter join with +; parameters separate with ,. A where on a single method narrows the type's parameter for that method only.

const NAME: Type = value;

At module level, a true compile-time constant, conventionally SCREAMING_SNAKE_CASE. (mut at module level declares mutable global state instead.)

static Str::new(text: string) -> Str

Construct from a NUL-terminated C-style string literal. The caller certifies that text is valid UTF-8 and outlives this view. The NUL terminator is not included in the view.

type enum JsonNumber {
    Int(i64);
    UInt(u64);
    Float(f64);
}

JSON's single number type, split by source representation so integers round-trip exactly. Int covers signed values that fit i64; UInt carries values in (i64::MAX, u64::MAX]; everything else (decimals, exponents, NaN-shaped inputs the parser accepts as floats) is Float.

JsonNumber::as_i64(&this) -> Option<i64>

Try to view as a signed 64-bit integer. UInt values that exceed i64::MAX and any Float with a fractional component return None.

JsonNumber::as_u64(&this) -> Option<u64>

Try to view as an unsigned 64-bit integer.

JsonNumber::as_f64(&this) -> f64

Always-succeeds f64 view. Int/UInt values larger than 2^53 lose precision in the conversion.

type struct Name {
    field: Type;
    method(&this) -> Ret { ... }
}

A value type with named fields and optional methods. Structs live on the stack and are passed by value. Fields are public by default and may carry = default values; methods take their receiver as &this, mut &this, or this.

type struct JsonObject {
    keys: Array<String>;
    values: Array<JsonValue>;
    index: HashMap<String, u64>;
}

JSON object. Insertion-ordered keys + parallel value array; a HashMap from String to slot index gives O(1) lookup. Owning; callers must drop before discarding.

type struct HashMap<K, V, A = GlobalAlloc> where A: Allocator {
    buckets: Entry<K, V>**;
    bucket_count: u64;
    length: u64;
    alloc: A;
    seed: u64;
}

HashMap<K, V, A>: key-value map with amortized O(1) operations.

JsonObject::insert(mut &this, key: String, value: JsonValue) -> void

Insert or overwrite the entry for key. Takes ownership of both the key String and the value. If the key already exists, the previous value is dropped and the slot reused.

mut &this
mut &Type

An exclusive, mutating borrow. As a receiver, mut &this lets the method modify the fields - and callers can see that from the signature alone. As a parameter type, mut &T lets the callee mutate through the reference while the caller keeps ownership.

primitive void

No value; only valid as a return type.

JsonObject::put(mut &this, key: string, value: JsonValue) -> void

Insert with a raw NUL-terminated string (C-string) key, interned to an owned String internally. The ergonomic shortcut for the common insert(String::from_str(Str::from(k)), v).

JsonObject::get(&this, key: Str) -> Option<JsonValue*>

Look up a value by key. Returns a borrowed pointer that is valid until the next mutating operation.

JsonObject::key_at(&this, index: u64) -> Option<Str>

Borrow the key at index. Returns None if index is out of range.

JsonObject::value_at(&this, index: u64) -> Option<JsonValue*>

Borrow the value at index.

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

Brings a module, or selected items from it, into scope. One path per declaration: use the brace form for several items, as to alias, and * for everything public (prefer the brace form; wildcards invite name collisions).

namespace std;

std: the Cryo standard library.

namespace std::json;

json: RFC 8259 JSON parser and serializer.

namespace std::json::value;

JsonValue: tagged union over the six JSON types.

JsonObject::drop(mut &this) -> void

via trait Drop

static JsonValue::string_value(s: String) -> JsonValue

Take ownership of s.

static match (T) { ... }

Opens a compile-time match on a type parameter: the one arm whose type matches is kept during monomorphisation and the rest are discarded.

static match (T) {
    u8 | u16 => { ... }
    _        => { ... }
}

Selects a body by inspecting a type parameter at compile time. The subject is a type and each arm is a type (| groups several; _ takes the rest). During monomorphisation the one matching arm is kept and the others discarded, so there is no runtime branch.

static JsonValue::string_array(items: &[string]) -> JsonValue

JSON array of strings from a raw [string]. Each element is escaped at serialize time.

JsonObject::get(&this, key: Str) -> Option<JsonValue*>

Look up a value by key. Returns a borrowed pointer that is valid until the next mutating operation.

JsonValue::at(&this, index: u64) -> Option<JsonValue*>

Array index access.

type trait JsonExtract {
    as<T>(&this) -> Option<T>
    where T: TryFrom<&JsonValue>;
}

Typed scalar extraction from a JsonValue, dispatched on the requested type T. json.as<i64>() yields Some when the value is a number representable as i64, else None; likewise as<boolean>, as<u64>, as<f64>, and as<Str> (a borrow into the value's owned string, valid for the JsonValue's lifetime).

implement trait Trait for Type { ... }

Introduces a trait implementation: the block supplies, for one concrete type, the method bodies the trait requires.

implement trait Trait for Type { ... }

Names the type a trait implementation is for. The block that follows supplies the bodies the trait requires.

type trait Drop {
    drop(mut &this) -> void;
}

Drop: explicit destructor.

primitive u32

32-bit unsigned integer.

primitive u16

16-bit unsigned integer.

primitive u8

8-bit unsigned integer.

primitive i32

32-bit signed integer.

primitive i16

16-bit signed integer.

primitive i8

8-bit signed integer.

JsonNumber::as_i64(&this) -> Option<i64>

Try to view as a signed 64-bit integer. UInt values that exceed i64::MAX and any Float with a fractional component return None.

JsonNumber::as_u64(&this) -> Option<u64>

Try to view as an unsigned 64-bit integer.

JsonNumber::as_f64(&this) -> f64

Always-succeeds f64 view. Int/UInt values larger than 2^53 lose precision in the conversion.

JsonObject::insert(mut &this, key: String, value: JsonValue) -> void

Insert or overwrite the entry for key. Takes ownership of both the key String and the value. If the key already exists, the previous value is dropped and the slot reused.

JsonObject::put(mut &this, key: string, value: JsonValue) -> void

Insert with a raw NUL-terminated string (C-string) key, interned to an owned String internally. The ergonomic shortcut for the common insert(String::from_str(Str::from(k)), v).

JsonObject::key_at(&this, index: u64) -> Option<Str>

Borrow the key at index. Returns None if index is out of range.

JsonObject::value_at(&this, index: u64) -> Option<JsonValue*>

Borrow the value at index.

static String::from_str(source: Str) -> String

Construct from a Str by copying its bytes. Panics on allocation failure.

static Str::from<T>(src: T) -> Str

Construct a Str view from a text source, dispatched on T at compile time: - string - a NUL-terminated C-string (literal or an i8*/u8* cast to string); length via strlen, the NUL is not part of the view. - Slice<u8> - an existing byte slice, borrowed verbatim.