anchor.diff:      (%same-name (write-to-string s1) s2))
     (:method (s1 s2)
       nil))
  +
  +(defgeneric %nonblank (el)
  +  (:method ((el string))
  +    (unless (every (lambda (ch) (char= ch #\Space)) el) el))
  +  (:method ((el (eql :null)))   ; postmodern uses this for NULL fields
  +    nil)
  +  (:method ((el (eql 0)))
  +    nil)
  +  (:method ((el (eql 0.0)))
  +    nil)
  +  (:method ((el (eql nil)))
  +    nil)
  +  (:method ((el array))
  +    (< 0 (length el)))
  +  (:method (el)
  +    el))
   
   (defgeneric fetch-property (map key)
     (:method ((map hash-table) key)
  
positive.code: 
      (or
       (make-or-handler args))
  
      (:round
       (make-simple-function-hadler #'round/closure-template args))
  
negative.code:   (named-lambda variable-handler (env)
      (fetch-property env varkey)))
  
  (defun make-boolean-expression-handler (expr)
    (let ((expr (make-expression-handler expr)))
      (named-lambda boolean-handler (env)
        (%nonblank (funcall expr env)))))
  
  (defun make-if-function-handler (condition success fail)
    (let ((condition-expr (make-boolean-expression-handler condition))
          (success-expr (make-expression-handler success))
          (fail-expr (make-expression-handler fail)))
      (named-lambda if-function-handler (env)
  