When a scheme module can be executed? When a module declaration is evaluated, the module's body is syntax-expanded and complied, but not executed. The body is executed only when the module is explicitly invoked, via a "require" or "require-for-syntax" expression at the top level, or a call to "dynamic-require".
Here, in actual fact, a scheme interpretor make a module according to the text entering by you at this phrase. When you "require" a module, the scheme interpretor just import the actual content (because of macro) into another module or top-level environment.
When a module is invoked, its body definitions and expressions are evaluated. First, however, the definitions and expressions are evaluated for each module imported (via require) by the invoked module. The import-initialization rule applies up the chain of modules, so that every module used (directly or indirectly) by the invoked module is executed before any module that uses its exports. A module can only import from previously declared modules, so the module-import relationship is acyclic.
Every module is executed at most once in reponse to an invocation, regardless of the number of times that it is imported
into other modules.
Note: The template of an exported macro may refer to an identifier definded in the module or imported into the module;
uses of the macro in other modules expand to references of the identifier defined to imported at the macro-definition site,
as opposed to the use site. Uses of a macro in a module must not expand to a "set!" assignment of an identifier from
any other module, including the module that defines the macro.
(module a mzscheme
(provide xm)
(define y 2)
(define-syntax xm ;a macro that expands to y
(syntax-rules ()
[(xm) y])))
(module b mzscheme
(require a)
(printf "~a~n" (xm)))
(require b) ;=> prints2
If a module is invoked before it is re-declared, each re-declaration of the module is immediately invoked.
The immediate invocation is necessary to keep the module-specific namespace consistent with the module
declaration.
When a modulere-declaration implies invocation, the invocation can fail at the definition of a binding
that was constant in the original module (where any definition without a "set!" within the module counts as
a constant definition); preventing re-definition protects potential optimizations (for the original
declaration) that rely on constant bindings.