Collections and Map

// An array is subject-first: `xs.push(x)`, `xs[i]`, `xs.length`, `xs.pop()`.
// `pop` answers `Option`, because an empty array has nothing to give.
import { joinWith } from "std/strings"

export fn demo() -> String {
    let mut xs: Array<Int64> = [1, 2, 3]
    xs.push(4)
    xs[0] = 10

    let mut total = 0
    for x in xs {
        total = total + x
    }

    let last = match xs.pop() {
        Some(v) => v.toString(),
        None => "nothing",
    }

    return joinWith(["length \{xs.length}", "total \{total}", "popped \{last}"], "\n")
}

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

// `Map<String, V>` keeps insertion order. A lookup answers `Option<V>`, so a
// missing key is a value you handle and never a null you forget.
import { joinWith } from "std/strings"

fn score(m: Map<String, Int64>, k: String) -> String {
    return match m[k] {
        Some(v) => v.toString(),
        None => "none",
    }
}

export fn demo() -> String {
    let mut scores: Map<String, Int64> = [:]
    scores["ada"] = 5
    scores["grace"] = 8
    scores["ada"] = 6 // an update keeps the original slot

    let mut order: Array<String> = []
    for k in scores.keys() {
        order.push(k)
    }
    let keys = joinWith(order, ", ")
    let ada = score(scores, "ada")
    let hopper = score(scores, "hopper")

    return joinWith([
        "keys    \{keys}",
        "ada     \{ada}",
        "hopper  \{hopper}",
        "length  \{scores.length}",
    ], "\n")
}

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