Tagging

---

Operators

Matching

r : # x / y {
    .value {[value] value }
    .error {[error] `log error; 0 }
}

Asserting

If no tag is specified for an operation, .value is used

An invalid assertion produces an Error with an .error tag

r : x /.value y
r : x / y // same as above

Lambdas

If no tag is specified .value is used, user defined coroutines don't have to have a .value tag

Returning

add : `{[I64 x; I64 y] `return.value x + y }
add : `{[I64 x; I64 y] .value x + y } // same as above
add : `{[I64 x; I64 y] x + y } // same as above
mu : `{[Bool i]
    ? i {
        .int 1
    } {
        .float 1.1
    }
}

Matching

// using the mu corotuine from above
i : # mu `sync `false {
    .int {[i] i }
    .float {[f] I64 f }
}

Asserting

// using the mu coroutine from aboce
i : mu `sync.int `true

Generators

Generators use a .done tag to denote when it is complete

gen : ^{[I64 n]
    @ 1 .. n {[x]
        `yield x
        // above is alias for -> `yield.value x
    }
    `done
}

it : gen `init 10

Matching

v : # `next it {
    .value {[x] x }
    .done { -1 }
}

Asserting

v : `next.value it
v : `next it // same as above

Tables

Creating

table : Table (.a 1; .b 1.1)

Accessing

`log table.a

Loops

Break

@.outer condtion {
    @ condition {
        `break.outer
    }
}

Continue

@ (x : 0; x < 10; x +: 2) {
    ? x < 5 { `continue }
    ...
}