On Sat, Nov 14, 2009 at 6:24 AM, Richard Stallman
<address@hidden> wrote:
The basic idea of `require' is that you specify a feature which gets
found through a search of all libraries. The idea is that these are
general features which anything might want to use.
Require has two parts which are distinct. One part has the searching for a file in it. The other part is the conditional load depending on whether or not a feature has already been loaded
You want something different:
That is, one wants to
load an Emacs Lisp file relative the file that issues the load which is
often in the same directory or a nearby directory.
It seems to me that this is useful only for loading other parts of one
single multi-file program.
No. A large modular program can be composed of other smaller modular programs. In theory, one can package each file or subsets of files as their own package, but often those smaller modules may be custom enough that it doesn't make sense to do so. Or at least not initially.
However when developing or working on the program, one wants may want to work with each of the subparts independently.
Here's an example that no doubt you are familiar with: a compile has a parser, code generator and code optimizer. In a well-written modular compiler one may want to work on and test the parser as an independent unit even though I'm not sure you would want to package the front-end for a specific language independently.
So what require-relative and load-relative allow one to do is create these little independent units without the overhead of using a more elaborate packaging systems. require/provide in fact does this too. However it pulls in file searching which is not desired here. Instead, what we want to do in a program built of custom modules but is just change how the file searching is managed.
The second benefit of this is that we can develop out of the source tree (that is without having to "install" the submodules) and have another version or many versions "installed" at the same time. Starting with a member of each version stays within that version of the code.
If you have a program which is in multiple files, you can write a
function similar to `require' which searches for files in any way you
like, and then you can use it. The function can be in your program;
it does not need to be built-in. It can load the chosen file using
`load'.
The files should each use `provide' in the usual way, and your
function should use the variable `features' to see if the desired
feature has already been loaded. The only difference would be in
choosing which file to load.
That's in fact what I have done. The only "primitive" needed is Ruby's __FILE__ which is the same thing as the C preprocessor __FILE__.
$# and load-file-name are close; better is (car-safe current-load-list). How these differ, and where __FILE__ is better, is that a macro substitution of the file name is done at compile time inside the code the if compiled, or at eval time if not.