anchor.diff:     - A symbol
      - A key
      - A function"
  -  (or (boolean? x)
  -      (string? x)
  -      (number? x)
  -      (symbol? x)
  -      (function? x)
  -      (key? x)))
  +  (/= (type# x) "table"))
   
   (defun falsey? (x)
     "Check whether X is falsey, that is, it is either `false` or does
  
positive.code: (import base (defun let* type# if car cdr when
                and or >= = <= /= # get-idx defmacro
                error gensym ! debug))
  
  (import lua/string (format sub))
  
  
negative.code:    - If X or Y do not exist
       - They are not equal if one exists and the other does not.
       - They are equal if neither exists.  "
    (if (= x y)
      true
      (let* [(type-x (type x))
             (type-y (type y))]
        (cond
          [(and (= type-x :list) (= type-y :list) (= (# x) (# y)))
           (let* [(equal true)] ; be optimistic
             (for i 1 (# x) 1
               (when (neq? (get-idx x i) (get-idx y i)) (set! equal false)))
             equal)]
          [(and (= :symbol type-x) (= :symbol type-y)) (= (get-idx x :contents) (get-idx y :contents))]
          [(and (= :key type-x)    (= :key type-y))    (= (get-idx x :value) (get-idx y :value))]
          [(and (= :symbol type-x) (= :string type-y)) (= (get-idx x :contents) y)]
          [(and (= :string type-x) (= :symbol type-y)) (= x (get-idx y :contents))] 
          [(and (= :key type-x)    (= :string type-y)) (= (get-idx x :value) y)]
          [(and (= :string type-x) (= :key type-y))    (= x (get-idx y :value))] 
          [true false]))))
  
  (defun neq? (x y)
    "Compare X and Y for inequality deeply. X and Y are `neq?`
  