Re: Versioning scheme-only modules.

[Neil Jerram]

>>>>> "Rob" == Rob Browning <address@hidden> writes:

    Rob> If possible, I'd like to try to decide upon an plan for our
    Rob> initial versioned module system.  [...]

First off, I'd like to say thanks for looking at this problem.
Although I have next to no experience to contribute on it, I do think
it's important, and I appreciate your persistence.

    Rob> My current thoughts say that for scheme-only modules we
    Rob> probably need:

    Rob>   1) some scheme side interface for asking for a versioned
    Rob> module:

    Rob>        (use-modules (foo bar 1)) (use-modules (foo bar
    Rob> #:interface 1))

    Rob>      or whatever.

Sounds good, although it's a pity that `#:interface' clashes with the
module system's different usage of the word `interface'.

    Rob>      (I propose we just borrow the libtool versioning
    Rob> conventions i.e. having CURRENT, REVISION, and AGE.  This
    Rob> approach is already well documented and common, and I can't
    Rob> see that we need anything more than it provides.)

Right.  (I was about to say that the libtool convention doesn't cater
for the scenario where the interface hasn't changed, but you happen to
know that some behavioural aspect of revision 3 differs from revision
2.  But of course that would really be an interface change, if it was
detectable at all.)

    Rob>   2) some standard for how the versioned scm files are
    Rob> installed so that they can be found (I know these examples
    Rob> are ugly -- better suggestions are certainly welcome :>):

    Rob>        <path>/foo/bar.scm.1.4.2 ;; the most like shared libs.
    Rob> <path>/foo/bar.1.4.2.scm <path>/foo/bar/1.4.2.scm

Definitely <path>/foo/bar.scm.1.4.2 IMO.  The others conflict with
validly unversioned modules (foo bar.1.4.2) and (foo bar 1.4.2).

    Rob>   4) hopefully some way to make it easier to generate the
    Rob> right files at build/install time.  i.e. how does a module
    Rob> .scm file advertize its INTERFACE, AGE, etc., and how does
    Rob> that translate into the resulting file name at build/install
    Rob> time?  Should the Makefile.am drive this process, or should
    Rob> the .scm file(s) themselves?

    Rob>      The simplest thing would probably be for the
    Rob> Makefile.am, as for shared libs, to use the version info to
    Rob> decide about install file names, etc., but then the .scm
    Rob> file(s) aren't fully self-describing, or the've got
    Rob> duplicated information.

I think we should follow the shared libs; i.e. drive this from
Makefile.am.

Installed files will be partly self-describing, from the file names
under which they're installed; I think this will be enough.

        Neil