Why a parameter of an Emacs lisp function is not evaluated?

Question

I want to define a list of accumulators with Emacs Lisp and write the following code, but I got a error saying that initV is a void variable. It seems initV is not evaluated in the function define-accum. Where is I make a mistake? (I just want to know why although I know there is other ways to reach my target.)

(defun define-accum (name initV)
  (defalias name (lambda (v) (+ v initV))))

(setq accums '((myadd1 . 1)
               (myadd2 . 2)))

(dolist (a accums)
  (define-accum (car a) (cdr a)))

(message "result = %d" (+ (myadd1 1) (myadd2 1)))

juanleon · Accepted Answer · 2014-07-17 06:29:48Z

3

You need to use backquotes properly. This would work for you, for instance:

(defun define-accum (name initV)
  (defalias name `(lambda (v) (+ v ,initV))))

See here for an explanation

answered Jul 17, 2014 at 6:29

juanleon

9,4901 gold badge33 silver badges42 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

Yantao Xie Over a year ago

Thanks. I know the usage of backquotes but I still don't understand why there should be quoting.

Tobias Over a year ago

The problem is that lambda is self-quoting. Therefore, initV stands literally in the alias. It is undefined at the evaluation of the alias.

legoscia · Accepted Answer · 2014-07-17 10:19:04Z

2

Apart from using backquotes, you can activate lexical binding (if you're using Emacs 24 or newer). For example, if I put your code in a .el file and put this on the first line:

;; -*- lexical-binding: t -*-

then I get the output:

result = 5

This works because the lambda function in define-accum will reference the initV in the environment where it's being defined (thus picking the variable in the argument list), and create a closure over this variable. With dynamic binding (the default), the function would look for initV in the environment where it's being called.

answered Jul 17, 2014 at 10:19

legoscia

42.1k23 gold badges123 silver badges179 bronze badges

Comments

Drew · Accepted Answer · 2014-07-17 16:01:36Z

1

To add a little to what others have said -

If the variable (initV) is never actually used as a variable, so that in fact its value at the time the accumulator is defined is all that is needed, then there is no need for the lexical closure that encapsulates that variable and its value. In that case, the approach described by @juanleon is sufficient: it uses only the value at definition time - the variable does not exist when the function is invoked (as you discovered).
On the other hand, the lexical-closure approach lets the function be byte-compiled. In the backquote approach, the function is simply represented at runtime by a list that represents a lambda form. If the lambda form represents costly code then it can make sense to use the lexical-closure approach, even though (in this case) the variable is not really needed (as a variable).
But you can always explicitly byte-compile the function (e.g. ##NAME## in your define-accum. That will take care of the inefficiency mentioned in #2, above.

answered Jul 17, 2014 at 16:01

Drew

30.9k7 gold badges81 silver badges111 bronze badges

1 Comment

Stefan Over a year ago

Note that closures don't like "variables" any more than backquoted lambdas. The only difference is that the byte-compiler will take care of rewriting the code for you if needed (e.g. it will turn (let ((a 1)) ... (setq a ..) ... a ...) into (let ((a (list 1))) ... (setcar a ..) ... (car a) ...)).

Collectives™ on Stack Overflow

Why a parameter of an Emacs lisp function is not evaluated?

3 Answers 3

2 Comments

Comments

1 Comment

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

2 Comments

Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Related