anchor.diff:  (defmethod = ((a object) (b object))
     (eq a b))
   
  -;;;; Numbers
  -
  -(defmacro define-jsnums-binop (name jsnums-name)
  -  #`(progn
  -      (defgeneric ,name (a b))
  -      (defmethod ,name ((a number) (b number))
  -        #{ jsnums.~(native-snippet ,jsnums-name)(~a, ~b) #})))
  -
  -(define-jsnums-binop = "equals")
  -(define-jsnums-binop > "greaterThan")
  -(define-jsnums-binop < "lessThan")
  -(define-jsnums-binop / "divide")
  -(define-jsnums-binop * "multiply")
  -(define-jsnums-binop + "add")
  -(define-jsnums-binop - "subtract")
  -
   ;;;; Printing
  +
  +(defgeneric show (object))
  +
  +(eval-when-compile
  +  (defun show-unreadable (class-name &optional (more ""))
  +    (string-concat "#(" (symbol-name class-name) more ")")))
  +
  +(defmacro define-stupid-show (class-name)
  +  #`(defmethod show ((a ,class-name))
  +      ,(string-to-form (show-unreadable class-name))))
   
   (defmethod show ((a object))
     #{ JSON.stringify(~a) #})
  
positive.code: (defun not (x)
    (if x #f #t))
  
  (defun nil? (x)
    (if (eq nil x) #t #f))
  
  (eval-when-compile
    (defun setter-name (getter-name)
  
negative.code: 
  (defmacro native-body (&rest stuff)
    #`#{ (function(){ ~,@stuff })() #})
  
  ;;;; Dynamic variables
  
  (defmacro dynamic (name)
    #`(identifier ,name dynamic))
  
  (defmacro defdynamic (name &optional (value #'nil))
    #`(defvar (dynamic ,name) ,value))
  
  (defmacro dynamic-bind (bindings &rest body)
    (if (compound-empty? bindings)
        #`(progn ,@body)
        #`(dynamic-bind-1 ,(compound-elt bindings 0)
            (dynamic-bind ,(compound-slice bindings 1)
               ,@body))))
  
  (defmacro dynamic-bind-1 (binding &rest body)
    (let ((name (compound-elt binding 0))
          (value (compound-elt binding 1)))
      #`(let ((old-value (dynamic ,name)))
          (setq (dynamic ,name) ,value)
          (unwind-protect (progn ,@body)
            (setq (dynamic ,name) old-value)))))
  
  ;;;; Object system
  
  