Generic method

// A generic type gets methods the same way any type does, through `extend`. The block is
// written `extend Labeled<T>`, and that `T` is in scope for every method inside it: one block
// serves `Labeled<int32>`, `Labeled<char8[..]>` and every other instantiation.
//
// A method may also declare a type parameter of its own, which is chosen at each call and has
// nothing to do with the type's. `With<U>` below pairs the stored `T` with a `U` that can be
// different every time it is called.
import Io::PrintLine;

// A value with a name attached to it.
struct Labeled<T> {
    label: char8[..];
    value: T;
}

extend Labeled<T> {
    // A constructor, as for any struct. It returns the instantiation it was called on.
    func Labeled(label: char8[..], value: T) -> Labeled<T> {
        return Labeled<T> { label: label, value: value };
    }

    func Get(self: &Labeled<T>) -> T {
        return self.value;
    }

    func Set(self: &var Labeled<T>, value: T) {
        self.value = value;
    }

    // `T` comes from the receiver; `U` comes from this call's argument.
    func With<U>(self: &Labeled<T>, other: U) -> (T, U) {
        return (self.value, other);
    }

    // The result can be a different instantiation of the same type: a `Labeled<T>` becomes a
    // `Labeled<U>`, keeping its label and changing its value through `change`.
    func Map<U>(self: &Labeled<T>, change: func(T) -> U) -> Labeled<U> {
        return Labeled<U> { label: self.label, value: change(self.value) };
    }
}

func Half(value: int32) -> float64 {
    return (value as float64) / 2.0;
}

func IsLarge(value: int32) -> bool {
    return value > 100;
}

func Main() -> int {
    // The type argument goes on the type name, then the constructor runs as usual.
    var count = Labeled<int32>("count", 7);
    count.Set(15);
    PrintLine("{} = {}", count.label, count.Get());

    // `U` is inferred from the argument, or written out after the method name.
    let fruit = count.With("apples");
    let flag = count.With<bool>(true);
    PrintLine("with     {} {}", fruit.0, fruit.1);
    PrintLine("with     {} {}", flag.0, flag.1);

    // `U` inferred from the callback's result type.
    let half = count.Map(Half);
    let large = count.Map(IsLarge);
    PrintLine("{} / 2 = {}", half.label, half.Get());
    PrintLine("{} > 100 is {}", large.label, large.Get());
    return 0;
}