anchor.diff:         [(eq? pattern 'true) `(eq? ,symb true)]
          [(eq? pattern 'false) `(eq? ,symb false)]
          [(eq? pattern 'nil) `(eq? ,symb nil)]
  +       [(type-predicate? pattern) `(,pattern ,symb)]
          [true ~(eq? ,symb ',pattern)])]
       [(or (number? pattern) (boolean? pattern) (string? pattern))
        `(eq? ,symb ,pattern)]
  
positive.code:  pattern ::= literal
             | metavar
             | _
             | ( -> expr pattern ) ;; view
             | ( as pattern metavar ) ;; as
             | ( pattern * ) ;; list
  
negative.code:  List patterns and _list with rest_ patterns match lists. A list pattern will
   match every element in a list, while a cons pattern will only match a certain
   number of cars and the cdr.
   Both bind everything bound by their \"inner\" patterns.
  
   A type predicate pattern works much like a wildcard, except it only matches if
   the scrutinee is of a specified type."
  
  (import base ( defun defmacro if get-idx
                 let* and gensym error for
                 quasiquote list or pretty
                 slice concat debug
                 /= # = ! - + / * >= ))
  (import type ())
  (import list ( car caddr cadr cdr append for-each
                 map filter push-cdr!
                 nth last elem? ))
  
  (import table (struct))
  (import string (.. char-at sub))
  