anchor.diff:  (defmethod expr-free ((object lisp-function))
     nil)
      
  -(defmacro make-function (name args return &body body)
  -  `(make-instance 'lisp-function :name ,name :fun
  -		  ,(named-let rec ((args args))
  -			      (destructuring-bind (var conv) (first args)
  -				(labels ((conv-lambda (expr)
  -					   `(lambda (,var)
  -					      (let ((,var (,conv ,var)))
  -						,expr))))
  -				  (if (rest args)
  -				      (conv-lambda (rec (rest args)))
  -				      (conv-lambda `(,return (progn ,@body)))))))))
  +(defmacro make-function (name args &body body)
  +  (let ((args (mapcar (lambda (arg) (if (consp arg) arg (list arg t))) args)))
  +    `(make-instance 'lisp-function :name ,name :args ',(mapcar #'second args)
  +		    :fun ,(named-let rec ((args args))
  +				     (destructuring-bind (var type) (first args)
  +				       (labels ((conv-lambda (expr)
  +						  `(lambda (,var)
  +						     (let ((,var (decode ,var ',type *environment*)))
  +						       ,expr))))
  +					 (if (rest args)
  +					     (conv-lambda (rec (rest args)))
  +					     (conv-lambda `(make-expression (progn ,@body))))))))))
   
   (defmethod normal-order ((expression lisp-function))
     nil)
  
positive.code: 
  #| Extensions to the lambda-calculus |#
  
  (defclass lisp-function (scalar hidden-abstraction)
    ((function :reader lisp-fun :initarg :fun)))
  
  (defmethod abs-var ((object lisp-function))
    object) ; for identification purposes, cf. beta-reduce
  
negative.code:   (if (eq variable expression) ; cf. abs-var
        (let ((result (funcall (lisp-fun expression) value)))
  	(if (functionp result)
  	    (make-instance 'lisp-function :fun result :args (rest (lisp-args expression))
  			   :name (let ((current (hid-name expression)))
  				   (if (listp current)
  				       (append (butlast current)
  