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!

// Effects are trivial to combine
Interpret = can Use InterpreterState, Fail

// One use is to thread state automatically, while keeping it explicit in the type signature
eval (expr: Expr): I32 can Interpret =
    match expr
    | Int x -> x
    | Var name -> lookup name
    | Add lhs rhs -> eval lhs + eval rhs  // No explicit state threading

// Convert thrown effect to optional value
lookup (name: String): I32 can Interpret =
    state = get () : InterpreterState
    state.environment.lookup name |>.unwrap  // `unwrap` throws a `Fail` effect instead of panicking

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

ref1 = !vec  // `!` is used for mutable references, `&` for immutable
ref2 = !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 wouldn't be safe since another mutable
// reference could reallocate the vector and cause it to be a dangling reference
// error: `get` requires an owned reference. Try `get_cloned` instead
elem = ref1.get 0

// Generators are implemented via Algebraic Effects
effect Emit elem with 
    emit: elem -> Unit

// One advantage of Generators is that they are easier to write than Iterators
map (stream: Unit -> Unit can Emit a) (f: a -> b) can Emit b =
    handle stream ()
    | Emit elem -> 
        emit (f elem)
        resume ()

// Stream is a helper trait to Emit all elements of a collection
parse_csv (text: s) : Vec (Vec String) given Stream s String =
    lines text |> skip 1 |> map (split _ ",") |> collect

csv = parse_csv (File.open "input.csv")

// A collection c of elements of type e
trait Collection c -> e with 
    len: c -> Usz
    get: c -> index:Usz -> e

trait Show t with to_string: t -> String

effect Print with print: String -> Unit

// Inferred type:
// elem_to_string: a -> Usz -> String
//    given Collection a b, Show b
//    can Print
elem_to_string c i =
    get c i |> to_string |> print