anchor.diff:           nil))))
   
   (defmacro function (&arms)
  +  "Create a lambda which matches its arguments against the patterns
  +   defined in ARMS."
     (let* [(rest-sym (gensym "remaining-arguments"))
            (rest { :tag :symbol
                    :contents (.. "&" (get-idx rest-sym :contents)) })
  
positive.code:  Utilities for manipulating deeply-nested data and lists in general, as
   well as binding multiple values.
  
   The grammar of patterns is described below:
   ```
   pattern ::= literal
             | metavar
             | _
             | symbol '?' ;; predicate
             | ( expr -> pattern ) ;; view
             | ( pattern @ metavar ) ;; as
             | ( pattern :when expr) ;; when
             | ( pattern * ) ;; list
             | ( pattern + . pattern ) ;; list+rest
             | ( struct-literal :name pattern :name pattern ) ;; structure literal
             | { :name pattern :name pattern } ;; structure literal
   literal ::= number | string | boolean | symbol | key
   metavar ::= '?' symbol
   ```
  
   A literal pattern matches only if the scrutinee (what's being matched)
   compares [[eq?]] to the literal.
  
   Both metavariable patterns and the wildcard, `_`, match
   anything. However, a metavariable will bind the result of matching to
   that symbol. For example,
  
   ```
   (destructuring-bind [x 1]
     (print! x))
   ```
  
   Results in `1` being printed to standard output, seeing as it is bound
   to `x`.
  
   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 matches the given predicate."
  
  (import lua/basic (xpcall))
  (import lua/math (max))
  
negative.code:     [true true]))
  
  (defun compile-pattern-test (pattern symb)
    :hidden
    (cond
      [(list? pattern)
       (cond
  