How to overcome the lack of local variable for emacs lisp closure

Question

I'm now studying Emacs Lisp from the reference manual and Common Lisp from a LISP Book.

from the Common Lisp book

>> (setf power-of-two
     (let ((previous-power-of-two 1))
       #'(lambda ()
           (setf previous-power-of-two
             (* previous-power-of-two 2)))))

>> (funcall power-of-two)
2

>> (funcall power-of-two)
4

>> (funcall power-of-two)
8

The function won't work in Emacs Lisp because of its dynamic binding behavior.

I wonder if it is possible to implement the same function in Emacs Lisp without introducing a global variable ?

You might save yourself a lot of time by using a Common Lisp with Slime in emacs. SBCL is my favourite. — justinhj, Aug 05 '11 at 16:54
@justinhj: Thanks for the tip. However, I'm learning lisp just to get to know emacs better. Unless something is going to change my mind, I think I prefer python over lisp with a really wide margin. — Sake, Aug 06 '11 at 05:46
That makes sense. BTW when using emacs lisp to extend emacs think about how you would do the same in Python. IMHO emacs lisp is an ideal language for extending a text editor, whilst Python, which I also really like, has many different uses. — justinhj, Aug 06 '11 at 05:58
Emacs lisp does not really reflect the experience of using lisps targeted at "real programming" like common lisp. Accordingly, it's not a fair comparison with python, which is not really intended to be used as an embedded scripting language as its first use. — Marcin, Dec 12 '11 at 12:38
Marcin, I'm sure lisp is a really powerful concept. Unfortunately, even after few months, I personally still not very comfortable with lisp syntax. — Sake, Dec 12 '11 at 12:43

danlei · Accepted Answer · 2012-07-17T23:05:34.497

18

Update:

By now, Emacs 24 has been officially released, and it supports lexical binding without using lexical-let, when the buffer-local variable lexical-binding is non-nil. See also M-: (info "(elisp) using lexical binding") and pokita's answer.

You can use lexical-let from the Common Lisp Extensions (the "CL package"):

elisp> (require 'cl)
cl
elisp> (setf power-of-two
             (lexical-let ((previous-power-of-two 1))
               #'(lambda ()
                   (setf previous-power-of-two
                         (* previous-power-of-two 2)))))
(lambda
  (&rest --cl-rest--)
  (apply
   (lambda
     (G175638)
     (set G175638
          (*
           (symbol-value G175638)
           2)))
   '--previous-power-of-two-- --cl-rest--))

elisp> (funcall power-of-two)
2
elisp> (funcall power-of-two)
4
elisp> (funcall power-of-two)
8

I've also heard about a lexbind branch of GNU Emacs.

edited Jul 17 '12 at 23:05

answered Aug 05 '11 at 11:47

danlei

14,121
5
58
82

And `M-x ielm` to get the elisp REPL. – phils Aug 05 '11 at 12:39
@phil I suppose the hint is for me ? :) – Sake Aug 05 '11 at 14:41
This is a good read to go deep into lexical scope in emacs lisp http://www.gnu.org/software/emacs/emacs-paper.html#SEC17 – justinhj Aug 05 '11 at 16:57

score 12 · Answer 2 · answered Aug 05 '11 at 12:03

12

Emacs24 from bzr now supports lexical binding out of the box; it just isn't activated by default since there are many packages which still deliberately or inadvertently depend on dynamical scoping. Your above code should work just fine in Emacs24 in a buffer where the variable 'lexical-binding' is set to 't'.

answered Aug 05 '11 at 12:03

pokita

1,241
10
12

1

Thanks for the info. I'm really curious if painless transition from dynamic-binding to lexical-binding could be possible. But it's great to know that emacs is still evolving. And I'm really looking forward to devote some effort to help when my skill is good enough. – Sake Aug 06 '11 at 05:41
Dynamic binding is one of the key reasons that Emacs is so easily extensible. It's certainly nice to have the alternative available, but I hope that dynamic binding will always be the standard for most elisp code. – phils Aug 07 '11 at 12:10

score 2 · Answer 3 · answered Sep 10 '11 at 17:46

2

See this page: http://www.emacswiki.org/emacs/FakeClosures

answered Sep 10 '11 at 17:46

Drew

29,895
7
74
104

score 1 · Answer 4 · answered Dec 12 '11 at 12:30

another solution using Emacs' unintern symbol:

ELISP> (setf power-of-two
         (let ((p (make-symbol "previous-power-of-two")))
           (set p 1) (list 'lambda '()
           (list 'setf p
             (list '* p 2)))))

ELISP> (funcall power-of-two)
2
ELISP> (funcall power-of-two)
4
ELISP> (funcall power-of-two)
8

How to overcome the lack of local variable for emacs lisp closure

4 Answers4

Linked