Is evaluating of constructed evaluation equal to macro?

问题

I want to know if these two definitions of nth are equal:

I. is defined as macro:

(defmacro -nth (n lst)
  (defun f (n1 lst1)
    (cond ((eql n1 0) lst1)
      (t `(cdr ,(f (- n1 1) lst1)))))
  `(car ,(f n lst)))

II. is defined as a bunch of functions:

(defun f (n lst)
  (cond ((eql n 0) lst)
        (t `(cdr ,(f (- n 1) lst)))))
(defun f1 (n lst)
  `(car ,(f n `',lst)))
(defun --nth (n lst)
  (eval (f1 n lst)))

Am i get the right idea? Is macro definition is evaluating of expression, constructed in its body?

回答1:

OK, let start from the beginning.

Macro is used to create new forms that usually depend on macro's input. Before code is complied or evaluated, macro has to be expanded. Expansion of a macro is a process that takes place before evaluation of form where it is used. Result of such expansion is usually a lisp form.

So inside a macro here are a several levels of code.

Not quoted code will be evaluated during macroexpansion (not at run-time!), in your example you define function f when macro is expanded (for what?);
Next here is quoted (with usual quote or backquote or even nested backquotes) code that will become part of macroexpansion result (in its literal form); you can control what part of code will be evaluated during macroexpansion and what will stay intact (quoted, partially or completely). This allows one to construct anything before it will be executed.

Another feature of macro is that it does not evaluate its parameters before expansion, while function does. To give you picture of what is a macro, see this (just first thing that came to mind):

(defmacro aif (test then &optional else)
  `(let ((it ,test))
     (if it ,then ,else)))

You can use it like this:

CL-USER> (defparameter *x* '((a . 1) (b . 2) (c . 3) (d . 4)))
*X*
CL-USER> (aif (find 'c *x* :key #'car) (1+ (cdr it)) 0)
4

This macro creates useful lexical binding, capturing variable it. After checking of a condition, you don't have to recalculate result, it's accessible in forms 'then' and 'else'. It's impossible to do with just a function, it has introduced new control construction in language. But macro is not just about creating lexical environments.

Macro is a powerful tool. It's impossible to fully describe what you can do with it, because you can do everything. But nth is not something you need a macro for. To construct a clone of nth you can try to write a recursive function.

It's important to note that LISP macro is most powerful thing in the programming world and LISP is the only language that has this power ;-)

To inspire you, I would recommend this article: http://www.paulgraham.com/avg.html

To master macro, begin with something like this:

http://www.gigamonkeys.com/book/macros-defining-your-own.html

Then may be Paul Graham's "On Lisp", then "Let Over Lambda".

回答2:

There is no need for either a macro nor eval to make abstractions to get the nth element of a list. Your macro -nth doesn't even work unless the index is literal number. try this:

(defparameter test-list '(9 8 7 6 5 4 3 2 1 0))
(defparameter index 3)

(nth index test-list)  ; ==> 6 (this is the LISP provided nth)
(-nth index test-list) ; ==> ERROR: index is not a number

A typical recursive solution of nth:

(defun nth2 (index list)
  (if (<= index 0) 
      (car list)
      (nth2 (1- index) (cdr list))))

(nth2 index test-list)  ; ==> 6

A typical loop version

(defun nth3 (index list)
  (loop :for e :in list
        :for i :from index :downto 0
        :when (= i 0) :return e))

(nth3 index test-list)  ; ==> 6

Usually a macro is something you use when you see your are repeating yourself too much and there is no way to abstract your code further with functions. You may make a macro that saves you the time to write boilerplate code. Of course there is a trade off of not being standard code so you usually write the macro after a couple of times have written the boilerplate.

eval should never be used unless you really have to. Usually you can get by with funcall and apply. eval works only in the global scope so you loose closure variables.

来源：https://stackoverflow.com/questions/24041571/is-evaluating-of-constructed-evaluation-equal-to-macro

标签

macros

lisp

common-lisp

evaluation