Lists and loops

// A list, the loops that go with it, and a constant the whole file can name.
//
// `[a, b]`, `xs[i]`, `len`, `push` and `for … in` are language forms rather than a module, which is
// why there is no `std/collections`: a capability's parameter types are names in a data format a
// host writes, and a module function over `List<T>` would need a type variable there.

// A `let` at the top of a file is a constant. Its value is arithmetic over literals and other
// constants; a call is not allowed, because a module is evaluated before its host is bound and
// there would be nothing to call. Another file can import it the way it imports a function.
let CALM = 0.15
// Annotated, because `len` answers a `u32` and there is no implicit widening: a bare `3` here is
// an `f32` and comparing the two is refused by name.
let SAMPLES: u32 = 3

// `continue` skips to the next turn, `break` leaves the loop. There are no labels, so a jump
// always means the loop it is written in.
fn strongestGust(gusts: List<f32>) -> f32 {
    var best: f32 = 0
    for gust in gusts {
        if gust < CALM {
            continue
        }
        if gust > best {
            best = gust
        }
    }
    return best
}

// `push` needs a mutable binding, because growing a list writes to the container.
fn firstFew(gusts: List<f32>) -> List<f32> {
    var picked: List<f32> = []
    for gust in gusts {
        if len(picked) == SAMPLES {
            break
        }
        push(picked, gust)
    }
    return picked
}

// An index past the end throws, for the same reason integer overflow does: there is no value that
// would be right, and returning one would be inventing an answer.
fn opening(gusts: List<f32>) -> f32 {
    if len(gusts) == 0 {
        return 0
    }
    return gusts[0]
}

// Deliberately refused.
//
// A `List<Wolf>` is not a `List<Dog>`, even though a `Wolf` is a `Dog`. With covariance the call
// below would hand `adopt` a reference whose real list holds wolves, and pushing a plain `Dog` into
// it would put one in a list every reader believes is wolves.
//
// Record subtyping is sound in this language partly because that cannot happen: a record is read
// through its fields and a list can be written through.
//
// `:` before the brace is the base clause. It is not a new keyword, and a reader meets `:` here
// meaning "extends" and three lines later meaning "has type"; the position is what keeps the two
// apart, since a type annotation never follows a record's name.

data Dog {
    weight: f32
}

data Wolf: Dog {
    pack: u32
}

fn adopt(kennel: mut List<Dog>, arrival: Dog) -> u32 {
    push(kennel, arrival)
    return len(kennel)
}

fn release(pack: mut List<Wolf>, stray: Dog) -> u32 {
    return adopt(pack, stray)
}