Re: upcoming patches

[Andy Wingo <wingo@pobox.com>]

Hi,

On Tue 20 Oct 2009 18:47, Mark H Weaver <mhw@netris.org> writes:

> Andy wrote:
>>   2) Make sure Mark's patch is in
>
> Neil wrote:
>> Have I missed this?  I _think_ I'm still waiting for Mark's updated
>> patch...
>
> Sorry for being so slow on this.  I had a lot of free time with I
> first submitted the patch, but have been busier since then.

No prob, happens to all of us :)

> The biggest block is that I'm intimidated by the prospect of looking
> at every use of scm_is_{false,true,null} in the tree and deciding
> which of the new predicates should be used.

Why don't we just get the first version in with #define scm_is_false(x)
scm_is_false_and_not_nil(x), etc? Patches that do 1 thing only are best.

> I expect that the vast majority could be left alone without
> introducing new bugs, but I can't be sure without checking each one.

Sure, but we can help with that.

> Also, since writing the first patch, I've had some second thoughts
> about whether this approach to #nil is the correct one.  I'm primarily
> concerned with the problem of equality predicates, which from the lisp
> point of view should treat #nil as equal to both '() and #f.  How will
> this interact with collections (e.g. hash tables and alists, or even
> simple lists used as sets) which use lists as keys?  If lisp adds an
> element to such a collection, scheme won't be able to find it, and
> vice versa.  I see the potential for many subtle bugs to go unnoticed.

Well, there are many ways to think about this I guess. I'm of more of a
pragmatic than a practical bent; so it's clear to me is that whatever
goes in as a result of your patch will be pragmatically better than what
we have now.

What do you think about this:

  (eq? #f '()) => #f
  (eq? #f #nil) => #f
  (eq? '() #nil) => #f

  (eqv? #f '()) => #f
  (eqv? #f #nil) => #t
  (eqv? '() #nil) => #t

  (equal? #f '()) => #f
  (equal? #f #nil) => #t
  (equal? '() #nil) => #t

That handles delv, assoc, etc.

Hash is more difficult. Hashq of all are distinct; hashv and hash are
the same. But if (hash #f) == (hash #nil) and (hash #nil) == (hash '()),
then (hash '(a)) == (hash '(a . #f)), which would be bad -- and indeed
that's not possible.

So why don't we just say that (hash #nil) == (hash '()). It will be
documented that hash tables and lisp interaction are just this way.

> Although I'm sure the Emacs community would never agree, I'm tempted
> to suggest that the best solution is for Emacs to meet us half way

Only if we can show them some really awesome benefits would they do
this -- and even then I think it's a bad idea. There is 20 years of
elisp code out there that we can't presume to change.

> Apologies if these thoughts are half-baked.  Part of the problem is
> that I've not had enough time to fully evaluate these issues, and I
> feel paralyzed since I don't like any of the available options.

No prob! Thanks for mailing the list, I hadn't thought about the hash
issues before. What do you think about my dodgy "solutions"? :)

Cheers,

Andy
-- 
http://wingolog.org/