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:                  ,@(cdr pt)))))]
      `(let* [(,val-sym ,val)]
         (cond ,@(map compile-arm pts)
               [true ,(generate-case-error pts val-sym)]))))
  