```{Record
cons
fold
reduce
for_each
for_each_numbered
iota
map
filter
length
reverse
reverse_append
append
concat
concat_map
fetch
zip
unzip
last
join
repeat
}

Where

Let (map list transform)
(fold list [] Func elem list. ((transform elem) :: list))

Let (iota n)
For (consing 0)
Define (consing i)
If (i = n)
`nil
(i :: (consing (i + 1)))

Let (filter list pred)
(fold list [] Func elem list. If (pred elem) (elem :: list) list)

Let (length list)
(reduce list 0
Func count _. (count + 1))

Let (concat lists)
(fold lists [] append)

Let (concat_map list f)
(fold list []
Func item items. (append (f item) items))

Let (fetch list n)
If (n < 0)
`nothing
Iterate {list n} From {list n}
Match list
| `cons.{item list}
If (n = 0)
`just.item
Continue {list (n - 1)}
| `nil `nothing
;

Let (zip a b)
Iterate {a b z} From {a b []}
Match a
| `cons.{ai a}
Match b
| `cons.{bi b} Continue {a b ({ai bi} :: z)}
| `nil (reverse z)
;
| `nil (reverse z)
;

Let (unzip list)
(fold list {[] []}
Func {a b} {as bs}. {(a :: as) (b :: bs)})

Let (last items)
(reduce items `nothing Func _ item. `just.item)

Let (join glue lists)
(fold lists []
Func list lists.
Match lists
| `nil [list]
| `cons._ (list :: (glue :: lists))
;)

Define (repeat n elem)
If (n = 0) [] (elem :: (repeat (n - 1) elem))

Where

Let (append left right) (reverse_append (reverse left) right)

Where

Let (reverse list) (reverse_append list [])

Where

Let (reverse_append queue tail)
(reduce queue tail
Func list elem. (elem :: list))

Where

Let (fold list nil cons)
For (fold list)
Define (fold list)
Match list
| `nil nil
| `cons.{elem list} (cons elem (fold list))
;

Let (reduce list zero plus)
Iterate {list sum} From {list zero}
Match list
| `nil sum
| `cons.{elem list} Continue {list (plus sum elem)}
;

Let (for_each list command)
Iterate {list} From {list}
Match list
| `nil {}
| `cons.{elem list}
Do (command elem)
In
Continue {list}
;

Let (for_each_numbered list command)
Iterate {i list} From {0 list}
Match list
| `nil {}
| `cons.{elem list}
Do (command i elem)
In
Continue {(i + 1) list}
;
```