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 closure values
trait Foo t with 
    foo: fn t -> U32

// And trait impls are sugar for implicit functions which take values and return a trait object.
// Moreover, since traits are implicits, no global coherence or orphan restrictions are required
impl ord_i32_descending: Ord I32 with
    cmp a b = Ordering.from_int (b - a)

// Impls can be defined locally and closures can capture data, making
// implementing traits on interned types much easier
impl foo_interned (ctx: InternCtx): Display MyInternedType with
    foo interned =
        // Use `ctx` from the closure environment
        data = ctx.get interned
        foo data

// Each capability is passed as a parameter and enables a function to perform its effect
signup (name: String) (email: Email) {t: Throw ValidationErr} {Throw IOErr} {IO}: User =
    // Unlike monads, capabilities are trivial to combine: they are just implicit parameters
    cfg = read_cfg_from_disk ()
    // And they can be passed explicitly if desired (or required)
    validate name email {t}

// Easy abstraction over control-flow: map_vec trivially works with exceptions, async, etc.
// Any capabilities required by `f` are captured in its closure
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 with 
    emit: fn elem -> Unit

// One advantage of generators is that they are easier to write than iterators.
// We'll supply the `Emit a` value but the caller needs to provide a capability for `Emit b`
map (stream: fn (Emit a) -> Unit) (f: fn a => b) {Emit b} =
    handler emit_a for emit elem ->
        emit (f elem)
        resume ()
    stream emit_a

parse_csv (text: String): Vec (Vec String) =
    lines text |> skip 1 |> map (fn line -> split line "," |> Vec.of) |> Vec.of