anchor.diff:   The grammar of patterns is described below:
    ```
    pattern ::= literal
  -           | symbol
  +           | metavar
              | _
  +           | ( as pattern metavar ) ;; as
              | ( pattern * ) ;; list
              | ( pattern + . pattern ) ;; list+rest
  + literal ::= int | string | boolean | symbol
  + metavar ::= '?' symbol
    ```
   
    A literal pattern matches only if the scrutinee (what's being matched)
    compares [[eq?]] to the literal.
   
  - Both symbol patterns and the wildcard, `_`, match anything. However, a
  - symbol will bind the result of matching to that symbol. For example,
  + 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]
  
positive.code:   `(if ,(compile-pattern-test pattern symb)
       (let* ,(compile-pattern-bindings pattern symb)
         ,@body)
       (error (.. ,(.. "failed to match pattern " (pretty pattern) " against ") (pretty ,symb)))))
  
  (defmacro destructuring-bind (pt &body)
    "Match a single pattern against a single value, then evaluate the BODY.
  
negative.code:          (val-sym (gensym))]
      `(let* [(,val-sym ,value)]
         ,(compile-pattern pattern val-sym body))))
  
  (defun generate-case-error (arms val) :hidden
    (let* [(patterns (map (lambda (x) (pretty (car x))) arms))
           ]
      `(error (.. "Pattern matching failure!\nTried to match the following patterns against " (pretty ,val) ", but none matched.\n"
                  ,(concat (map (lambda (x) (.. "  Tried: `" x "`")) patterns) "\n")))))
  
  (defmacro case (val &pts)
    "Match a single value against a series of patterns, evaluating the first
  