[racket] Evaluating Racket source files from within another Racket source file

Thank you for the explanation. As a new Racket user, in general I find the
docs thorough and well done. (I have HTDP and SICP nearby as well.) Coming
to Racket from Python, the differences in the module system have been
slowest to take hold (exacerbated by the fact that one cannot temporarily
kludge a way around one's ignorance, as one can in other areas of the
language). The rest has been smooth so far.



On Sun, Apr 28, 2013 at 3:01 PM, Matthew Flatt <mflatt at cs.utah.edu> wrote:

> At Sun, 28 Apr 2013 08:28:46 -0700, Matthew Butterick wrote:
> > >
> > > The syntax of `enter!' is supposed to be like `require', where the
> > > module name is not quoted
> >
> >
> > OK, I see what you're saying. And yes, the enter! / require connection is
> > noted in the docs.
> >
> > As a reader of docs, what trips me up here is that the docs for enter!
> and
> > require both refer to a module-path, but they will not necessarily take
> as
> > input something that returns #t for module-path?, for instance:
> >
> > (require "filename.rkt") ; works
> >
> > (define name "filename.rkt")
> > (module-path? name) ; returns #t
> > (require name) ; doesn't work
> >
> > However, dynamic-require works differently:
> >
> > (define name "filename.rkt")
> > (module-path? name) ; returns #t
> > (dynamic-require name 'foo) ;works
> >
> > I notice that dynamic-require uses the module-path? contract, and enter!
> > and require apparently do not. So OK, I guess that's why they can be more
> > restrictive. But then when I look up the meaning of module-path?, it
> says:
> >
> > Returns #t if v corresponds to a datum that *matches the grammar for
> > module-path for require*, #f otherwise.
> >
> >
> > That is, module-path? seems to be defined in terms of what require will
> > accept, but in practice module-path? accepts more than require will.
> Which,
> > if true, is strange.
>
> I think you're getting tripped up by the difference between syntax and
> values, and also by the way that ' is used in forming module paths.
>
> As Ian says, `enter!' is a syntactic form, and `enter!' is documented
> as having the grammar
>
>   (enter! module-path)
>
> The `module-path' here is a syntactic element, and it is defined as a
> non-terminal in the definition of `require' (which is why the
> documentation of `enter!' refers to `require').
>
>
> In typical Lispy style, however, we make a connection between a
> syntactic module path and a "module-path value": if you take a
> syntactic module path and put a quote on the front, you get an
> expression whose value is a module-path value --- a value for which
> `module-path?' returns #t. In other words, we overload the term "module
> path" with different (but related) meanings in syntax and value
> contexts.
>
>
> Note that if the grammar of `enter!' were
>
>  (enter! expr)
>
>        expr : module-path?
>
> then it would mean that you can put any expression after `enter!', and
> the expression's value would be checked at run time to be a module
> path.
>
> So, the distinction is carefully and precisely packed in to the
> documentation's notation, and programmers don't usually notice this
> sort of overloading, because it usually works out in an obvious way.
>
> Unfortunately, the distinction between syntactic module paths and
> module-path values can be especially confusing, I think for these
> reasons:
>
>  * Many module paths are just strings, and strings are self-quoting,
>    so the syntactic module path and an expression that produces the
>    corresponding module path are the same.
>
>  * The form
>       'x
>    is a syntactic module path, and it means "a module with the symbolic
>    resolved name `x'".
>
>    At the same time, the form
>       x
>    is a syntactic module path that means "the main module from the `x'
>    collection".
>
>    A good case can be made that abusing ' for the former module path
>    was a bad idea (but it sure is convenient).
>
>  * The *expression*
>      'x
>    produces a value that, when treated as a module path, refers to the
>    main module of the `x' collection.
>
>    To create a value that refers to the module with the symbolic
>    resolved name `x', you'd have to write
>      ''x
>
>    That's all consistent --- just put a ' on the front of each example
>    from the preceding bullet --- but because ' is used in two different
>    ways, it can be confusing.
>
>
> Finally, I think it's fair to say that the `module-path?' documentation
> "a datum that matches the grammar for module-path for require" is too
> tightly packed, and we'll improve it.
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.racket-lang.org/users/archive/attachments/20130428/59e8e90e/attachment-0001.html>