anchor.diff:    (dolist (x forms)
       (funcall
   	  (compose #'(lambda (x)
  -  				   (format t "Expression expansion...~%")
  -		           (expression-expand x))
  +			       (expression-expand (transpiler-expex tr) x))
   				 #'(lambda (x)
  -  				   (format t "Lambda expansion...~%")
   		     	   (transpiler-lambda-expand x))
   				 #'(lambda (x)
  -  				   (format t "Quote expansion...~%")
   		           (backquote-expand x))
   				 #'(lambda (x)
  -  				   (format t "Compiler-macro expansion...~%")
   		     	   (compiler-macroexpand x))
   				 #'(lambda (x)
  -  				   (format t "Macro expansion...~%")
   		           (transpiler-macroexpand x))
   			     #'list
   			     #'(lambda (x)
  -  				   (format t "Standard-macro expansion...~%")
   				   (expander-expand (transpiler-std-macro-expander tr) x)))
   	    x)))
   
   (defun transpiler-pass2 (tr forms)
  -  (print
     (transpiler-concat-strings
       (transpiler-to-string tr
         (mapcar #'(lambda (x)
                     (funcall
   				    (compose #'(lambda (x)
  -  								 (format t "Transpiler macro expansion...~%")
   								 (expander-expand (transpiler-macro-expander tr) x))
   						     #'(lambda (x)
  -  								  (format t "Finalizing expressions...~%")
   								 (transpiler-finalize-sexprs tr x))
   							 #'(lambda (x)
  -  								 (format t "Encapsulating strings...~%")
   						         (transpiler-encapsulate-strings x))
   							 #'(lambda (x)
  -  								 (format t "Expression expansion...~%")
  -						         (expression-expand x))
  -							 #'(lambda (x)
  -  								 (format t "Lambda expansion...~%")
  +						         (expression-expand (transpiler-expex tr) x))
  +							 #'(lambda (x)
   						     	 (transpiler-lambda-expand x))
   							 #'(lambda (x)
  -  								 (format t "Quote expansion...~%")
   						         (backquote-expand x))
   							 #'(lambda (x)
  -  								 (format t "Compiler-macro expansion...~%")
   						     	 (compiler-macroexpand x))
   							 #'(lambda (x)
  -  								 (format t "Macro expansion...~%")
  +						         (transpiler-make-slot-getters x))
  +							 #'(lambda (x)
   						         (transpiler-macroexpand x))
   						     #'list
  -							 #'(lambda (x)
  -  								 (format t "Generating slot getters...~%")
  -						         (transpiler-make-slot-getters x))
   						     #'(lambda (x)
  -  								 (format t "Standard-macro expansion...~%")
  -								 (expander-expand (transpiler-std-macro-expander tr) x))
  -)
  +								 (expander-expand (transpiler-std-macro-expander tr) x)))
   				    x))
  -		      forms)))))
  +		      forms))))
   
   (defun transpiler-wanted (tr pass verbose)
     (with (out nil)
  
positive.code: ;;;; SLOT GETTER GENERATION
  
  (defun transpiler-make-slot-getters (x)
    (maptree #'((x)
  				(if (and (atom x) (not (or (numberp x) (stringp x))))
  				    (with (sl (string-list (symbol-name x))
  					       p (position #\. sl :test #'=))
  				      (if p
  					      `(get-slot ,(make-symbol (list-string (subseq sl (1+ p))))
  								     ,(make-symbol (list-string (subseq sl 0 p))))
  					      x))
  					x))
  		  x))
  
  ;;;; OPERATOR EXPANSION
  
  (defmacro define-transpiler-infix (tr name)
    `(define-expander-macro ,(transpiler-macro-expander (eval tr)) ,name (x y)
  	 `(,,x (string ',name) ,,y)))
  
  (defun transpiler-binary-expand (op args)
    (nconc (list "(")
  
negative.code: 	      (cons (car x)
  			    (tree-list (cdr x))))))
  
  (defun mapatree (fun x)
    (if (atom x)
        (if x
  	  	  (funcall fun x)
  		  x)
  	  (cons (mapatree fun (car x))
  			(mapatree fun (cdr x)))))
  
  (defun maptree (fun tree)
    (if (atom tree)
           tree
        (mapcar #'((x)
                    (if (consp x)
                        (funcall fun (maptree fun (funcall fun x)))
  