Re: sending function arguments to recursive function calls

[Pascal J. Bourguignon]

Dmitry Gutov <dgutov@yandex.ru> writes:

> On 17.05.2013 18:31, Drew Adams wrote:
>>> This is the ugly side of dynamic scoping.
>>> (defun foo () (let ((bar 42)) (baz)))
>>> (defun baz () bar)
>>> (foo) ; => 42
>>> baz ; => void-variable error
>>
>> Huh?  I guess you meant to write
>> (baz) ; => "void-variable bar" error
>
> No, I meant exactly to write variable reference, not function call, to
> illustrate that it's not defined globally.

Then you meant to write:

    bar

not:

    baz


>> There is nothing ugly about that behavior.
>
> It's ugly because this kind of code is hard to reason about and,
> consequently, hard to modify. Suppose I want to rewrite `foo' (and
> suppose it's longer than this one line).

Yes. That's why you should adopt the CL convention of naming all the
special variables (those with dynamic binding) with stars:

(defun foo ()
  (let ((*bar* 42)) 
     (declare (special *bar*))
     (baz)))

(defun baz ()
   (declare (special *bar*))
   *bar*)


(foo) ; => 42

*bar* ; Debugger entered--Lisp error: (void-variable *bar*)



> Can I rename `bar' to something else? 

Yes.  You should name it *bar*, and declare it special locally.  Right,
for now (declare (special *bar*)) has no effect in emacs lisp since it's
the default, but it states your intent!


> No idea: to be absolutely sure,
> I have to search the definitions of all functions that `foo' calls,
> and if I find a `bar' reference in any of them, I'll now have to
> search for any other functions that call them, etc. IOW, this makes
> for terrible composability.

Definitely.  That's why the default is lexical binding, and you have to
declare specially variables with dynamic binding, either with declare
special, or globally with defvar or defparameter.


> The behavior is ugly because it allows the code to be written this way.
>
> A worse example is when `bar' is one of the arguments to `foo' (ugh).

Global or local special declarations are still possible, even for
parameters.


>> The `let' binds variable `bar' for the dynamic extent of the call to `foo'.
>> There is no other binding of `bar' or assignment to it here, so `(baz)' 
>> refers
>> to an unbound variable `bar'.
>>
>> What happens with lexical scoping?
>> (foo) ; => "void-variable bar" error
>> (baz) ; => "void-variable bar" error
>
> As it should. Contrast this with the situation when `bar' has been
> defvar'ed in advance. Both functions would know that this var is
> global, so if it's renamed in some place, it definitely should be
> renamed in all functions that reference it.
>
> This is what I can call the light side of dynamic scoping, and it's
> how the term "dynamic binding" is often defined.
>
>> Dynamic binding facilitates user extension ("monkey patching").  And yes, 
>> this
>> is particularly important for a dynamic user environment like Emacs.
>>
>> It is easy to find references lauding the benefits of lexical binding (most
>> languages use only lexical binding).  Stallman explains well why dynamic 
>> binding
>> is important for Emacs:
>> http://www.gnu.org/software/emacs/emacs-paper.html#SEC17.
>
> I could offer some criticism for the paper, but there's really no need.
>
> Just recall that Emacs is on track to eventually replace dynamic
> scoping with lexical scoping everywhere, with exceptions for defvar'ed
> vars (controlled dynamic binding), and nobody is really arguing that
> Emacs will become too hard to customize as a result. Nobody reasonably
> well-informed, anyway.

Of course.  As long as dynamic binding is still available for the few
cases where it's needed, as in Common Lisp.


-- 
__Pascal Bourguignon__                     http://www.informatimago.com/
A bad day in () is better than a good day in {}.
You can take the lisper out of the lisp job, but you can't take the lisp out
of the lisper (; -- antifuchs