Questions tagged [lexical-scoping]

The tag has no usage guidance.

Filter by
Sorted by
Tagged with
33 votes
3 answers
2k views

Why is `let' faster with lexical scope?

While reading through the source code for the dolist macro, I ran into the following comment. ;; This is not a reliable test, but it does not matter because both semantics are acceptable, tho one ...
Malabarba's user avatar
  • 23.2k
18 votes
2 answers
830 views

Why do setq and set quote act differently on let-bound variables with lexical scope?

I had a bug in one of my extensions that eventually turned out to be caused by set not working as I expected: ;; -*- lexical-binding: t -*- (let ((a nil)) (setq a t) (print a)) (let ((a nil)) ...
dshepherd's user avatar
  • 1,281
18 votes
1 answer
8k views

Dealing with "Warning: assignment to free variable" when certain libraries can be missing by design

Byte compilation of my mode: (defun dict-setup-expansions () "Add `dict-mode' specific expansions." (set (make-local-variable 'er/try-expand-list) (list #'dict-mark-article))) gives ...
gavenkoa's user avatar
  • 3,452
16 votes
3 answers
789 views

Defun inside let with lexical binding gives byte-compile warning "the function is not known to be defined"

I want to get the effect of a static variable by using defun inside of let with lexical binding to create a closure. However, when byte-compiling the file, I get a warning. Am I doing something wrong, ...
Rose Kunkel's user avatar
14 votes
1 answer
493 views

What are the potential pitfalls of enabling lexical-binding for a buffer?

This was inspired by the discussion of lexical-binding vs lexical-let in this question. As lexical-binding gives you the ability to have useful closures people may be used to in other languages like ...
stsquad's user avatar
  • 4,661
11 votes
1 answer
224 views

How is the variable scoping for macros determined?

Take the following example macro, defined in macro.el. (defmacro some-macro (&rest body) `(let ((some-variable 1)) ,@body)) And take the following function, defined in a different file, ...
Malabarba's user avatar
  • 23.2k
10 votes
3 answers
382 views

Why does defvar scoping work differently without an initvalue?

Suppose I have a file named elisp-defvar-test.el containing: ;;; elisp-defvar-test.el --- -*- lexical-binding: t -*- (defvar my-dynamic-var) (defun f1 (x) "Should return X." (let ((my-dynamic-...
Ryan C. Thompson's user avatar
8 votes
2 answers
1k views

'Symbol's value as variable is void' in callback from url-retrieve

When executing the following I get an error: (defun caller (func) (url-retrieve "http://m0smith.freeshell.org/" (lambda (status) (funcall func)))) (caller (lambda() (message "called"))) Result:...
M Smith's user avatar
  • 279
6 votes
2 answers
465 views

Why doesn't "complement" work as a function?

I'm trying to implement the complement function from Common Lisp (CL) in Emacs Lisp, but I'm confused by why defining it as a function (as opposed to a macro) does not work. The macro definition is ...
Tianxiang Xiong's user avatar
6 votes
1 answer
1k views

Scope in lambda

In my .emacs conf file, I've got this function that adds a hook to set the compile-command based on the mode. It looks something like, (defun set-compile-cmd (mode-hook cmd) (add-hook mode-hook (...
user1943733's user avatar
5 votes
1 answer
500 views

About closure creation

After reading this article about readable closures, I check that: Since closures are byte-code function objects, they print readably. You can capture an environment in a closure, serialize it, ...
anquegi's user avatar
  • 749
5 votes
1 answer
800 views

void-function lexical-let

I'm using this code on Xubuntu (emacs 24.5.1) but it throw error on windows (emacs 25.0.50.1 64bit) (defun ignore-error-wrapper (fn) "Funtion return new function that ignore errors. The function ...
jcubic's user avatar
  • 743
5 votes
2 answers
1k views

defun in defun is not local?

I am reading SICP to learn Lisp, the book uses Scheme dialect. I want accommodate it to emacs lisp, I find something weird in 3.1.1 and cannot figure it out, say I have a test.el file: (defun make-...
Alaneuler's user avatar
  • 277
4 votes
3 answers
2k views

Alternative to lexical-let

I'd rather not use cl-lib and cl at the same time. However, I really like using lexical-let to specify the usage of lexical binding on a more granular level. Is there any equivalent in cl-lib or ...
PythonNut's user avatar
  • 10.4k
4 votes
3 answers
239 views

idiomatic way to lexically scope variables in a cl-loop body

Here is some asynchronous code in a cl-loop: ;;; foo.el --- -*- lexical-binding: t; -*- (let ((my-list '(a b c))) (cl-loop for index below (length my-list) ...
Damien Cassou's user avatar
4 votes
1 answer
69 views

why is a let binding is ignored in compiled function?

I have this function which works perfectly in an uncompiled function. It should let-bind the variable bibtex-completion-bibliography to the result of (org-ref-find-bibliography). (defun org-ref-...
John Kitchin's user avatar
  • 11.9k
4 votes
1 answer
250 views

Make a variable visible to some functions only

Consider the following metacode: ;;; -*- lexical-binding: t -*- (defvar var1 ...) (defvar var2 ...) (defun main () "Main entry point" ...) (defun func1 ...) (defun func2 ...) ... (defun funcn ...)...
antonio's user avatar
  • 1,822
4 votes
1 answer
771 views

Can turning on lexical binding in a legacy init file cause problems?

AFAIK turning on lexical binding only affects the current buffer. But if I add lexical scoped code to my crusty old init file which have load and require statements in it (not everything is autoloaded)...
Tom's user avatar
  • 1,260
3 votes
3 answers
343 views

How does scoping work in emacs lisp

A lot of emacs configurations shared publicly have this format: ;; 01-something.el (provide 'something) ;; init.el (require 'something) Suppose I'm writing a defun named "s-join" inside 01-...
american-ninja-warrior's user avatar
3 votes
3 answers
937 views

How to avoid use of `lexical-let`

I have a macro that intends to creates a closure: ; -*- lexical-binding: t -*- (defmacro repro () (let ((kmap-sym (gensym "kmap-"))) `(let ((,kmap-sym (make-sparse-keymap))) (define-key ,...
erjoalgo's user avatar
  • 863
3 votes
2 answers
579 views

Accessing the global value of a locally altered variable

Is it possible to access the global value of a variable that has been changed locally? (setq foo 2) (let ((foo 3)) ;; can I access the original value here? )
Toothrot's user avatar
  • 3,264
3 votes
2 answers
259 views

byte-compile and lexical-binding

Could someone in the know please help me understand what's going on here: ;; -*- lexical-binding: t; -*- (let* ((a 0)) (let* ((a 1)) (funcall (byte-compile (lambda () a))))) ;;=> 0 wat? Not ...
zeRusski's user avatar
  • 335
2 votes
3 answers
355 views

Bringing a function into a lexical environment

I'm using a closure to keep track of some stuff to do with state; I want to be able to ‘include’ a function into that closure, so it can access the state. The only way this is possible is by creating ...
digitalis_'s user avatar
2 votes
1 answer
368 views

Reliable lexical binding?

How does one reliably create a lexically bound/scoped variable? Consider the following: ;; -*- lexical-binding: t; -*- (let ((f load-file-name)) (defun foo () f)) Normally f would be lexically ...
Richard Hansen's user avatar
2 votes
2 answers
208 views

Lexical capture/access local scope in function, the same way as lambda

I'd like to use a function reference in place of a lambda, however the lambda in question captures a lot of locally scoped vars declared in an enclosing let. For example: (let ((x 1)(y 2)(z 3) (...
ocodo's user avatar
  • 1,222
2 votes
1 answer
342 views

Why does this straightforward use of a closure fail?

Suppose you save the following code to some file test.el and then do load-file test.el ;;; -*- lexical-binding: t -*- (let ((closure-vbl 0)) (defun tst () (eval 'closure-vbl))) (tst) You get ...
Jonathan Ganc's user avatar
2 votes
1 answer
70 views

`make-local-variable` Behaves Differently depending on Whether Variable is Special

Two examples (both are in the *scratch* buffer and under lexical scoping rule): _ (setq xx :default) (let ((xx :let)) (with-current-buffer (get-buffer-create "tmp") (make-local-...
shynur's user avatar
  • 5,308
2 votes
2 answers
151 views

Increase the level of dynamic binding with backtick / comma

I have a favorite function that contains several levels of set-process-sentinel and lambda sentinels. I have been using lexical-let, but would like to see if it is possible to use dynamically bound ...
lawlist's user avatar
  • 19.1k
2 votes
1 answer
182 views

lexical-binding only set at the buffer level?

According to this, it seems to say setting lexical-binding only happens at the individual buffer level, i.e. I could not do (setq lexical-binding t) in my init file and have it apply to all subsequent ...
147pm's user avatar
  • 2,969
2 votes
1 answer
239 views

What effect does eval-and-compile have on a defun-within-let?

The byte-compiler does not currently seem to recognise that a function has been defined when using defun within a let expression under lexical-binding, as explained in Stefan's answer to this question....
Basil's user avatar
  • 12.4k
2 votes
1 answer
104 views

Allow custom function to take from lexical environment

I am trying to convert my code to use lexical binding. I have a function (format-template) that calls a lambda function (let-bound to replacer-inner) from a user-customizable list (template-replace-...
rnkn's user avatar
  • 255
1 vote
1 answer
278 views

How to temporarily change the definition of a function?

In the following code the function foo calls the outer f2 function. How to make it call the anonymous function bound within the let? (defun f2 () (message "outer f2")) (defun foo () (f2)...
Talespin_Kit's user avatar
1 vote
2 answers
614 views

How to get an insert-text-button 'action property accessing a dynamically-bound buffer-local variable

In realgud I have a text button that needs access to a dynamically-bound buffer-local variable. The situation occurs like this. Inside one buffer that has the buffer local variable, there is a ...
rocky's user avatar
  • 898
1 vote
1 answer
53 views

Inconsistency in emacs' rules of scope?

I have always felt that emacs' rules of scope are a bit strange and prone to contradictions. In fact I have even attempted to file bug reports just to be told that my interpretation of the rules of ...
Ruy's user avatar
  • 839
1 vote
1 answer
127 views

Cannot assign current buffer name in let statement

I'm trying to write some buffer switching function (which in itself may be a fool's errand, but I digress...) - and it looks a little like this (defun swk--quit-buffer (original-buffer) (switch-to-...
sunwukung's user avatar
  • 227
1 vote
2 answers
37 views

Closure does not capture variable

I wrote the following code, but it does not work: (progn (define-prefix-command 'unicode-shortcut-keymap) (dolist (mapping '(("- >" . "→"))) (let ((keys (car mapping)) ...
ceving's user avatar
  • 1,358
1 vote
1 answer
95 views

Warning: assignment to free variable ‘skeleton-pair’

Am using the following function, but getting the error In bracemk-balance: fencones.el:109:9:Warning: assignment to free variable ‘skeleton-pair’ What is wrong with this? (defun bracemk-balance ()...
Dilna's user avatar
  • 1
1 vote
1 answer
71 views

Top-level variables, local variables, variable scoping and the difference between set and setq

I've been reading about emacs dynamic and lexical bindings. While I generally get the difference between the two types, there is one example that is not clear to me. I've checked this question and I ...
Ivan Ruski's user avatar
1 vote
1 answer
127 views

Void-variable error when lambda function calls itself

Here's a simple test: (let ((func (lambda (i) (when (> i 0) (print i) (funcall func (1- i)))))) (funcall func 3)) It says (void-variable func), but ...
Tom's user avatar
  • 1,260
1 vote
1 answer
63 views

Referencing Lexically Bound Variable in Mocked Function

I'd like to mock a function for a unit test that I'm writing. I want the mocked function to count how many times it was called but I'm having issues related to the scope of the count variable. Here ...
kfoley's user avatar
  • 527
1 vote
1 answer
61 views

Lexical binding in a process filter

The code constantly prints server-process: nil instead of the server process name: -*- lexical-binding: t; -*- (let* ((port 1234) (server-process 'something)) (setq server-process (...
Damien Cassou's user avatar
0 votes
3 answers
202 views

How did `cl-flet` got circumvented?

I want to slightly alter the behavior of counsel-fzf by locally changing the definition of counsel-fzf-action, which activates in the end of the definition of the former. See the source code of ...
Student's user avatar
  • 225
0 votes
1 answer
116 views

Search in readable eww buffer [duplicate]

I would like to open url in eww in readable-mode and find str. Below is my code that doesn't work: (defun my-eww-searh-readable (str) "Once-off call to `my-eww-searh-readable' after EWW is done ...
Pfedj's user avatar
  • 338
0 votes
2 answers
77 views

Different behavior of same function defined at two places: symbol's value as variable is void

I implemented a couple of extra functions that work with projectile and have been keeping them in my dotfiles as they are not yet a part of the original package. When the functions are defined in the ...
myTerminal's user avatar
0 votes
1 answer
133 views

eval-defun ignores lexical-binding

Today I discovered that if you re-evaluate a defun using eval-defun (C-M-x) in a buffer with lexical-binding set to t, the defun is recreated as an ordinary lambda, not a closure. For example, after ...
Sean's user avatar
  • 941
0 votes
2 answers
271 views

How to fix byte compiler warnings for "Unused lexical variable" in a macro?

I have a macro and a function which uses it: (defmacro oauth2-auto--query-case (&rest cases) "Handle HTTP queries based on the keys present in ‘query-alist’. ‘query-alist’ is a free ...
telotortium's user avatar
0 votes
1 answer
174 views

Forcing lexical-scope in the middle of dynamic-scope

Today I ran head first into lexical vs dynamic scope in Emacs Lisp. Gist of it is I have a macro defined in lexical scope that expands into a `defun'. Let's say something simple like this: ;; -*- ...
zeRusski's user avatar
  • 335
0 votes
1 answer
49 views

capture and replay a closure later

I am having a problem working with closures. I hope I can explain this clearly. When I try to start a compilation I typically do it like this: (let ((dir (get-dir)) (model-root root) (default-...
Prgrm.celeritas's user avatar
0 votes
0 answers
43 views

dynamic scoping doesn't perform as expected

(require 'cl) (require 'seq) (require 'dash) (eval-when-compile (require 'cl-lib) (require 'subr-x) (require 'env) (require 'json)) (defgroup chatgpt nil "ChatGPT frontend." :...
A-nak Wannapaschaiyong's user avatar