lexically set referenced symbol of a symbol within let bind form

Question

Is it possible to set a symbol that is the value of target symbol within the let bind form? because I am not setting a target symbol, I am not sure how to use let.

I am doing this because I am passing in a string that represents a library's name to generate a function for the library. look at the following link to see how I am using it https://github.com/natask/sexp-string/blob/6b748c133da51a129a465a426ae43b06c3a1331d/sexp-string.el#L189.

starting point, The following is a valid let form

(setq boolean 'dynamic-value)
(print boolean) ;; prints 'dynamic-value
(let ((boolean 'lexical-value))
   (print boolean)) ;; prints 'lexical-value

I am looking to modify lexically the variable boolean from a variable boolean-variable that contains the symbol boolean. boolean-variable is like a pointer to the pointer boolean.

(setq boolean 'first-value)
(setq boolean-variable 'boolean)
(print (symbol-value boolean-variable)) ;; prints 'first-value
(set  boolean-variable 'second-value)
(print boolean) ;; prints 'second-value

what I have,

(setq boolean 'dynamic-value)
(setq boolean-variable (intern-soft "boolean"))
(print boolean-variable) ;; prints 'boolean
(print (symbol-value boolean-variable)) ;; prints 'dynamic-value
(let ((old-boolean-variable (symbol-value boolean-variable)))
          (set boolean-variable 'lexical-value)
          ;; use boolean-variable in a function
          (print (symbol-value boolean-variable)) ;; prints 'lexical-value
          ;; set the value of variable back to previous value
          (set boolean-variable old-boolean-variable))
(print (symbol-value boolean-variable))  ;; prints 'dynamic-value

what I am looking for ,

(setq boolean 'dynamic-value)
(setq boolean-variable (intern-soft "boolean"))
(print boolean-variable) ;; prints 'boolean
(print (symbol-value boolean-variable)) ;; prints 'dynamic-value
(let (((symbol-content boolean-variable) 'lexical-value))) ;; creates a lexical binding to symbol 'boolean
    (print (access-symbol-lexically boolean-variable)) ;; prints 'lexical-value
)
(print (symbol-value boolean-variable)) ;; prints 'dynamic-value

I am not using the variable boolean directly but through a symbol because I am passing in a string something like the following.

(setq boolean-1 'dynamic-value)
(setq boolean-2 'dynamic-value)
(defun my-fun (library)
(setq boolean-variable1 (intern-soft (concat library "-1")))
(setq boolean-variable2 (intern-soft (concat library "-2")))
;;utilize variables
)
(my-fun "boolean")

Answer 1

@phils comment on his answer lead me to think of the following.

(setq boolean 'dynamic-value)
(setq boolean-variable (intern-soft "boolean"))
(print boolean-variable) ;; prints 'boolean
(print (symbol-value boolean-variable)) ;; prints 'dynamic-value
(eval `(let ((,boolean-variable 'lexical-value)) ;; creates a lexical binding
    (print ,boolean-variable) ;; prints 'lexical-value
    (print boolean) ;;prints 'lexical-value
))
(print (symbol-value boolean-variable)) ;; prints 'dynamic-value

strangely, I had to pass environment variables to eval in my case. I had thought eval captures environment variables automatically. https://github.com/natask/sexp-string/blob/9fbacdf620d9077b60270c63eaa6267be75fd855/sexp-string.el#L200

                    (eval
                     `(let ((,boolean-variable (or boolean ,boolean-variable)))
                     (pcase parsed-sexp
                        (`(,_) (->> `,(backquote ,(car parsed-sexp))
                                    backquote
                                    eval
                                    sexp-string-collapse-list))
                        (_ nil))) (list (cons 'boolean boolean) (cons 'parsed-sexp parsed-sexp))))))))

Answer 2

To my knowledge, if you have lexical-binding enabled in your library, then it cannot treat a given name as both dynamic and lexical. If you have declared a variable as dynamic by using defvar, then it will not be treated as lexically-bound. You must pick one or the other. This shouldn't be a problem because, by definition, all of the code which can access a lexically-bound variable is right there in that same block of code (within the scope of the lexical binding), where you can edit it -- so there's absolutely no reason to be using the same name as a dynamic variable.

Alternatively (but again, I don't see why you might need this) you can utilise the fake lexical binding macro lexical-let from the cl library, which was typically used to imitate lexical binding back when Emacs only supported dynamic binding.

---

I am looking to modify lexically the variable boolean from a variable boolean-variable that contains the symbol boolean. boolean-variable is like a pointer to the pointer boolean.

No, if you are using lexical-binding then this is not possible at all. There's no way of taking a symbol name and using it to find a lexical variable of that name, because the lexical variable isn't associated with the symbol at all.

C-hig (elisp)Lexical Binding explains:

Note that unlike dynamic variables which are tied to the symbol object itself, the relationship between lexical variables and symbols is only present in the interpreter (or compiler). Therefore, functions which take a symbol argument (like ‘symbol-value’, ‘boundp’, and ‘set’) can only retrieve or modify a variable’s dynamic binding (i.e., the contents of its symbol’s value cell).

Within the scope of a lexical-binding the only code which can access a given lexical variable is the code which directly references the variable name.

Answer 3

Experimenting with defmacro I think I found a way of taking a symbol name and using it to find the lexical value of the variable by that name under lexical-binding.

This makes a somewhat unconventional use of defmacro and I cannot say that I fully understand what is going on but I think this might contradict phils's statement in his answer above according to which:

No, if you are using lexical-binding then this is not possible at all. There's no way of taking a symbol name and using it to find a lexical variable of that name, because the lexical variable isn't associated with the symbol at all.

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

 (defmacro access-symbol-lexically (symbol)
   (eval symbol))

 (setq my-var "Dynamical")

 (let ((my-var "Lexical"))
   (print (access-symbol-lexically (intern "my-var")))  ;; prints "Lexical"
   )

The example discussed by the OP is mostly related to accessing a lexical variable but the question itself also mentions setting such variables. Here is a similar trick that does it:

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

 (defmacro set-symbol-lexically (symbol val)
   `(setq ,(eval symbol) ,val))

 (setq my-var "Dynamical")

 (let (my-var)
   (set-symbol-lexically (intern "my-var") "Lexical")
   (print my-var)  ;; prints "Lexical"
   )

Applying this to the question posed by the OP, we have:

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

 (defmacro access-symbol-lexically (symbol)
   (eval symbol))


 (setq boolean 'dynamic-value)
 (setq boolean-variable (intern-soft "boolean"))
 (print boolean-variable) ;; prints 'boolean
 (print (symbol-value boolean-variable)) ;; prints 'dynamic-value

 (let ((boolean 'lexical-value)) ;; creates a lexical binding to symbol 'boolean
 (print (access-symbol-lexically boolean-variable)) ;; prints 'lexical-value
 )
 (print (symbol-value boolean-variable)) ;; prints 'dynamic-value

---

EDIT: Here are some further examples of the above defmacro trick.

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

(defmacro access-symbol-lexically (symbol)
  (eval symbol))

(setq my-var "Dynamical")

(let ((my-var "Lexical"))
  (print (access-symbol-lexically (intern "my-var"))) ;; Prints "Lexical" (same as above example)
  (print (access-symbol-lexically 'my-var)) ;; Prints "Lexical"
  (setq s 'my-var)
  (print (access-symbol-lexically s)) ;; Prints "Lexical"
  (let ((s 'my-var) (my-var "Doubly Lexical")) (print (access-symbol-lexically s))) ;; Prints "Doubly Lexical"
  (let ((s 'my-var) ) (print (access-symbol-lexically s))) ;; Prints "Lexical"
  ;; From now on commands do not use above defmacro trick
  (print (eval 'my-var)) ;; Prints "Dynamical"
  (print (eval s)) ;; Prints "Dynamical"
  )