(tulam)

type SizedVector(a:Type) =
    size:Nat * values:Vec(a, size);

type Showable = exists (a:Type).
    { value:a, display:a -> String };

value item : Showable =
    { value = 42, display = showInt };

unpack item as (a, x) in
    x.display(x.value)

algebra Monoid(a:Type)
    extends Semigroup(a) = {
    value empty : a;

    law leftIdentity(x:a) =
        combine(empty, x) === x;

    law rightIdentity(x:a) =
        combine(x, empty) === x
};

instance Monoid(PackedPolynomial) = {
    function combine(x, y) = intrinsic;
    value empty = intrinsic
};

effect Choice requires Resumption(Many) = {
    function choose[a:Type](options:List(a)) : a
};

handler FirstChoice : Choice = {
    function choose[a:Type](options:List(a)) =
        resume(head(options))
};

handle choose(values) with FirstChoice

type Source(a:Type) =
    None + Some * item:a;

function schema(code:DataCode(Unit, Z))
    : DataCode(Unit, Z) =
    renameDataType(code, "Generated");

type Generated(a:Type) =
    schema(dataCode(reflect(Source(a))));

instance Eq(Generated(a)) = derive;

function matrixMultiply(a:Matrix, b:Matrix)
    : Matrix on compute =
    portableMatrixMultiply(a, b);

target FastAccelerator {
    function matrixMultiply(a, b) = intrinsic;
};

value result = matrixMultiply(left, right);

class Animal(name:String) = {
    function describe(self:Self) : String = self.name
};

class Dog(breed:String)
    extends Animal("unknown") = {
    override function describe(self:Self) : String =
        self.breed
};

value dog = Dog.new("Collie");