For example, I have:

(setq func-body (generate-2-arg-func)) => (+ arg1 arg2)

Now, I want to make a function symbol, auto-func, that takes two
arguments and returns the result of binding them into arg1 and arg2, and
executing func-body on them.  That is:

(defun auto-func (arg1 arg2) ?some-magic-stuff-involving-func-body?)

(auto-func 100 200) => 300

Can anybody hit me with a clue stick about this?  (I'm using CMUCL.)

(eval `(defun auto-func (arg1 arg2) ,func-body))

; (compile 'auto-func)

or

(compile 'auto-func `(lambda (arg1 arg2) ,func-body))

(auto-func 1 2)

 (defun auto-func (x y) (+ x y))

but I assume you're saying you want func-body to be a variable that
auto-func uses.

First know that it is bad style to use dynamic variables without *'s
on each end of the name unless you have some very important reason to
the contrary.  And variables are lexical by default, so let's assume
you've arranged to declare the specialness (i.e., dynamic nature) of the
variable using defvar or defparameter or something like that, as in:

 (defvar *func-body* (generate-2-arg-func))

and let's further assume that this yielded (+ *arg1* *arg2*) just for
clarity of anyone later trying to debug the system.  (Better yet, you might
want it to yield:

 (locally (declare (special *arg1* *arg2*))
    (+ *arg1* *arg2*))

if you want generate-2-arg-func to be side-effect free and not polluting
your special variable environment as a side-effect of calling it with
debugging args.  Anyway, all that given, you probably already defined
generate-2-arg-func by doing something vaguely like:

 (defun generate-2-arg-func ()
   (generate-n-arg-func '+ 2))

 (defun generate-n-arg-func (op n-args)
   (let ((vars (generate-args n-args)))
     `(locally (declare (special ,@vars))
        (,op ,@vars))))

 (defun generate-args (n-args)
   (loop for i below n-args
         collect (intern (format nil "*ARG~D*" i))))

So using the same generate-args function that you surely made as a subroutine
because you knew it would be so useful (wink), you would now write:

 (defun auto-func (&rest args)
   (let ((n-args (length args)))
     (progv (generate-args n-args) args ;bind n ars to n args
       (eval *func-body*))))  ; done in the environment of the special bindings

-- -- --

The other way to write this is not to use specials at all and to compose it
only with lexicals, but that involves promoting some function from text to
a real function using EVAL of a LAMBDA expression, or using COMPILE.

In this case, you'd write:

 (defun generate-2-arg-func ()
   (generate-n-arg-func '+ 2))

 (defun generate-n-arg-func (op n-args)
   (let ((vars (generate-args n-args)))
     `(,op ,@vars)))

 (defun generate-args (n-args)
   (loop for i below n-args
         collect (intern (format nil "ARG~D" i))))

 (defvar *func-body* (generate-2-arg-func))

 (defun auto-func (&rest args)
   (let ((n-args (length args)))
     (apply (compile nil `(lambda ,(generate-args n-args)
                            ,*func-body*))
            args)))

-- -- --

But all this really begs the question of why on earth you're trying to do
this in this detached way.  Can you back up from your problem and explain
why you would ever have a situation in which you knew the function body and
the args in so detached a way?  It's possible to handle, as you've seen here,
but it doesn't sound very much like any likely real-world scenario.

(It doesn't sound like homework either, so hopefully my doing a fully
elaborated answer isn't spoiling anything.)

-- -- ---

Notes:

 * It doesn't matter that you're using CMUCL.  This kind of stuff is
   identical in all implementations of CL.

(defun generate-2-arg-func () #'(lambda (x y) (+ x y)))
(setq func-body (generate-2-arg-func))
(defun auto-func (arg1 arg2) (funcall func-body arg1 arg2))
(auto-func 100 200) -> 300

------------------

The other way would be an awful construct:

(defun generate-2-arg-func () '(+ arg1 arg2))
(setq func-body (generate-2-arg-func))
(defun auto-func (x y)
   (let ((arg1 x) (arg2 y))
     (declare (special arg1 arg2))
     (eval func-body)
     ))
(auto-func 100 200) -> 300

(defun auto-func (fn &rest arguments)
  (apply fn arguments))

Thanks very much!  The "compile" version worked great, and is simple
enough that I can (almost :-) understand what's going on.  It looks like
I'll have to go over the quoting and unquoting mechanisms more
carefully...I'm aware of the "," operator to unquote in macros, but I
never needed it before and don't really understand how it works yet.

To respond to the questions about what I'm doing, I'm *trying* to work
through the even-parity-3 example in Koza's _Genetic_Programming_III_
book.  Abstractly, it makes plenty of sense, but I'm trying to code it
up and reproduce the runs.

So, I've started by making a random code generator, which produces a
parameterized executable form based on a list of initial terminals and
functions.  And, now that I can turn these forms into real functions,
I'm going to make a bunch of them and call them with various arguments
to see which ones come closest to producing the results I want.  Then,
I'll work out the combination and mutation code, mate the best members
of the initial population, and check out their offspring.  And so on.

(list '+ pi pi)

is the same as:

`(+ ,pi ,pi)

You can think of it as follows:

In (list '+ pi pi) you have write the list
constructing function (here LIST) and you have
to quote the constants (here the symbol +).

In `(+ ,pi ,pi) you write a list template and
everything is constant - except in the places
after the minus characters - so
you are unquoting (-> forcing the evaluation
at these places). So it is kind of opposite from
the above.

  Except that the result of the backquote form is to be treated as a
  constant.  The list structure may not be modified as it might be
  shared with other list structures.

  (list ...) constructs a list at run-time.
  `(...) constructs at least parts of the list at read-time.