# Tagging

---

## Operators

### Matching

```text
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

```text
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

```text
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

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

### Asserting

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

## Generators

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

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

it : gen `init 10
```

### Matching

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

### Asserting

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

## Tables

### Creating

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

### Accessing

```text
`log table.a
```

## Loops

### Break

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

### Continue

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