anchor.diff:    (%type? expression type environment))
   
   (defmethod %type? (expression (type (eql 'numeral)) environment)
  -  (typep (decode expression type environment) '(integer 0 *)))
  +  (multiple-value-bind (value decoded?) (decode expression type environment)
  +    (when decoded?
  +      (typep value '(integer 0 *)))))
   
   (defmethod %type? (expression (type (eql 't)) environment)
     t)
  
positive.code: #| Extensions to the lambda-calculus |#
  
  (defgeneric decode (expression type environment)
    (:documentation "Returns the Lisp object encoded by the expression in the environment, with type as a hint."))
  
  (defmethod decode ((expression hidden-abstraction) type environment)
    (hid-name expression))
  
  (defmethod decode ((expression hidden-abstraction) (type (eql 'boolean)) environment)
    (read-from-string (render (normalize #'normal-order (make-expression (list expr t nil) nil))) nil))
  
  ;;;
  
  
negative.code: (defmethod applicative-order ((expression lisp-function))
    nil)
  
  (defmethod beta-candidates? ((abstraction lisp-function) value)
    (type? value (first (lisp-args abstraction))))
  
  (defmethod beta-reduce (variable value (expression lisp-function))
    (if (eq variable expression) ; cf. abs-var
        (let ((result (funcall (lisp-fun expression) value)))
  