anchor.diff:  ;;   `(list ,@(mapcar (lambda (vb) `(read-fn ,(common-lisp:first vb) ,(second vb))) specs)))
   
   (EVAL-WHEN (:compile-toplevel :load-toplevel :execute)
  -  (defun fn* (&rest specs)
  +  ;; (defun fn* (&rest specs)
  +  ;;   (let* ((fst (car specs))
  +  ;;          (named? nil)
  +  ;;          (name (if (symbolp (common-lisp:first fst))                     
  +  ;;                    (progn (setf named? t)
  +  ;;                           (common-lisp:first fst) )
  +  ;;                    (symb (symbol-name (gensym "fn_")))))
  +  ;;          (specs (if named? (common-lisp:rest (common-lisp:first  specs)) specs)))
  +  ;;     (pprint (list fst named? name specs))
  +  ;;     `(,@(mapcar (lambda (vb)
  +  ;;                   (pprint vb)
  +  ;;                   (read-fn (common-lisp:first vb)
  +  ;;                            (if (cadr vb)                                          
  +  ;;                                (common-lisp:cons 'progn (common-lisp:rest vb))
  +  ;;                                (second vb))
  +  ;;                            name))
  +  ;;                 specs
  +  ;;                 ))))
  +  
  +  (defun fn* (name &rest specs)
       `(,@(mapcar (lambda (vb) (read-fn (common-lisp:first vb)
                                         (if (cadr vb)                                          
                                             (common-lisp:cons 'progn (common-lisp:rest vb))
  -                                          (second vb)))) specs)))
  -
  +                                          (second vb)) name)) specs)))
  +  
     ;; (defparameter test-fn
     ;;   '(fn* ([x] x)
     ;;         ([x y]        (+ x y))
  
positive.code: ;;Compile a clojure fn special form into a common lisp lambda
  (EVAL-WHEN (:compile-toplevel :load-toplevel :execute)
    (defgeneric fndef->sexp (fd))
    (defmethod  fndef->sexp ((fd fn-def))
      (with-slots (args body) fd
        (with-slots (lambda-list outer-let) (parse-args args)           
          (let ((interior (if outer-let `(let* ,outer-let ,body)
                              body)))
            `(lambda ,lambda-list ,interior)))))
  
    ;;parse a list of function definitions into an n-lambda dispatching function.
    (defmethod fndef->sexp ((fd common-lisp:cons))
      (if (= (length fd) 1)  (fndef->sexp (common-lisp:first fd)) ;simple case
          ;;case with multiple function definitions.
          `(common-utils:lambda* ,@(mapcar (lambda (body)
                                             (common-lisp:rest (fndef->sexp body))) fd)))))
    
  ;;Clojure's anonymous function special form.
  ;;Todo: support destructuring in the args.
  (defmacro fn (&rest specs)
    (let ((res 
            (if (vector-form? (common-lisp:first specs)) 
                (fndef->sexp (fn*  specs))
                ;;TODO get rid of this eval....
                (fndef->sexp (apply #'fn* specs)))))    
      `(,@(clclojure.eval::custom-eval-bindings (sb-cltl2::macroexpand-all res) nil))))
  
  ;; (defmacro fn (&rest specs)
  ;;   (let ((res 
  ;;           (if (vector-form? (common-lisp:first specs)) 
  ;;               (fndef->sexp (fn*  specs))
  ;;               ;;TODO get rid of this eval....
  ;;               (fndef->sexp (apply #'fn* specs)))))    
  ;;     `(,@(clclojure.eval::custom-eval-bindings (sb-cltl2::macroexpand-all res) nil))))
  
  ;;def 
  ;;===
  
negative.code: 
  ;;a single function definition
  (EVAL-WHEN (:compile-toplevel :load-toplevel :execute)
    (defstruct fn-def  name args body)
    ;;a macro definition -- later
    (defstruct macro-def name args body))
  
  