anchor.diff:      (cond
         [(list? pattern)
          (cond
  +         [(eq? (car pattern) 'as)
  +          `(,@(compile-pattern-bindings (caddr pattern) symb) ,@(compile-pattern-bindings (cadr pattern) symb))]
            [(cons-pattern? pattern)
             (let* [(lhs (cons-pat-left-side pattern))
                    (rhs (cons-pat-right-side pattern))
  
positive.code:  The grammar of patterns is described below:
   ```
   pattern ::= literal
             | symbol
             | _
             | ( pattern * ) ;; list
             | ( pattern + . pattern ) ;; list+rest
   ```
  
   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,
  
   ```
   (destructuring-bind [x 1]
  
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
  