# Queue


FTCQueue (catenable queue, after Kiselyov & Ishii 2015). O(1) `snoc`/`append`, amortized O(1) `viewl`.

## `append`

_append: concatenate two queues in O(1); identity queues short-circuit and the `__rawResume` rotation flag is propagated when present._

```
append : FTCQueue a b -> FTCQueue b c -> FTCQueue a c
```

Concatenate two queues. O(1).

Identity queues short-circuit (return the other side untouched).
The `__rawResume` flag is preserved so `fx.bind` chains around
`scope.provide` retain deep-handler semantics.

## `leaf`

_leaf: build a singleton FTCQueue containing one continuation; the leaf of the catenable-tree representation._

```
leaf : (a -> Computation b) -> FTCQueue a b
```

Create a singleton queue containing one continuation function.

## `node`

_node: join two FTCQueues into a balanced tree node; O(1) concatenation that defers traversal cost to `viewl`._

```
node : FTCQueue a x -> FTCQueue x b -> FTCQueue a b
```

Join two queues. O(1) — just creates a tree node; the cost is amortised by `viewl` during deconstruction.

## `qApp`

_qApp: apply a queue of continuations to a starting value; trampolines pure continuations via `genericClosure` and halts at the first `Impure` result._

```
qApp : FTCQueue a b -> a -> Computation b
```

Apply a queue of continuations to a value. Processes continuations
left-to-right: if a continuation returns `Pure`, feed the value
to the next continuation. If it returns `Impure`, append the
remaining queue to the effect's own queue and return.

## `singleton`

_singleton: alias for `leaf`; build an FTCQueue from a single continuation function with no nesting._

```
singleton : (a -> Computation b) -> FTCQueue a b
```

Create a queue with a single continuation. O(1). Synonym for `leaf`.

## `snoc`

_snoc: append one continuation to the right end of a queue in O(1); preserves the `__rawResume` rotation flag for deep-handler semantics._

```
snoc : FTCQueue a b -> (b -> Computation c) -> FTCQueue a c
```

Append a continuation to the right of the queue. O(1).

Preserves the `__rawResume` flag through extension so deep-handler
rotation continuations keep routing effectful resumes back through
inner-scope handlers.

## `viewl`

_viewl: extract the leftmost continuation from a queue with amortised O(1) cost via `viewlGo` rotation; returns `{ head, tail }`, `tail = null` for singletons._

```
viewl : FTCQueue a b -> { head : (a -> Computation b), tail : FTCQueue a b | null }
```

Extract the leftmost continuation from the queue. Amortized O(1).

Returns `{ head = fn; tail = queue | null; }` — `tail` is `null`
when the queue had only one element.