"defmacro" and "local variables" and "let" and "nconc" strange behaviour...

"defmacro" and "local variables" and "let" and "nconc" strange behaviour...

[Oleksandr Gavenko]

I wrote simple macro:

  (defmacro my-filter (pred list)
    "Construct list with elements from LIST which satisfy PRED."
    (let ( (r (make-symbol "r_")) )
      `(let ( (,r '(nil)) )
         (mapc (lambda (item)
                 (when (,pred item)
                   (nconc ,r (cons item nil))))
               ,list)
         (cdr ,r))))

When I evaluate several times:

  (my-filter (lambda (x) x) '(1 nil "a"))

I get sequentially:

  (1 "a")
  (1 "a" 1 "a")
  (1 "a" 1 "a" 1 "a")
  (1 "a" 1 "a" 1 "a" 1 "a")

When I eval:

  (pp (macroexpand '(my-filter (lambda (x) x) '(1 nil "a"))))

I get:

  (let
      ((r_
        '(nil 1 "a" 1 "a" 1 "a" 1 "a" 1 "a" 1 "a" 1 "a" 1 "a")))
    (mapc
     (lambda
       (item)
       (when
           ((lambda
              (x)
              x)
            item)
         (nconc r_
                (cons item nil))))
     '(1 nil "a"))
    (cdr r_))

Why instead of '(nil) I get something else?

-- 
Best regards!

Re: "defmacro" and "local variables" and "let" and "nconc" strange behaviour...

[Oleksandr Gavenko]

On 2013-01-13, Oleksandr Gavenko wrote:

> I wrote simple macro:
>
>   (defmacro my-filter (pred list)
>     "Construct list with elements from LIST which satisfy PRED."
>     (let ( (r (make-symbol "r_")) )
>       `(let ( (,r '(nil)) )
>          (mapc (lambda (item)
>                  (when (,pred item)
>                    (nconc ,r (cons item nil))))
>                ,list)
>          (cdr ,r))))
>
> When I evaluate several times:
>
>   (my-filter (lambda (x) x) '(1 nil "a"))
>
> I get sequentially:
>
>   (1 "a")
>   (1 "a" 1 "a")
>   (1 "a" 1 "a" 1 "a")
>   (1 "a" 1 "a" 1 "a" 1 "a")
>
> When I eval:
>
>   (pp (macroexpand '(my-filter (lambda (x) x) '(1 nil "a"))))
>
> I get:
>
>   (let
>       ((r_
>         '(nil 1 "a" 1 "a" 1 "a" 1 "a" 1 "a" 1 "a" 1 "a" 1 "a")))
>     (mapc
>      (lambda
>        (item)
>        (when
>            ((lambda
>               (x)
>               x)
>             item)
>          (nconc r_
>                 (cons item nil))))
>      '(1 nil "a"))
>     (cdr r_))
>
> Why instead of '(nil) I get something else?

I found fix by changing '(nil) to (list nil). Please explain why first variant
fail?

-- 
Best regards!

Re: "defmacro" and "local variables" and "let" and "nconc" strange behaviour...

[Barry Margolin]

In article <mailman.17290.1358086558.855.help-gnu-emacs@gnu.org>,
 Oleksandr Gavenko <gavenkoa@gmail.com> wrote:

> I wrote simple macro:
> 
>   (defmacro my-filter (pred list)
>     "Construct list with elements from LIST which satisfy PRED."
>     (let ( (r (make-symbol "r_")) )
>       `(let ( (,r '(nil)) )
>          (mapc (lambda (item)
>                  (when (,pred item)
>                    (nconc ,r (cons item nil))))
>                ,list)
>          (cdr ,r))))
> 
> When I evaluate several times:
> 
>   (my-filter (lambda (x) x) '(1 nil "a"))
> 
> I get sequentially:
> 
>   (1 "a")
>   (1 "a" 1 "a")
>   (1 "a" 1 "a" 1 "a")
>   (1 "a" 1 "a" 1 "a" 1 "a")
> 
> When I eval:
> 
>   (pp (macroexpand '(my-filter (lambda (x) x) '(1 nil "a"))))
> 
> I get:
> 
>   (let
>       ((r_
>         '(nil 1 "a" 1 "a" 1 "a" 1 "a" 1 "a" 1 "a" 1 "a" 1 "a")))
>     (mapc
>      (lambda
>        (item)
>        (when
>            ((lambda
>               (x)
>               x)
>             item)
>          (nconc r_
>                 (cons item nil))))
>      '(1 nil "a"))
>     (cdr r_))
> 
> Why instead of '(nil) I get something else?

Because nconc is destructively modifying its own source code.

-- 
Barry Margolin, barmar@alum.mit.edu
Arlington, MA
*** PLEASE post questions in newsgroups, not directly to me ***

Re: "defmacro" and "local variables" and "let" and "nconc" strange behaviour...

[Oleksandr Gavenko]

On 2013-01-13, Barry Margolin wrote:

> In article <mailman.17290.1358086558.855.help-gnu-emacs@gnu.org>,
>  Oleksandr Gavenko <gavenkoa@gmail.com> wrote:
>
>> I wrote simple macro:
>> 
>>   (defmacro my-filter (pred list)
>>     "Construct list with elements from LIST which satisfy PRED."
>>     (let ( (r (make-symbol "r_")) )
>>       `(let ( (,r '(nil)) )
>>          (mapc (lambda (item)
>>                  (when (,pred item)
>>                    (nconc ,r (cons item nil))))
>>                ,list)
>>          (cdr ,r))))
>> [...]
>> Why instead of '(nil) I get something else?
>
> Because nconc is destructively modifying its own source code.

I know that nconc destructive. But how this effect '(nil) in defmacro inside
`(...)?

-- 
Best regards!

Re: "defmacro" and "local variables" and "let" and "nconc" strange behaviour...

[Le Wang]

On Sun, Jan 13, 2013 at 11:00 PM, Oleksandr Gavenko <gavenkoa@gmail.com> wrote:
> On 2013-01-13, Barry Margolin wrote:
>
>> In article <mailman.17290.1358086558.855.help-gnu-emacs@gnu.org>,
>>  Oleksandr Gavenko <gavenkoa@gmail.com> wrote:
>>
>>> I wrote simple macro:
>>>
>>>   (defmacro my-filter (pred list)
>>>     "Construct list with elements from LIST which satisfy PRED."
>>>     (let ( (r (make-symbol "r_")) )
>>>       `(let ( (,r '(nil)) )
>>>          (mapc (lambda (item)
>>>                  (when (,pred item)
>>>                    (nconc ,r (cons item nil))))
>>>                ,list)
>>>          (cdr ,r))))
>>> [...]
>>> Why instead of '(nil) I get something else?
>>
>> Because nconc is destructively modifying its own source code.
>
> I know that nconc destructive. But how this effect '(nil) in defmacro inside
> `(...)?

In lisp, code is data.  See my enlightenment process:
http://comments.gmane.org/gmane.emacs.bugs/50783

-- 
Le

Re: "defmacro" and "local variables" and "let" and "nconc" strange behaviour...

[Oleksandr Gavenko]

On 2013-01-13, Le Wang wrote:

> On Sun, Jan 13, 2013 at 11:00 PM, Oleksandr Gavenko <gavenkoa@gmail.com> wrote:
>> On 2013-01-13, Barry Margolin wrote:
>>
>>> In article <mailman.17290.1358086558.855.help-gnu-emacs@gnu.org>,
>>>  Oleksandr Gavenko <gavenkoa@gmail.com> wrote:
>>>
>>>> I wrote simple macro:
>>>>
>>>>   (defmacro my-filter (pred list)
>>>>     "Construct list with elements from LIST which satisfy PRED."
>>>>     (let ( (r (make-symbol "r_")) )
>>>>       `(let ( (,r '(nil)) )
>>>>          (mapc (lambda (item)
>>>>                  (when (,pred item)
>>>>                    (nconc ,r (cons item nil))))
>>>>                ,list)
>>>>          (cdr ,r))))
>>>> [...]
>>>> Why instead of '(nil) I get something else?
>>>
>>> Because nconc is destructively modifying its own source code.
>>
>> I know that nconc destructive. But how this effect '(nil) in defmacro inside
>> `(...)?
>
> In lisp, code is data.  See my enlightenment process:
> http://comments.gmane.org/gmane.emacs.bugs/50783

I follow you link and found different explanation from Drew Adams:

> Note that different Lisps (and different implementations of the same Lisp) can
> treat a sexp such as '(a b) differently - they might or might not create a new
> list each time it is read or eval'd.

> To be sure to get what you expect in situations like this, do not use '(...).
> Use `cons' or `list' or equivalent backquote syntax.  Do not expect '(...) to
> create new list structure each time it is read/eval'd.

That's why my code fail with '(nil)...

-- 
Best regards!

Re: "defmacro" and "local variables" and "let" and "nconc" strange behaviour...

[jack-mac]

Le dimanche 13 janvier 2013 15:18:46 UTC+1, Oleksandr Gavenko a écrit :
> On 2013-01-13, Oleksandr Gavenko wrote:
> 
> 
> 
> > I wrote simple macro:
> 
> >
> 
> >   (defmacro my-filter (pred list)
> 
> >     "Construct list with elements from LIST which satisfy PRED."
> 
> >     (let ( (r (make-symbol "r_")) )
> 
> >       `(let ( (,r '(nil)) )
> 
> >          (mapc (lambda (item)
> 
> >                  (when (,pred item)
> 
> >                    (nconc ,r (cons item nil))))
> 
> >                ,list)
> 
> >          (cdr ,r))))
> 
> >
> 
> > When I evaluate several times:
> 
> >
> 
> >   (my-filter (lambda (x) x) '(1 nil "a"))
> 
> >
> 
> > I get sequentially:
> 
> >
> 
> >   (1 "a")
> 
> >   (1 "a" 1 "a")
> 
> >   (1 "a" 1 "a" 1 "a")
> 
> >   (1 "a" 1 "a" 1 "a" 1 "a")
> 
> >
> 
> > When I eval:
> 
> >
> 
> >   (pp (macroexpand '(my-filter (lambda (x) x) '(1 nil "a"))))
> 
> >
> 
> > I get:
> 
> >
> 
> >   (let
> 
> >       ((r_
> 
> >         '(nil 1 "a" 1 "a" 1 "a" 1 "a" 1 "a" 1 "a" 1 "a" 1 "a")))
> 
> >     (mapc
> 
> >      (lambda
> 
> >        (item)
> 
> >        (when
> 
> >            ((lambda
> 
> >               (x)
> 
> >               x)
> 
> >             item)
> 
> >          (nconc r_
> 
> >                 (cons item nil))))
> 
> >      '(1 nil "a"))
> 
> >     (cdr r_))
> 
> >
> 
> > Why instead of '(nil) I get something else?
> 
> 
> 
> I found fix by changing '(nil) to (list nil). Please explain why first variant
> 
> fail?
> 
> 
> 
> -- 
> 
> Best regards!

To understand it, just try:
(defun foo (x)
  (let ((l '(0)))
    (nconc l (list x))))
(foo 1)
(foo 2)
This looks like a closure!