anchor.diff:  (defmacro defunion (union &body variants)
     "Define an algebraic data type.
   
  -VARIANTS defines the subtypes of UNION. Each expression in VARIANTS is
  -either a symbol \(in which case it defines a unit type, as with
  -`defunit') or a list \(in which case it defines a structure, as with
  -`defconstructor'.
  -
  -AKA a tagged union or a discriminated union."
  +Each expression in VARIANTS is either a symbol \(in which case it
  +defines a unit type, as with `defunit') or a list \(in which case it
  +defines a structure, as with `defconstructor'."
     (let* ((docstring (and (stringp (first variants))
                            (pop variants)))
            (ctors (filter #'listp variants))
  
positive.code: (defmacro defunit (name)
    "Define a unit type.
  
  A unit type is a type that only allows one value.
  
  Or: a unit type is a singleton without state.
  
  Or: a unit type is a product type with no factors.
  
  Or: a unit type is a unique object, like a symbol, but tagged with its
  own individual type."
    `(progn
       (defclass ,name () ()
  
negative.code: 
  UNION should be an algebraic data type.
  
  Each clause in CLAUSES has a pattern as its first element.
  
  If the pattern is a symbol, it matches a unit type.
  
  If the pattern is a list, it matches a constructor.
  
  If the pattern is an underscore, it introduces a default or
  fallthrough clause.
  
  If the pattern is a list that starts with `or', it is a disjunction of
  other patterns."
    (check-match-exhaustive union clauses env)
    `(ematch ,expr
       ,@(loop for (pattern . body) in clauses
  