Re: Surprising behavior of eq?

[Zelphir Kaltstahl]

Sorry, I misclicked "send" when I wanted to further edit my e-mail ...

My Guile version is:

~~~~
(version)
$6 = "3.0.4"
~~~~

On 20.09.20 14:16, Zelphir Kaltstahl wrote:
>
> Hello Guile users,
>
> I just noticed something weird about eq?.
>
> My Guile version is:
>
>
> I get the different results, depending on whether I define some
> bindings in a let or using define:
>
> (In Emacs Geiser:)
>
> ~~~~
> (define x '(10 9))
> (define y '(10 9))
> (eq? x y)
> $2 = #f
>
> (let ([x '(10 9)]
>       [y '(10 9)])
>      (eq? x y))
> $3 = #t
> ~~~~
>
> Is this intentional or a bug?
>
> I first noticed something strange when writing the following code:
>
> ~~~~DEFINITION~~~~
> (define make-multiple-list-remover
>   (λ (equal-proc)
>     (λ (lst unwanted)
>       (let loop ([remaining-list lst])
>         (cond
>          [(null? remaining-list)
>           '()]
>          [(equal-proc (car remaining-list) unwanted)
>           (loop (cdr remaining-list))]
>          [else
>           (cons (car remaining-list)
>                 (loop (cdr remaining-list)))])))))
> ~~~~
>
> ~~~~TEST~~~~
> (let ([a '(9 10)]
>       [b '(9 10)])
>   (test-equal "make-multiple-list-remover-03"
>     `(1 2 (3) (4) ,a)
>     ((make-multiple-list-remover eq?)
>      `(a b (c) (d) ,a) b)))
> ~~~~
>
> I was wondering, why the test fails. I think (eq? ...) should not be
> able to see the equivalence of both lists a and b, just like when
> defined using (define ...).
>
> I can also run it in the REPL and see the difference:
>
> ~~~~
> (define a '(9 10))
> (define b '(9 10))
> ((make-multiple-list-remover eq?)
>  `(a b (c) (d) ,a) b)
> $4 = (a b (c) (d) (9 10))
>
> (let ([a '(9 10)]
>       [b '(9 10)])
>   ((make-multiple-list-remover eq?)
>    `(a b (c) (d) ,a) b))
> $5 = (a b (c) (d))
> ~~~~
>
> Somehow the bindings of let seem to be different from the bindings
> created using define. What about using define inside let?
>
> ~~~~
>
> ~~~~
> -- 
> repositories: https://notabug.org/ZelphirKaltstahl

Somehow the bindings of let seem to be different from the bindings
created using define. What about using define inside let?

~~~~
(let ([unrelated 'bla])
  (define a '(9 10))
  (define b '(9 10))
  ((make-multiple-list-remover eq?)
   `(a b (c) (d) ,a) b))
$7 = (a b (c) (d))
~~~~

So there the define usage also differs from when I use define on the top
level. Perhaps that is the difference? On which level the bindings are
defined?

Regards,
Zelphir

-- 
repositories: https://notabug.org/ZelphirKaltstahl