Re: add-to-list with lexical variables

[Hongxu Chen <leftcopy.chx@gmail.com>]

Thanks Pascal and Stefan! It's so kind of you to tell me so much
about the scope/binding.

It's much clear to me now(although I think I need to read your words and
do some practice to fully grasp it).

"Pascal J. Bourguignon" <pjb@informatimago.com> writes:

> Hongxu Chen <leftcopy.chx@gmail.com> writes:
>
>> However I still don't know the difference `lexical-binding' and
>> `lexical-let' brings. Are there some authoritative introductions/tutorials?
>
> http://www.emacswiki.org/emacs/DynamicBindingVsLexicalBinding
>
> Also, any Common Lisp tutorial covers them.  
>
>
> You may be interested by my explanations in the context of Common Lisp:
> https://groups.google.com/group/comp.lang.lisp/msg/58f1c7ed53d0c0d6
>
>
> But basically, it's a question of time vs. space.
>
>
> Dynamic is change over time.  So dynamic binding will be concerned by
> the time, by WHEN things are bound and referenced.
>
>
> Lexical is textual.  So lexical binding will be concerned by space, by
> WHERE in the text things are bound and referenced.
>
>
> With dynamic binding, things occur at certain times:
> #+BEGIN_SRC elisp  
> ;; with lexical-binding set to nil:
> (let ((list (list 1 2 3)))
>   (add-to-list 'list 0))
> #+END_SRC
>
> time
> ----
>
>  1.  the function list is called with arguments 1 2 and 3.
>
>  2.  it returns a list: (1 2 3).
>
>  3.  let creates a variable, it saves any dynamic binding the symbol
>      list may have, and it names the variable with the symbol list, and
>      it binds it (dynamically, at this time 3.) to the list (1 2 3).
>
>  4.  (quote list)  is evaluated.
>
>  5.  it returns the symbol list.
>
>  6.  0 is evaluated.
>
>  7.  it returns 0
>
>  8.  the function add-to-list is called with as arguments, the symbol
>      list and the integer 0.
>
>  9.  the function changes the dynamic binding of the symbol list.
>      remember at this time, while the function add-to-list is being
>      called, there symbol list is dynamically bound to the list (1 2 3),
>      since the time 3.
>
> 10.  it returns, and the dynamic binding to the variable list has been
>      changed.
>
> 11.  let destroys the dynamic binding of list, and destroys the variable
>      named list.  Whatever dynamic binding list had before is restored.
>
>  
>
> With lexical binding, what matters is the space, the place where
> expressions are:
> #+BEGIN_SRC elisp  
> ;; with lexical-binding set to t:
> (let ((list (list 1 2 3)))
>   (add-to-list 'list 0))
> #+END_SRC
>
> (let ((list (list 1 2 3)))
>   ;; From HERE
>   (add-to-list 'list 0)
>   ;; To HERE, there is a lexical variable named list.
>   )
>
> (defun add-to-list (variable value)
>   ;; From HERE
>   …
>   … code of add-to-list
>   …
>   ;; To HERE, we're outside the lexical scope of the let form above. 
>   ;; There is no lexical variable named list here!  Only the variables
>   ;; and parameters of add-to-list.
>   )
>
> So there's no way for add-to-list to access directly the lexical
> variable list defined in the let form.  
>
> It could access it indirectly, if you passed it a closure.  See for
> example:
> http://www.informatimago.com/articles/usenet.html#C-like-pointers-in-Lisp
> (those CL examples should run the same in emacs lisp with
> lexical-binding set to t).
>
>
> But since add-to-list is predefined not to use a closure, but to modify
> a dynamic binding, it won't change a lexical binding.  It's not it's
> purpose, it's not what it's designed to do.

-- 
Regards,
Hongxu Chen