Learn

A tour of the language

Everything you need to read Grasm, in order.

Bindings

let binds; var binds something you may reassign. Types are inferred and may be written.

let n = 1 + 2
let x: f64 = 2          // an integer literal becomes a float where one is wanted
var total = 0
total = total + n

Types

There is no null. Something that may be absent is an Option, and the compiler makes you open it.

Control

let label = if n > 0 { "positive" } else { "not" }

match value {
    Some(v) -> print("{v}")
    None    -> print("nothing")
}

for i in 0..3 { }
for v in [1, 2, 3] { }
while more { }

if and match are expressions. A match must cover its subject, and the compiler says which case is missing.

Functions and closures

fn twice(n: i64) -> i64 {
    n * 2
}

let f = |n| n + 1                 // a closure captures by value, at creation
let g: fn(i64) -> i64 = twice     // a function is a value

[1, 2, 3].map(twice)
3 |> twice                        // the same call, written the other way

Generics

type Stack[T] = { items: [T] }

fn same[T](v: T) -> T {
    v
}

Generics are monomorphised: one compiled copy per member of the family. The one thing this cannot do is polymorphic recursion, and it is refused by name rather than miscompiled.

Parameters

Next