anchor.diff:  
   (defun compile-argument-expansion-0 (adef p &optional (argdefs nil) (key-args nil))
     (with ((argdefs key-args) (make-&key-alist adef)
  -		 get-name
  -		   #'((def)
  -				(? (cons? def.) def.. def.))
  +		 get-name    [? (cons? _.) _.. _.]
  +		 get-default [? (cons? _.) (cadr _.) _.]
   
  -		 get-default
  -		   #'((def)
  -				(? (cons? def.) (cadr def.) def.))
  +		 key
  +		   #'(()
  +			    (& key-args '((keywords))))
   
  -		 compexp-key
  -		   #'(()
  -			    (& key-args '((compexp-keywords))))
  -
  -		 compexp-static
  +		 static
   		   #'((def)
   			    `((= ,def. (car ,p))
   				  (= ,p (cdr ,p))
  -				  ,@(compexp-main .def)))
  +				  ,@(main .def)))
   
  -		 compexp-optional
  +		 optional
   		   #'((def)
  -			    `(,@(compexp-key)
  +			    `(,@(key)
   				  (? ,p
   				     (= ,(get-name def) (car ,p)
   				        ,p (cdr ,p))
  
positive.code: 					      `((= ,(get-name def) ,(get-default def)))))
  				  ,@(& .def
  					   (? (argument-keyword? .def.)
  				  		  (compexp-main .def)
  					      (compexp-optional .def)))))
  
  		 compexp-rest
  		   #'((def)
  			    `(,@(compexp-key)
  				  (= ,def. ,p)))
  
           compexp-optional-rest
  		   #'((def)
  		        (case def.
  				  '&rest     (compexp-rest .def)
  				  '&body     (compexp-rest .def)
  				  '&optional (compexp-optional .def)))
  
  		 compexp-sub
  		   #'((def)
  			    `(,@(compexp-key)
  				  (with-temporary ,p (car ,p)
  				    ,@(compile-argument-expansion-0 def. p))
  				  (= ,p (cdr ,p))
  				  ,@(compexp-main .def)))
  
  		 compexp-main
  		   #'((def)
  				(?
  				  (not def)					nil
  				  (argument-keyword? def.)	(compexp-optional-rest def)
  				  (cons? def.)				(compexp-sub def)
  				  (compexp-static def))))
     (? key-args
        `((with (compexp-keywords
  				  #'(()
                        (block compexp
  				        (let v nil
  
negative.code: 												 ,p (cdr ,p))))
  									    (carlist key-args))
  						      (return-from compexp nil)))))))
            ,@(& argdefs (main argdefs))
  		  ,@(key)
  		  ,@(compile-argument-expansion-defaults key-args)))
         (main argdefs))))
  
  (defun compile-argument-expansion-function-body (fun-name adef p toplevel-continuer names)
    `(with ,(mapcan (fn `(,_ ,(list 'quote _))) names)
       ,@(compile-argument-expansion-0 adef p)
       ((%transpiler-native ,(compiled-function-name *transpiler* fun-name)) ,@toplevel-continuer ,@names)))
  
  (defun compile-argument-expansion-cps (this-name fun-name adef names)
    (with-gensym (toplevel-continuer p)
      `(function ,this-name
                 ((,p)
                    (let ,toplevel-continuer ~%continuer
                      ,(compile-argument-expansion-function-body fun-name adef p (list toplevel-continuer) names))))))
  
  (defun compile-argument-expansion-no-cps (this-name fun-name adef names)
    (with-gensym p
      `(function ,this-name
                 ((,p)
                    ,(compile-argument-expansion-function-body fun-name adef p nil names)))))
  
  (defun only-&rest? (adef)
    (& (== 2 (length adef))
       (eq '&rest adef.)))
  
  (defun compile-argument-expansion (this-name fun-name adef)
    (? (only-&rest? adef)
  	 fun-name
       (alet (argument-expand-names 'compile-argument-expansion adef)
         (funcall (? (in-cps-mode?)
                     #'compile-argument-expansion-cps
                     #'compile-argument-expansion-no-cps)
                  this-name fun-name adef !)
  	   fun-name)))
  