local binding, too local...

local binding, too local...

[Jean-Christophe Helary]

In a defun I wrote I have a let* block that does something, then some setf code, then a let block that does something on the values created by setf, but the let block needs a value that it set in the let* block.

I would like to keep things local, but not *that* local, just *defun* local.

Is there a clean way to declare variables local to a defun and without being locked by let\*? blocks ?



Jean-Christophe Helary
-----------------------------------------------
http://mac4translators.blogspot.com @brandelune

RE: local binding, too local...

[Drew Adams]

> In a defun I wrote I have a let* block that does something, then some
> setf code, then a let block that does something on the values created
> by setf, but the let block needs a value that it set in the let* block.
> 
> I would like to keep things local, but not *that* local, just *defun*
> local.
> 
> Is there a clean way to declare variables local to a defun and without
> being locked by let\*? blocks ?

How about an example?  It's not clear to me what
you are describing.

Re: local binding, too local...

[Yuri Khan]

On Sat, Dec 8, 2018 at 9:19 AM Jean-Christophe Helary
<brandelune@gmail.com> wrote:

> In a defun I wrote I have a let* block that does something, then some setf code, then a let block that does something on the values created by setf, but the let block needs a value that it set in the let* block.

The customary way is to put the consumer block within the producer block:

    (defun foo ()
      (let* ((bar '(baz quux)))
        (setf (car bar) 'xyzzy)
        (let ((plugh (cdr bar)))
          (message "%s" plugh))))

> I would like to keep things local, but not *that* local, just *defun* local.
>
> Is there a clean way to declare variables local to a defun and without being locked by let\*? blocks ?

let and let* are *binding* forms, not *assignment* statements. The
bindings go in scope, the body is executed, the bindings go out of
scope.

setq, on the other hand, is an assignment form. If a named variable
exists in the current scope, it will reset its value.

However, the longer a variable is and the broader its scope is, the
more difficult it is to track where and how it it modified.

Re: local binding, too local...

[Jean-Christophe Helary]

> On Dec 8, 2018, at 15:48, Yuri Khan <yurivkhan@gmail.com> wrote:
> 
> On Sat, Dec 8, 2018 at 9:19 AM Jean-Christophe Helary
> <brandelune@gmail.com> wrote:
> 
>> In a defun I wrote I have a let* block that does something, then some setf code, then a let block that does something on the values created by setf, but the let block needs a value that it set in the let* block.
> 
> The customary way is to put the consumer block within the producer block:
> 
>    (defun foo ()
>      (let* ((bar '(baz quux)))
>        (setf (car bar) 'xyzzy)
>        (let ((plugh (cdr bar)))
>          (message "%s" plugh))))

Eventually that's what I did. But I was not sure if that would be considered a "hack" or is the correct way to think about things.

>> I would like to keep things local, but not *that* local, just *defun* local.
>> 
>> Is there a clean way to declare variables local to a defun and without being locked by let\*? blocks ?
> 
> let and let* are *binding* forms, not *assignment* statements. The
> bindings go in scope, the body is executed, the bindings go out of
> scope.
> 
> setq, on the other hand, is an assignment form. If a named variable
> exists in the current scope, it will reset its value.

I'm not sure I understand the difference yet between binding and assigning yet.


Jean-Christophe Helary
-----------------------------------------------
http://mac4translators.blogspot.com @brandelune

Re: local binding, too local...

[Jean-Christophe Helary]

> On Dec 8, 2018, at 15:07, Drew Adams <drew.adams@oracle.com> wrote:
> 
>> In a defun I wrote I have a let* block that does something, then some
>> setf code, then a let block that does something on the values created
>> by setf, but the let block needs a value that it set in the let* block.
>> 
>> I would like to keep things local, but not *that* local, just *defun*
>> local.
>> 
>> Is there a clean way to declare variables local to a defun and without
>> being locked by let\*? blocks ?
> 
> How about an example?  It's not clear to me what
> you are describing.


Sorry I was going to reply but that's exactly what Yuri described and the solution I adopted is exactly what he suggested.

Jean-Christophe Helary
-----------------------------------------------
http://mac4translators.blogspot.com @brandelune

Re: local binding, too local...

[tomas]

[-- Attachment #1: Type: text/plain, Size: 878 bytes --]

On Sat, Dec 08, 2018 at 04:37:59PM +0900, Jean-Christophe Helary wrote:

[...]

> I'm not sure I understand the difference yet between binding and assigning yet.

Binding: you associate a name (strictly: a symbol) to a place where to
store something (a "variable").

Assigning: you change the content (the thing stored in) an existing variable.

Often you get those two steps in one package, and that's why the difference
isn't so clear.

Consider:


  (let ((foo 12)) ; bind a variable to the symbol foo
    ...
    (... ; some sub-scope, e.g. another let
         ; let's assume it does *not* bind foo
      (setq foo 13) ; Now the foo is bound to the same variable,
                    ; but that contains now 13
    ))

Things are a bit confusing, because (let ((foo 12)) ...) binds foo *and*
assigns 12. But you could just use (let (foo) ...) in its pure form

Cheers
-- t

[-- Attachment #2: Digital signature --]
[-- Type: application/pgp-signature, Size: 198 bytes --]

Re: local binding, too local...

[Rusi]

Yuri wrote:

      (let* ((bar '(baz quux))) 
        (setf (car bar) 'xyzzy) 
        (let ((plugh (cdr bar))) 
          (message "%s" plugh)))) 

Can also be written
(let (bar plugh) 
 (setf bar '(baz quux))
 (setf (car bar) 'xyzzy)
 (setf plugh (cdr bar)))

IOW declare variables without initializers. Then write 'normal'imperative code

Re: local binding, too local...

[Jean-Christophe Helary]

Thank you Tomas.

So can you say that "binding" is like "creating" a variable ?
While assigning is just putting a value in that variable ?

I remember in my math classes, when we were using x and y, etc. we were binding x and y, right ? And then when we had values for x and y we were assigning values. Is that correct ?

Jean-Christophe 

> On Dec 8, 2018, at 17:02, <tomas@tuxteam.de> <tomas@tuxteam.de> wrote:
> 
> On Sat, Dec 08, 2018 at 04:37:59PM +0900, Jean-Christophe Helary wrote:
> 
> [...]
> 
>> I'm not sure I understand the difference yet between binding and assigning yet.
> 
> Binding: you associate a name (strictly: a symbol) to a place where to
> store something (a "variable").
> 
> Assigning: you change the content (the thing stored in) an existing variable.
> 
> Often you get those two steps in one package, and that's why the difference
> isn't so clear.
> 
> Consider:
> 
> 
>  (let ((foo 12)) ; bind a variable to the symbol foo
>    ...
>    (... ; some sub-scope, e.g. another let
>         ; let's assume it does *not* bind foo
>      (setq foo 13) ; Now the foo is bound to the same variable,
>                    ; but that contains now 13
>    ))
> 
> Things are a bit confusing, because (let ((foo 12)) ...) binds foo *and*
> assigns 12. But you could just use (let (foo) ...) in its pure form
> 
> Cheers
> -- t

Jean-Christophe Helary
-----------------------------------------------
http://mac4translators.blogspot.com @brandelune

Re: local binding, too local...

[Stefan Monnier]

>       (let* ((bar '(baz quux))) 
>         (setf (car bar) 'xyzzy) 
>         (let ((plugh (cdr bar))) 
>           (message "%s" plugh)))) 
>
> Can also be written
>
>    (let (bar plugh) 
>     (setf bar '(baz quux))
>     (setf (car bar) 'xyzzy)
>     (setf plugh (cdr bar)))

Indeed, but you lose a lot of karma points for that,


        Stefan

Re: local binding, too local...

[Barry Fishman]

On 2018-12-08 11:41:10 -05, Stefan Monnier wrote:
>>       (let* ((bar '(baz quux))) 
>>         (setf (car bar) 'xyzzy) 
>>         (let ((plugh (cdr bar))) 
>>           (message "%s" plugh)))) 
>>
>> Can also be written
>>
>>    (let (bar plugh) 
>>     (setf bar '(baz quux))
>>     (setf (car bar) 'xyzzy)
>>     (setf plugh (cdr bar)))
>
> Indeed, but you lose a lot of karma points for that,

Haven't you already lost all your karma points by modifying a literal list no
matter how you do it. ;-)

--
Barry Fishman

Re: local binding, too local...

[tomas]

[-- Attachment #1: Type: text/plain, Size: 897 bytes --]

On Sat, Dec 08, 2018 at 11:45:32PM +0900, Jean-Christophe Helary wrote:
> Thank you Tomas.
> 
> So can you say that "binding" is like "creating" a variable ?

No (at least not in this Lisp context). It's more like associating
a name with a variable.

> While assigning is just putting a value in that variable ?

Kind of, yes. Reality is a bit more complex, though...

> I remember in my math classes, when we were using x and y, etc. we were binding x and y, right ? And then when we had values for x and y we were assigning values. Is that correct ?

In maths, binding means associating a value with a name, that's easy.
And there's no correspondence for assignment. You can substitute a
bound variable (say x is bound to 5) by for its value everywhere.

"Assigning 7 to x" wouldn't make much sense in maths, because it would
amount to assigning 7 to 5.

Cheers
-- tomás

[-- Attachment #2: Digital signature --]
[-- Type: application/pgp-signature, Size: 198 bytes --]

Re: local binding, too local...

[Jean-Christophe Helary]

> On Dec 9, 2018, at 6:59, <tomas@tuxteam.de> <tomas@tuxteam.de> wrote:
> 
> On Sat, Dec 08, 2018 at 11:45:32PM +0900, Jean-Christophe Helary wrote:
>> Thank you Tomas.
>> 
>> So can you say that "binding" is like "creating" a variable ?
> 
> No (at least not in this Lisp context). It's more like associating
> a name with a variable.

But there must be something that's created that did not exist before that "binding" right ?

>> While assigning is just putting a value in that variable ?
> 
> Kind of, yes. Reality is a bit more complex, though...
> 
>> I remember in my math classes, when we were using x and y, etc. we were binding x and y, right ? And then when we had values for x and y we were assigning values. Is that correct ?
> 
> In maths, binding means associating a value with a name, that's easy.
> And there's no correspondence for assignment. You can substitute a
> bound variable (say x is bound to 5) by for its value everywhere.
> 
> "Assigning 7 to x" wouldn't make much sense in maths, because it would
> amount to assigning 7 to 5.

Ok so the comparison with maths doesn't work, right ?

Jean-Christophe Helary
-----------------------------------------------
http://mac4translators.blogspot.com @brandelune

Re: local binding, too local...

[tomas]

[-- Attachment #1: Type: text/plain, Size: 1197 bytes --]

On Sun, Dec 09, 2018 at 11:41:19AM +0900, Jean-Christophe Helary wrote:
> 
> 
> > On Dec 9, 2018, at 6:59, <tomas@tuxteam.de> <tomas@tuxteam.de> wrote:
> > 
> > On Sat, Dec 08, 2018 at 11:45:32PM +0900, Jean-Christophe Helary wrote:
> >> Thank you Tomas.
> >> 
> >> So can you say that "binding" is like "creating" a variable ?
> > 
> > No (at least not in this Lisp context). It's more like associating
> > a name with a variable.
> 
> But there must be something that's created that did not exist before that "binding" right ?

The association :-)

Technically, there's some hash table in the background, where
the implementation can look up symbols and what's been "hung"
on them (besides a "variable binding" there are some other
possibilities,,,)

> > "Assigning 7 to x" wouldn't make much sense in maths, because it would
> > amount to assigning 7 to 5.
> 
> Ok so the comparison with maths doesn't work, right ?

I'd say that the "maths" view was an inspiration, so it always helps
to keep it around for comparison. But it's important to remember that
there are differences.

That doesn't mean that maths can't model assignment, though.

Cheers
-- tomás

[-- Attachment #2: Digital signature --]
[-- Type: application/pgp-signature, Size: 198 bytes --]

Re: local binding, too local...

[Jean-Christophe Helary]

> On Dec 9, 2018, at 17:45, <tomas@tuxteam.de> <tomas@tuxteam.de> wrote:
> 
> On Sun, Dec 09, 2018 at 11:41:19AM +0900, Jean-Christophe Helary wrote:
>> 
>> 
>>> On Dec 9, 2018, at 6:59, <tomas@tuxteam.de> <tomas@tuxteam.de> wrote:
>>> 
>>> On Sat, Dec 08, 2018 at 11:45:32PM +0900, Jean-Christophe Helary wrote:
>>>> Thank you Tomas.
>>>> 
>>>> So can you say that "binding" is like "creating" a variable ?
>>> 
>>> No (at least not in this Lisp context). It's more like associating
>>> a name with a variable.
>> 
>> But there must be something that's created that did not exist before that "binding" right ?
> 
> The association :-)

Ok, that's what I needed to know :)

> Technically, there's some hash table in the background, where
> the implementation can look up symbols and what's been "hung"
> on them (besides a "variable binding" there are some other
> possibilities,,,)

Thank you.

> 
>>> "Assigning 7 to x" wouldn't make much sense in maths, because it would
>>> amount to assigning 7 to 5.
>> 
>> Ok so the comparison with maths doesn't work, right ?
> 
> I'd say that the "maths" view was an inspiration, so it always helps
> to keep it around for comparison. But it's important to remember that
> there are differences.
> 
> That doesn't mean that maths can't model assignment, though.

That will be for another time :)


Jean-Christophe Helary
-----------------------------------------------
http://mac4translators.blogspot.com @brandelune