Records, enums, match

// A record type is a shape. A value with more fields fits where fewer are
// wanted, with no cast and no inheritance.
import { joinWith } from "std/strings"

type Named = { name: String }
type User = { name: String, age: Int64 }

fn greet(who: Named) -> String {
    return "hello, \{who.name}"
}

export fn demo() -> String {
    let u = User { name: "Ada", age: 36 }
    let mut next = u.copy() // a copy, because both `u` and `next` are read below
    next.age = next.age + 1

    return joinWith([greet(u), "was \{u.age}", "now \{next.age}"], "\n")
}

fn main() -> Int64 {
    print(demo())
    return 0
}

// A value is exactly one variant. A variant may carry a payload, and `match`
// must cover every one — leave an arm out and the file does not compile.
import { joinWith } from "std/strings"

type Shape = enum {
    Circle(Int64),
    Rect(Int64, Int64),
    Point }

fn describeShape(s: Shape) -> String {
    return match s {
        Circle(r) => "circle of radius \{r}",
        Rect(w, h) => "rect \{w} by \{h}",
        Point => "a point",
    }
}

export fn demo() -> String {
    let shapes: Array<Shape> = [Circle(2), Rect(3, 4), Point]
    let mut out: Array<String> = []
    for s in shapes {
        out.push(describeShape(s))
    }
    return joinWith(out, "\n")
}

fn main() -> Int64 {
    print(demo())
    return 0
}

// `match` is an expression: it answers with a value, so a binding can take it
// directly. `if let` reads one variant when the others need no arm of their own.
import { joinWith, indexOf } from "std/strings"

type Level = enum {
    Info,
    Warn(String) }

fn found(haystack: String, needle: String) -> String {
    if let Some(at) = indexOf(haystack, needle) {
        return "\{needle} at byte \{at}"
    }
    return "\{needle} is not there"
}

export fn demo() -> String {
    let l: Level = Warn("disk is filling")
    let line = match l {
        Info => "nothing to say",
        Warn(what) => "warning: \{what}",
    }
    return joinWith([line, found("hello, world", "world"), found("hello, world", "zebra")], "\n")
}

fn main() -> Int64 {
    print(demo())
    return 0
}