anchor.diff:    (let ((hidden (find sexpr environment :key #'hid-name :test #'equal)))
       (if hidden
   	hidden
  -	(make-instance 'variable :name sexpr))))
  +	(make-instance 'variable :name sexpr :free (list sexpr)))))
   
   (defmethod make-expression ((sexpr symbol)  &optional environment)
     (make-expression (string-downcase (symbol-name sexpr))))
   
  +(defun free-in-either (expr1 expr2)
  +  (let ((free1 (expr-free expr1))
  +	(free2 (expr-free expr2)))
  +    (remove-duplicates (append free1 free2) :test #'string=)))
  +
   (defmethod make-expression ((sexpr cons)  &optional environment)
     (case (first sexpr)
  -    ((lambda) (make-instance 'abstraction :var (make-expression (second sexpr)) :body (make-expression (third sexpr) environment)))
  -    (t (make-applications-chain
  -	(make-instance 'application :fun (make-expression (first sexpr) environment) :arg (make-expression (second sexpr) environment))
  -	(cddr sexpr)
  -	environment))))
  +    ((lambda) (let ((var (make-expression (second sexpr)))
  +		    (body (make-expression (third sexpr) environment)))
  +		(make-instance 'abstraction :var var :body body
  +			       :free (remove-if (lambda (name) (equal name (var-name var))) (expr-free body)))))
  +    (t (let ((fun (make-expression (first sexpr) environment))
  +	     (arg (make-expression (second sexpr) environment)))
  +	 (make-applications-chain
  +	  (make-instance 'application :fun fun :arg arg :free (free-in-either fun arg))
  +	  (cddr sexpr)
  +	  environment)))))
   
   (defun make-applications-chain (fun sexpr &optional environment)
     (if (null sexpr)
         fun
  -      (make-applications-chain (make-instance 'application
  -					      :fun fun
  -					      :arg (make-expression (first sexpr) environment))
  -			       (rest sexpr)
  -			       environment)))
  +      (let ((arg (make-expression (first sexpr) environment)))
  +	(make-applications-chain (make-instance 'application :fun fun :arg arg :free (free-in-either fun arg))
  +				 (rest sexpr)
  +				 environment))))
  
positive.code:   ((content :reader hid-abs :initarg :abs)
     (name :reader hid-name :initarg :name)))
  
  (defmethod abs-var ((object hidden-abstraction))
    (abs-var (hid-abs object)))
  
  (defmethod abs-body ((object hidden-abstraction))
    (abs-body (hid-abs object)))
  
  
  
  #| Building of lambda expressions for symbolic expressions |#
  
negative.code: 
  #| Basic constructs of lambda calculus |#
  
  (defclass expression ()
    ((free-variables :reader expr-free :initarg :free)))
  
  (defclass variable (expression)
    ((name :accessor var-name :initarg :name)))
  