Re: relative load-file

[Rocky Bernstein <rocky@gnu.org>]

[-- Attachment #1: Type: text/plain, Size: 3107 bytes --]

On Sat, Nov 14, 2009 at 6:24 AM, Richard Stallman <rms@gnu.org> 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<http://github.com/rocky/emacs-load-relative>.
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.

[-- Attachment #2: Type: text/html, Size: 4087 bytes --]