Function values and closures

// A `fn`-typed parameter takes a lambda or a named function. Every use is
// monomorphized, so no function value survives to run time.
import { map, filter, fold } from "std/arrays"
import { joinWith } from "std/strings"

fn double(n: Int64) -> Int64 {
    return n * 2
}

export fn demo() -> String {
    let nums: Array<Int64> = [1, 2, 3, 4, 5]
    let doubled = map(nums, double)
    let evens = filter(nums, x -> x % 2 == 0)
    let total = fold(nums, 0, (acc, x) -> acc + x)

    return joinWith([
        "doubled last \{doubled[4]}",
        "evens        \{evens.length}",
        "total        \{total}",
    ], "\n")
}

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

// A `fn` type is storable: a let, a record field, an array. A lambda that reads
// an outer local carries a copy of it, taken where the lambda is written.
import { joinWith } from "std/strings"

type Transform = fn(Int64) -> Int64

fn makeAdder(n: Int64) -> Transform {
    return x -> x + n
}

export fn demo() -> String {
    let tenfold: Transform = x -> x * 10
    let addFive = makeAdder(5)
    let steps: Array<Transform> = [tenfold.copy(), addFive.copy()]

    let mut value = 1
    for step in steps {
        value = step(value)
    }

    return joinWith(["tenfold 4 is \{tenfold(4)}", "add five to 4 is \{addFive(4)}", "both, from 1, give \{value}"], "\n")
}

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