Re: defining many similar functions using macros

[Kevin Rodgers]

Joe Corneli wrote:
> I would like to define them all in one go:
>
> (dolist (elt '("alpha"
>                "beta"
>                ...))
>   (define-tex-symbol elt))
>
> This seems like a good chance to use a macro.  My first experiment
> along these lines fails however, and I could use some help
> re-designing it.
>
> This macro works on single elements:
>
> (defmacro define-tex-symbol (name)
>   `(defun ,(intern (concat "tex-" name)) ()
>      (interactive)
>      (insert "\\" ,name)))
>
> E.g. (define-tex-symbol "alpha") ;=> tex-alpha
>
> But
>
> (dolist (elt '("alpha"
>                "beta"))
>   (define-tex-symbol elt))

[M-x rhetorical] Why is that better than:

(define-text-symbol "alpha")
(define-text-symbol "beta")

> triggers an error:
>
> Debugger entered--Lisp error: (wrong-type-argument sequencep elt)
>   concat("tex-" elt)
>   (intern (concat "tex-" name))
>   (list (quote defun) (intern (concat "tex-" name)) nil (quote (interactive)) (list 
(quote insert) "\\" name))
> ...
>
> There seem to be some subtleties associated with macro expansion
> that I'm missing here.  Help would be appreciated.

The macro argument NAME is bound to the unevaluated form the macro is
called with, e.g. "alpha".  If you want to be able to call the macro
with some other kind of form that must be evaluated to yield a string,
you have to write your macro to take that into account.

In Lisp, a macro transforms one expression into another, which is then
evaluated.  The backquote syntax makes it easy to specify the output
expression, and the comma syntax allows you to substitute forms
evaluated at compile-time for literal forms.  But then the resulting
expression still has to be evaluated.

A problem arises when you want to generate a call to another macro (e.g.
defun) that requires an unevaluated form (i.e. the function name symbol)
that you compute dynamically.  That's why you have to put the comma
before the  (intern ...) form: because this is valid

        (defun tex-alpha ...)

but this isn't

        (defun (intern (concat "tex-" "alpha")) ...)

As someone else pointed out, the solution is to use the fset function
instead of the macro:

(defmacro define-tex-symbol (name)
  `(fset (intern (concat "tex-" ,name))
         (lambda ()
           (interactive)
           (insert "\\" ,name))))

--
Kevin Rodgers