move_value x = ()

// Most types are not shared and use move semantics by default
vec = Vec.of [1, 2, 3]
move_value vec  // ok!
move_value vec  // error! Vec already moved

// But shared types can be defined which enable cleaner code and a gentler learning curve.
shared type Expr =
    | Int I32
    | Var (name: String)
    | Add Expr Expr  // No explicit boxing since `Expr` is shared

foo = Expr.Var "foo"
move_value foo  // ok!
move_value foo  // ok!

// Traits in Ante are just sugar for types holding function values
trait Add t =
    (+): fn t t -> t

// Since they are just values, we can create them in constructor expressions
// and no global coherence or orphan restrictions are required
impl cmp_i32_descending: Cmp I32 with
    cmp a b = Ordering.from_int (b - a)

// Trait values can be defined locally and closures can capture data,
// making implementing them on interned types much easier
impl display_interned (ctx: InternCtx): Display MyInternedType with
    display interned =
        // Use `ctx` from the closure environment
        data = ctx.get interned
        display data

effect Throw err =
    throw: fn err -> Never

// Functions must declare which effects they use. E.g. the type system
// prevents a function without the Net effect from accessing the network.
signup (name: String) (email: Email): User can IO, Throw ValidationErr, Throw IOErr =
    // Unlike monads, effects are trivial to combine.
    // signup throws multiple error kinds but we don't need an error union to combine them.
    cfg = read_cfg_from_disk () // can IO, Throw IOErr
    validate name email  // can Throw ValidationErr

// No function coloring problem: map_vec trivially works with exceptions, async, etc.
// Any effects required by `f` are reflected in its type and in the effects of `map_vec`'s callsite.
map_vec (v: Vec t) (f: fn t => u): Vec u =
    Vec.of (map v f)

var vec = Vec.of [1, 2, 3]

ref1 = mut vec  // Create a temporary mutable reference to vec
ref2 = mut vec

// Ok! It is safe to call `Vec.push` with shared mutable references
ref1.push 4
ref2.push 5

// Retrieving a reference to an element is also possible, but we can't
// use other mutable references to the same value while it is active.
elem = ref1.get 0

// Generators are implemented via effects
effect Emit elem =
    emit: fn elem -> Unit

// One advantage of generators is that they are easier to write than iterators.
// Our input stream can `Emit a` and `map` can `Emit b`
map (stream: fn Unit => Unit can Emit a) (f: fn a => b): Unit can Emit b =
    handle stream ()
    | emit elem ->
        emit (f elem)
        resume ()

// From: `a,b,c\n1,2,3\n4,5,6`
// Return: `[["1", "2", "3"], ["4", "5", "6"]]`
parse_csv (text: String): Vec (Vec String) =
    lines text |> skip 1 |> map (fn line -> split line "," |> Vec.of) |> Vec.of