Builtins
========
if     ( ? then else -- )
true?  ( ? -- ? )
false? ( ? -- ? )
true   ( -- t )
false  ( -- f )
=      ( o -- ? )
  Note: deep equality on lists/sequences
,      enclose    [X^z Y] -> [X^{z} Y]
       disclose   [X^{z} Y] -> [X^z Y]
       turns a list into a function and a function into a list
       ?

  join Apeend two lists
`      ( seq -- o )
  first
`      ( o -- seq )
  unit
<=     uncache    [X Y^z] -> [X^z Y]  
       moves the tail of the queue to the top of the stack
       1 2 3 <= 4 5
    1 2 3 5 4
      
=>     cache      [X^z Y] -> {X Y^z]
       moves the top of the stack to the tail of the queue
       1 2 3 => 4 5
    1 2 3 5 4

->     queue      [X^z Y] -> [X z]
       replaces the queue with the top of the stack
       10 20 [2 3 +] -> 30 40 50
    10 20 5

<-     stack     [X^z Y] -> [z Y]
       replaces the stack with the top of the stack
       10 20 [2 3 +] <-
    2 3 +

/      use       [X^z Y] -> [X z,Y]
       prepends to the queue the item at the top of the stack
       10 20 [2 3 +] / 30 40 50
    10 20 5 30 40 50

\      mention  [X z^Y] -> [X^z Y]
       appends to the stack the item at the top of the queue
       10 20 \ + 30 40
    10 20 + 30 40

;      define   [X name^...code..^; Y] -> [X Y]
       defines word 'name' that runs 'code'

{      pattern  [X template^...code...^} Y] -> [X^Z Y]
       expands pattern. A capital letter as the final
       element in a template is the cons of the list.
       If the stack and queue have the form:
         X^x2^...xn {^[^a1^..^an^]^..^}^Y
       then _x is X, _y is Y and _z is {^[^a1^..^an^]^..^}^
       {} is a noop.

       10 20 30 { [a b] a b b a }
    10 20 30 30 20

       10 [20 30] { [a [b c]] [a b] [a c] }
    [10 20] [ 10 30]

       [10 20 30] { [[a A]] A a}
    [20 30] 10

iota   iota      [X^n Y] -> [X^{0^...^n} Y]
       Take the number off the stack and produce a sequence
       of numbers from 0 to n.

list?  list?     [X^o Y] -> [X^? Y]
       Removes the object from the top of X and pushes
       a boolean indicating whether the object is a list.

negate negate    [X^n Y] -> [X^n Y]
       Changes the sign of the number on the top of the stack.

reverse          [X^{o1^...^on} Y] -> [X^{on^...^o1} Y]
       Reverse the sequence on the top of the stack.

first            [X^{o1^....^on} Y] -> [X^o1 Y]
       Place the first element of the sequence on the stack.
       
head             [X^x^{o1^..^on} Y] -> [X^{o1^..^ox}]
       Outputs a new sequence containing the first 'x'
       elements of the initial sequence. If 'x' is
       negative then the new sequence contains the last
       'x' elements of the initial sequence.

tail             [X^x^{o1^..^on} Y] -> [X^{o1^..^ox}]
       Outputs a new sequence containing the initial
       sequence with the first 'x' elements removed. 
       If 'x' is negative then the new sequence has
       the last 'x' elements removed.


source           [X^s Y] -> [X^{...} Y]
       Given a symbol on the stack, leaves a sequence
       on the stack containing the definition of that
       symbol.

       \ dup source
    [ { a \a \a } ]