Hi,
On Tue 20 Oct 2009 18:47, Mark H Weaver <m...@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/
