{
:Infix &
:cons
:fold
:reduce
:for_each
:for_each_numbered
:iota
:map
:filter
:length
:reverse
:reverse_append
:append
:concat
:concat_map
:fetch
:tail
:zip
:unzip
:last
:join
:repeat
}

Where

Define (cons head tail)
    [head & tail]

Define (tail items n)
    Iterate {items n}
        If [n = 0]
            items
            Match items {
            | 'nil 'nil
            | 'cons.{_ items} (Continue items [n - 1])
            }

Define (map list transform)
    (fold list 'nil Func {elem list} [(transform elem) & list])

Define (iota n)
    Unfold i From 0
        If [i = n]
            'nil
            [i & (Fold [i + 1])]

Define (filter list pred)
    (fold list 'nil Func {elem list} If (pred elem) [elem & list] list)

Define (length list)
    (reduce list 0
        Func {count _} [count + 1])

Define (concat lists)
    (fold lists 'nil append)

Define (concat_map list f)
    (fold list 'nil
        Func {item items} (append (f item) items))

Define (fetch list n)
    If [n < 0]
        'nothing
        Iterate {list n}
            Match list {
            | 'cons.{item list}
                If [n = 0]
                    'just.item
                    (Continue list [n - 1])
            | 'nil 'nothing
            }

Define (zip a b)
    Iterate {a b z} From {a b 'nil}
        Match a {
        | 'cons.{ai a}
            Match b {
            | 'cons.{bi b} (Continue a b [{ai bi} & z])
            | 'nil (reverse z)
            }
        | 'nil (reverse z)
        }

Define (unzip list)
    (fold list {'nil 'nil}
        Func {{a b} {as bs}} {[a & as] [b & bs]})

Define (last items)
    (reduce items 'nothing Func {_ item} 'just.item)

Define (join glue items)
    (fold items 'nil
        Func {item items}
            Match items {
            | 'nil [item & 'nil]
            | 'cons._ [item & glue & items]
            })

Define (repeat n elem)
    Unfold n
        If [n = 0] 'nil [elem & (Fold [n - 1])]

Where

Define (append left right) (reverse_append (reverse left) right)

Where

Define (reverse list) (reverse_append list 'nil)

Where

Define (reverse_append queue tail)
    (reduce queue tail
        Func {list elem} [elem & list])

Where

Define (fold list nil cons)
    Unfold list
        Match list {
        | 'nil nil
        | 'cons.{elem list} (cons elem (Fold list))
        }

Define (reduce list zero plus)
    Iterate {list sum} From {list zero}
        Match list {
        | 'nil sum
        | 'cons.{elem list} (Continue list (plus sum elem))
        }

Define (for_each list command)
    Iterate list
        Begin Match list {
        | 'nil
        | 'cons.{elem list}
            (command elem)
            (Continue list)
        }

Define (for_each_numbered list command)
    Iterate {i list} From {0 list}
        Begin Match list {
        | 'nil
        | 'cons.{elem list}
            (command i elem)
            (Continue [i + 1] list)
        }

Where

Open Z
    {
    :Infix <
    :Infix =
    :Infix +
    :Infix -
    }

Where

Define [head & [tail]] 'cons.{head tail}

Let Z Package "z"