anchor.diff:  (in-package :smacklisp)
  -
  -
  -(defmacro def-smack-cl-fun (name lambda-list)
  -  (flet ((convert-parm (p)
  -           (destructuring-bind (var &optional def sup)
  -               (ensure-list p)
  -             (case var
  -               (key '(when key
  -                      (lambda (x) (funcall key denv x))))
  -               (predicate-1
  -                `(when ,var
  -                   (lambda (x) (apply ,var denv x))))
  -               (predicate-2
  -                `(when ,var
  -                   (lambda (x y) (apply ,var denv x y))))
  -               (predicate
  -                `(when ,var
  -                   (lambda (x &rest more) (apply ,var denv x more))))
  -               (function
  -                `(when ,var
  -                   (lambda (&rest args) (apply ,var denv args))))
  -               (test '(if test (lambda (x y) (funcall test denv x y)) #'eql))
  -               (t (cond (sup `(if ,sup ,var ,def))
  -                        (def `(if ,var ,var ,def))
  -                        (t var)))))))
  -    (multiple-value-bind (required optional rest keyword)
  -        (smack-parse-lambda-list lambda-list)
  -      `(defun ,(symbolicate 'smack- name) ,(cons 'denv lambda-list)
  -         (,(if rest 'apply 'funcall)
  -          (function ,name)
  -          ,@(mapcar #'convert-parm required)
  -          ,@(mapcar #'convert-parm optional)
  -          ,@(mapcan (lambda (k)
  -                      (list (car k) (convert-parm (cdr k))))
  -                    keyword)
  -          ,@rest)))))
  -
  -
  -(def-smack-cl-fun member (item list &key key test))
  -(def-smack-cl-fun member-if (predicate-1 sequence &key key))
  -(def-smack-cl-fun assoc (item alist &key key test))
  -(def-smack-cl-fun assoc-if (predicate-1 sequence &key key))
  -(def-smack-cl-fun rassoc (item alist &key key test))
  -(def-smack-cl-fun rassoc-if (predicate-1 sequence &key key))
  -(def-smack-cl-fun adjoin (item alist &key key test))
  -(def-smack-cl-fun notany (predicate first-seq &rest more-seqs))
  -(def-smack-cl-fun every (predicate first-seq &rest more-seqs))
  -(def-smack-cl-fun some (predicate first-seq &rest more-seqs))
  -(def-smack-cl-fun notevery (predicate first-seq &rest more-seqs))
  -(def-smack-cl-fun find (item sequence &key from-end test (start 0) end key))
  -(def-smack-cl-fun find-if (predicate-1 sequence &key from-end (start 0) end key))
  -(def-smack-cl-fun count (item sequence &key from-end test (start 0) end key))
  -(def-smack-cl-fun count-if (predicate-1 sequence &key from-end (start 0) end key))
  -(def-smack-cl-fun position (item sequence &key from-end test (start 0) end key))
  -(def-smack-cl-fun position-if (predicate-1 sequence &key from-end (start 0) end key))
  -(def-smack-cl-fun remove (item sequence &key from-end test (start 0) end count key))
  -(def-smack-cl-fun remove-if (predicate-1 sequence &key from-end (start 0) end count key))
  -(def-smack-cl-fun delete (item sequence &key from-end test (start 0) end count key))
  -(def-smack-cl-fun delete-if (predicate-1 sequence &key from-end (start 0) end count key))
  -(def-smack-cl-fun substitute (newitem olditem sequence &key from-end test (start 0) end count key))
  -(def-smack-cl-fun substitute-if (newitem predicate-1 sequence &key from-end (start 0) end count key))
  -(def-smack-cl-fun nsubstitute (newitem olditem sequence &key from-end test (start 0) end count key))
  -(def-smack-cl-fun nsubstitute-if (newitem predicate-1 sequence &key from-end (start 0) end count key))
  -(def-smack-cl-fun mapc (function list &rest more-lists))
  -(def-smack-cl-fun mapcan (function list &rest more-lists))
  -(def-smack-cl-fun mapcar (function list &rest more-lists))
  -(def-smack-cl-fun mapcon (function list &rest more-lists))
  -(def-smack-cl-fun mapl (function list &rest more-lists))
  -(def-smack-cl-fun maplist (function list &rest more-lists))
  -(def-smack-cl-fun map (result-type function first-seq &rest more-seqs))
  -(def-smack-cl-fun map-into (result-sequence function &rest more-seqs))
  -(def-smack-cl-fun merge (result-type sequence1 sequence2 predicate-2 &key key))
  -(def-smack-cl-fun mismatch (sequence1 sequence2 &key from-end test key (start1 0) (start2 0) end1 end2))
  -(def-smack-cl-fun reduce (function sequence &key key from-end (start 0) end initial-value))
  -(def-smack-cl-fun remove-duplicates (sequence &key from-end test (start 0) end key))
  -(def-smack-cl-fun delete-duplicates (sequence &key from-end test (start 0) end key))
  -(def-smack-cl-fun search (sequence1 sequence2 &key from-end test key (start1 0) (start2 0) end1 end2))
  -(def-smack-cl-fun sort (sequence predicate-2 &key key))
  -(def-smack-cl-fun stable-sort (sequence predicate-2 &key key))
  -(def-smack-cl-fun make-hash-table (&key test size rehash-size rehash-threshold))
  -(def-smack-cl-fun maphash (function hash-table))
  -
  -(def-smack-cl-fun subsetp (list1 list2 &key key test))
  -(def-smack-cl-fun tree-equal (tree1 tree2 &key test))
  -(def-smack-cl-fun subst (new old tree &key key test))
  -(def-smack-cl-fun nsubst (new old tree &key key test))
  -(def-smack-cl-fun subst-if (new predicate1 tree &key test))
  -(def-smack-cl-fun nsubst-if (new predicate1 tree &key test))
  -(def-smack-cl-fun sublis (alist tree &key key test))
  -(def-smack-cl-fun nsublis (alist tree &key key test))
  -
  -(def-smack-cl-fun intersection (list1 list2 &key key test))
  -(def-smack-cl-fun nintersection (list1 list2 &key key test))
  -(def-smack-cl-fun set-difference (list1 list2 &key key test))
  -(def-smack-cl-fun nset-difference (list1 list2 &key key test))
  -(def-smack-cl-fun set-exclusive-or (list1 list2 &key key test))
  -(def-smack-cl-fun nset-exclusive-or (list1 list2 &key key test))
  -(def-smack-cl-fun union (list1 list2 &key key test))
  -(def-smack-cl-fun nunion (list1 list2 &key key test))
   
   (defparameter *smack-procs*
     '(
  
positive.code:     length make-sequence
      subseq 
      replace reverse nreverse
      (merge smack-merge)
      (mismatch smack-mismatch) 
      (reduce smack-reduce) 
      (remove-duplicates smack-remove-duplicates)
      (delete-duplicates smack-delete-duplicates)
      (search smack-search)
      (sort smack-sort)
      (stable-sort smack-stable-sort)
      (count smack-count)
      (count-if smack-count-if)
      (find smack-find)
      (find-if smack-find-if)
      (position smack-position)
      (position-if smack-position-if)
      (remove smack-remove)
      (remove-if smack-remove-if)
      (delete smack-delete)
      (delete-if smack-delete-if)
      (substitute smack-substitute) 
      (substitute-if smack-substitute-if)
      (nsubstitute smack-nsubstitute)
      (nsubstitute-if smack-nsubstitute-if)
      (map smack-map)
      (map-into smack-map-into)
      
      ;; hash tables
      clrhash gethash hash-table-count hash-table-p
      hash-table-rehash-size hash-table-rehash-threshold
      hash-table-size hash-table-test
      remhash sxhash
      (make-hash-table smack-make-hash-table)
      (maphash smack-maphash) 
      
      ;; reader
      ;; (read smack-read)
      ;; printer
      prin1 princ terpri print    
      ;; system construction
      (load smack-load-file)
      ;; environment
      decode-universal-time encode-universal-time
      get-decoded-time get-internal-real-time
      get-universal-time
      (lisp-implementation-type smack-lisp-implementation-type)
      (lisp-implementation-version smack-lisp-implementation-version)
      ;; smacklisp extension
      
      (%defconstant smack-defconstant)
      (%defstruct smack-defstruct)
      (quit smack-quit))
  
  )
  
  (defparameter *smack-constants*
    '(
  
negative.code:     ;; Control and data flow    
      eq equal eql
      not
      identity
      complement
      constantly
  