effect Fail with
    fail: Unit -> I32
    
safe_div (x: I32) (y: I32) : I32 can Fail =
    if y != 0
    then x / y
    else fail ()

// Unlike exceptions, we can choose to either stop on error, or resume with a value:
default_value (value: I32) (f: Unit -> a can Fail) : Unit =
    handle f ()
    | fail () -> resume value

safe_div 1 0 with default_value 42  //=> 42

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

ref1 = &mut vec
ref2 = &mut vec

// Ok! It is safe to call `Vec.push` with shared mutable references
push ref1 4
push ref2 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 = get ref1 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