anchor.diff:  		 exp-sub
   		   #'((def vals)
   			    (when no-static
  -				  (error "static sublevel argument definition after ~A" no-static))
  +				  (err "static sublevel argument definition after ~A" no-static))
   				(and apply-values (not (consp (first vals)))
  -					 (error "sublist expected for argument ~A" num))
  -				(nconc (argument-expand2 (first def) (first vals) apply-values)
  +					 (err "sublist expected for argument ~A" num))
  +				(nconc (argument-expand2 fun (first def) (first vals) apply-values)
   					   (exp-main (cdr def) (cdr vals))))
   
   		 exp-check-too-many
              #'((def vals)
   			    (and (not def) vals
  -				     (error "too many arguments. ~A max, but ~A more given"
  +				     (err "too many arguments. ~A max, but ~A more given"
   						    (length argdefs) (length vals))))
   
   		 exp-main-non-key
  
positive.code: 		 exp-optional
  		   #'((def vals)
  				(when (argument-keyword? (first def))
  					(error "Keyword ~A after &OPTIONAL" (first def)))
  				(setf no-static '&optional)
  				(cons (cons (get-name def) (get-value def vals))
  					  (if (argument-list-keyword? (second def))
  
negative.code: 			 key-args
  			 rest-arg))))
  
  (defun argument-expand (fun def vals apply-values)
    (funcall (if apply-values
  			   #'identity
  			   #'carlist)
  		   (argument-expand2 fun def vals apply-values)))
  
  ;;; Tests
  
  (define-test "argument expansion basically works"
    ((equal (argument-expand 'test '(a b) '(2 3) t)
  	      '((a . 2) (b . 3))))
    t)
  
  (define-test "argument expansion basically works without apply-values"
    ((equal (argument-expand 'test '(a b) nil nil)
  	      '(a b)))
    t)
  
  (define-test "argument expansion can handle nested lists"
    ((equal (argument-expand 'test '(a (b c) d) '(23 (2 3) 42) t)
  	    '((a . 23) (b . 2) (c . 3) (d . 42))))
    t)
  
  (define-test "argument expansion can handle nested lists without apply-values"
    ((equal (argument-expand 'test '(a (b c) d) nil nil)
  	    '(a b c d)))
    t)
  
  (define-test "argument expansion can handle &REST keyword"
    ((equal (argument-expand 'test '(a b &rest c) '(23 5 42 65) t)
  	  '((a . 23) (b . 5) (c &rest 42 65))))
    t)
  
  (define-test "argument expansion can handle &REST keyword without apply-values"
    ((equal (argument-expand 'test '(a b c &rest d) nil nil)
  	    '(a b c d)))
    t)
  
  (define-test "argument expansion can handle missing &REST"
    ((equal (argument-expand 'test '(a b &rest c) '(23 5) t)
  	  '((a . 23) (b . 5) (c &rest))))
    t)
  
  (define-test "argument expansion can handle missing &REST without apply-values"
    ((equal (argument-expand 'test '(a b &rest c) '(23 5) nil)
  	  '(a b c)))
    t)
  
  (define-test "argument expansion can handle &OPTIONAL keyword"
    ((equal (argument-expand 'test '(a b &optional c d) '(23 2 3 42) t)
  	  '((a . 23) (b . 2) (c . 3) (d . 42))))
    t)
  
  (define-test "argument expansion can handle &OPTIONAL keyword without apply-values"
    ((equal (argument-expand 'test '(a b &optional c d) nil nil)
  	    '(a b c d)))
    t)
  
  (define-test "argument expansion can handle &OPTIONAL keyword with init forms"
    ((equal (argument-expand 'test '(a b &optional (c 3) (d 42)) '(23 2) t)
  	  '((a . 23) (b . 2) (c . 3) (d . 42))))
    t)
  
  (define-test "argument expansion can handle &OPTIONAL keyword with init forms without apply-values"
    ((equal (argument-expand 'test '(a b &optional (c 3) (d 42)) nil nil)
  	    '(a b c d)))
    t)
  
  (define-test "argument expansion can handle &KEY keyword"
    ((equal (argument-expand 'test '(a b &key c d) '(23 2 :c 3 :d 42) t)
  	  '((a . 23) (b . 2) (c . 3) (d . 42))))
    t)
  
  (define-test "argument expansion can handle &KEY keyword without apply-values"
    ((equal (argument-expand 'test '(a b &key c d) nil nil)
  	    '(a b c d)))
    t)
  
  