anchor.diff:              ,@sub-table)
            ,@body))))
   
  -;;;; EXAMPLE
  -;;;; (with-data-table (:row V1! :col V2! :data D!)
  -;;;;     ((   'a 'b 'c)
  -;;;;      ('a  1  2  3)
  -;;;;      ('b  4  5  6)
  -;;;;      ('c  7  8  9))
  -;;;;   (format t "~S ~S ~S~%" v1! v2! D!))
  -       
  -          
  +
  +;; WITH-SUBSTITUTED-COMBINATIONS:          
   (defmacro with-substituted-combinations (substitution-sets &body body)
     "Where Bindings = ((v1 m1 m2 m3 ..)
                        (v2 m4 m5 m6 ...)
  
positive.code: ;;;;  [{[ERB _] + [NRG _] ->> [[ERB 1] [NRG 1]]}
  ;;;;   (|.SET-RATE-FUNCTION| 'MASS-ACTION 0.001)])
  
  (defmacro with-substitution-table ((header &rest data) &body body)
    "The table consists of a header (symbols/column names) and data, a 
     set of lists containing the values corresponding to each column.
  
negative.code:     `(with-substitutions ,binding-sets
         ,@body)))
  
  ;;;; WITH-DATA-TABLE:  
  ;;;; User specifies:
  ;;;;    * substitution variables
  ;;;;    * 2D-table of columns and rows
  ;;;;    * body of code
  ;;;; For each cell in the table, the macro results
  ;;;; in a substituted version of the code where the
  ;;;; column headers and row headers as well as data
  ;;;; are substituted everywhere the variables appear.
  ;;;; 
  ;;;; The user can specify a value which signals a cell 
  ;;;; should be ignored.  By default this is NIL.
  ;;;;
  ;;;; 
                 
  ;;;; EXAMPLE
  ;;;; (with-data-table (:row V1! :col V2! :data D!)
  ;;;;     ((   'a 'b 'c)
  ;;;;      ('a  1  2  3)
  ;;;;      ('b  4  5  6)
  ;;;;      ('c  7  8  9))
  ;;;;   (format t "~S ~S ~S, " v1! v2! D!))
  ;;;; =>
  ;;;  A A 1, A B 1, A C 3, B A 4, B B 5 ...
         
  (defmacro with-data-table ((&key row col data ignore) (colnames &rest rows) &body body)
    "ROW COL and DATA are substituted in the code (BODY).  If a cell contains the ignore symbol,
     no substitutions will be performed.  By default, IGNORE is NIL."
    (let* ((row        (or row (gensym "row")))
           (col        (or col (gensym "col")))
           (data       (or data (gensym "data")))
           (sub-table  (mapcan
                       (lambda (rowlist)
                         (loop with rowname = (first rowlist)
                               for colname in colnames
                               for d in (rest rowlist)
                               unless (eq d empty)
                               collect (if (listp data) (list* colname rowname d)
                                         (list colname rowname d))))
                       rows)))
  