[racket] Order dependency in submodules

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