I think the ordering of submodules is unavoidable, but the documentation should make more clear that the order of `module*` declarations matters.
Meanwhile, the documentation for `module+` needs to clarify that it puts the generated `module*` at the end of the enclosing module, even if there's only one `module+` form for a module name. It should also say that the order of the generated `module*`s for multiple `module+`-based modules corresponds to the order of the initial `module+` for each name (which turns out to be an explicit choice, as opposed to an accident of the implementation). At Tue, 1 Jul 2014 10:16:06 +0200, Laurent wrote: > Hi, > > I'm using `(module+ plot)` to avoid loading the `plot` library when > requiring the enclosing module only. > > But it seems that `module+` is dependent on the order of the modules, > somewhat contrarily to `module*`. For example, this works: > #lang racket > > (define x 3) > > (module+ foo > (provide y) > (define y x)) > > (module+ test > (require (submod ".." foo)) > y) > > But this does not: > #lang racket > > (define x 3) > > (module+ test) ; *** ADDED > > (module+ foo > (provide y) > (define y x)) > > (module+ test > (require (submod ".." foo)) > y) > > But this works: > #lang racket > > (define x 3) > > (module+ test) > > (module* foo #f ; *** CHANGED > (provide y) > (define y x)) > > (module+ test > (require (submod ".." foo)) > y) > > And this works too: > #lang racket > > (define x 3) > > (module+ foo) ; *** ADDED > (module+ test) > > (module+ foo ; *** > (provide y) > (define y x)) > > (module+ test > (require (submod ".." foo)) > y) > > I want to use `module+` over `module*` for its concatenation capability, > and adding a `(module+ foo)` at the top of my file is no big deal, but, > since the docs do not talk about some order dependency of submodules > (AFAICT) and only say that `module+` is equivalent to `module*` with #f and > concatenation, I was wondering if this was the intended behavior. > > Actually, `module*` also seems to be dependent of the order, as the > following does not work: > #lang racket > > (define x 3) > > (module* test #f > (require (submod ".." foo)) > y) > > (module* foo #f > (provide y) > (define y x)) > > From this I infer that the modules declared by `module+` are collected in > order of their first appearance and declared at the end of the module in > this same order, therefore after all `module*`. Is this correct? > > And is it easy enough to have order independence for both `module+` and > `module*`, and would it be a good idea in general? > > Laurent > ____________________ > Racket Users list: > http://lists.racket-lang.org/users ____________________ Racket Users list: http://lists.racket-lang.org/users
