>> It does! Apparently, require in clisp is both case sensitive
>> and unwilling to translate uppercase symbols to lowercase filenames.
>> Reading the CLHS for require and provide, this is a valid
>> interpretation of the standard, which says it compares string designators
>> with string=.
> Frankly, I don't see how one can interpret the standard in any other way.
Well, out a score of implementations that I tried out there,
CLISP seems to be only implementation to stick to the letter of the standard
rather than to its spirit and to common practice.
>> However, this is also very much unlike common practice, whereby
>> uppercase strings, often designated by symbols, are used for module
>> names, and local case, always lowercase these days, is used for
> yeah, that's the "implementation-dependent" part which features
> prominently there.
Then again, it would be nice to acknowledge common practice.
Back when LISP was initially developed, upper case was the standard,
if only because not all computers had lower case.
Symbols, filenames, etc. - everything often was in uppercase.
Nowadays, the ubiquitous Unix systems are case-sensitive,
and conventions are to use lowercase by default,
even on the last remaining widely available non-Unix system.
It only makes sense to respect both conventions, and keep using
the uppercase symbols on the Lisp side (note how "LISP" seems antiquated),
and lowercase filenames on the filesystem side.
>> abcl, allegro, ccl, ecl, sbcl, xcl, all accept "asdf" and "ASDF",
>> and "ASDF" (uppercase) is then pushed onto *modules* which when it
>> contains strings contains only uppercase strings.
>> All those that had strings in *modules* used uppercase strings.
>> Interestingly, ccl alone among them pushes both "ASDF" and "asdf"
>> onto *modules* if require was called with "asdf".
>> scl also behaves the same way (though the latest release doesn't sport
>> ASDF yet), and lispworks seems to do the same (with same reserve).
>> As far as I can remember, cmucl (which does provide asdf)
>> also behaves similarly.
> I see no benefit in this behavior.
> It gratuitously works around the "string=" part of the spec to produce
> case-folding behavior which is not justified by modern filesystems.
> Let us not confuse *features* and *modules*.
> These are different variables with different content.
I'm not confusing anything. I'm stating what practice is in every single
other Lisp implementation, and why it makes sense both historically and
logically. Once again, the standard totally allows the mapping of
any case of symbol names to lower case physical pathnames, and it's
what everybody expects in every other implementation.
>> In the asdf documentation, I recommend (require :asdf)
>> as the preferred way to load ASDF.
> I suggest (require "asdf") instead.
> It makes more sense and should be more portable.
And it would also require everyone to change his documentation everywhere.
I'm not the only one out there to have documented (require :asdf), which
works on every other platform.
>> Could you make both "ASDF" and "asdf" work on CLISP too?
> How do you propose I handle qwer.lisp, Qwer.lisp, QWER.lisp in
> *load-path* and (require :qwer), (require "Qwer") in user code?
> I don't want to encourage case folding.
As you said above, modules are not to be confused with either
features or filenames. I suggest that module to filename conversion
should be case-folding, and that your implementation should not
provide confusingly named modules the name of which differs only by case.
> BTW, check out the "-modern" clisp option.
Even better! Now whether (require :asdf) works or not depends on the
-modern or not mode of the Lisp, and to have code work in both modes,
I can't use symbols at all!
If you the module to filename conversion were case-folded, symbols
would work in both modes.
—♯ƒ • François-René ÐVB Rideau •Reflection&Cybernethics• http://fare.tunes.org
Obscenity is the crutch of inarticulate motherfuckers.