Vader

module "main"

import "std/io"
import "std/math"

// A sum type: `match` must cover every variant.
Shape :: Circle | Rect

Circle :: struct { radius: f64 }
Rect   :: struct { w: f64, h: f64 }

area :: fn(s: Shape) -> f64 = match s {
    is Circle -> pi * s.radius * s.radius
    is Rect   -> s.w * s.h
}

main :: fn() -> i32 {
    shapes: Shape[]: [
        Circle { .radius = 2.0 },
        Rect { .w = 3.0, .h = 4.0 },
    ]
    total := 0.0
    for s in shapes {
        total += s.area()          // UFCS: s.area() is area(s)
    }
    println("${shapes.len()} shapes, total area ${total}")
    return 0
}

2 shapes, total area 24.566370614359172

module "main"

import "std/io"
import "std/string"

// A failure is a value: `parse_int` returns `i32 | ParseError`,
// and the sum can be used only once the error is ruled out.
sum_of :: fn(text: string) -> i32 | ParseError {
    total := 0
    for field in text.split(",") {
        n :: parse_int(field.trim())
        if n is ParseError {
            return n
        }
        total += n
    }
    return total
}

main :: fn() -> i32 {
    for input in ["1, 2, 3", "4, five"] {
        result :: sum_of(input)
        if result is ParseError {
            println("${input}: ${result.msg}")
        } else {
            println("${input}: ${result}")
        }
    }
    return 0
}

1, 2, 3: 6
4, five: parse_int: invalid digit

module "main"

import "std/io"

squares :: fn(n: i32) -> i32[] {
    out: i32[]: []
    for i in 0..<n {
        out.push(i * i)
    }
    return out
}

// Computed by the compiler: the program holds the table, not the loop.
@comptime SQUARES :: squares(8)

main :: fn() -> i32 {
    println("${SQUARES}")
    return 0
}

[0, 1, 4, 9, 16, 25, 36, 49]

module "main"

import "std/io"
import "std/iter"

// A function with a `yield` is a generator: it produces its values
// one at a time, as the consumer asks for them.
fibonacci :: fn() -> Iterator<i64> {
    a: i64 = 0
    b: i64 = 1
    for {
        yield a
        next :: a + b
        a = b
        b = next
    }
}

main :: fn() -> i32 {
    evens :: fibonacci().filter(n -> n % 2 == 0).take(6).collect()
    println("${evens}")
    return 0
}

[0, 2, 8, 34, 144, 610]