Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://docs.racket-lang.org/reference/Namespaces.html below:

14.1 Namespaces

See Namespaces for basic information on the namespace model.

A new namespace is created with procedures like make-empty-namespace, and make-base-namespace, which return a first-class namespace value. A namespace is used by setting the current-namespace parameter value, or by providing the namespace to procedures such as eval and eval-syntax.

Returns #t if v is a namespace value, #f otherwise.

The new namespace is associated with a new root namespace, which has the same module registry as the returned namespace and has a base phase of 0. The new root namespace is the same as the returned namespace if both have base phase 0.

This form can be used only in a top-level context or in a module-context.

Returns #t if v is a namespace-anchor value, #f otherwise.

If the anchor is from a define-namespace-anchor form in a module context, then the source is the namespace in which the containing module is instantiated. If the anchor is from a define-namespace-anchor form in a top-level content, then the source is the namespace in which the anchor definition was evaluated.

Returns a namespace corresponding to the source of the anchor.

If the anchor is from a define-namespace-anchor form in a module context, then the result is a namespace for the module’s body in the anchor’s phase. The result is the same as a namespace obtained via module->namespace, and the module is similarly made available if it is not available already.

If the anchor is from a define-namespace-anchor form in a top-level content, then the result is the namespace in which the anchor definition was evaluated.

Similar to

restricted to symbols. The

of the resulting identifier corresponds to the top-level environment of the current namespace; the identifier has no source location or properties.

The lexical information of the identifier includes bindings (in the same phase level) for all syntactic forms that appear in fully expanded code (see Fully Expanded Programs), but using the name reported by the second element of identifier-binding for the binding; the lexical information may also include other bindings.

Returns a value for

in

, using

’s

. The returned value depends on

:

• If use-mapping? is true (the default), and if sym maps to a top-level variable or an imported variable (see Namespaces), then the result is the same as evaluating sym as an expression. If sym maps to syntax or imported syntax, then failure-thunk is called or the exn:fail:syntax exception is raised. If sym is mapped to an undefined variable or an uninitialized module variable, then failure-thunk is called or the exn:fail:contract:variable exception is raised.

• If use-mapping? is #f, the namespace’s syntax and import mappings are ignored. Instead, the value of the top-level variable named sym in namespace is returned. If the variable is undefined, then failure-thunk is called or the exn:fail:contract:variable exception is raised.

If failure-thunk is not #f, namespace-variable-value calls failure-thunk to produce the return value in place of raising an exn:fail:contract:variable or exn:fail:syntax exception.

Sets the value of

in the top-level environment of

in the

, defining

if it is not already defined.

If map? is supplied as true, then the namespace’s identifier mapping is also adjusted (see Namespaces) in the phase level corresponding to the base phase, so that sym maps to the variable.

If as-constant? is true, then the variable is made a constant (so future assignments are rejected) after v is installed as the value.

Changed in version 6.90.0.14 of package base: Added the as-constant? argument.

Removes the

variable, if any, in the top-level environment of

in its

. The namespace’s

mapping (see

) is unaffected.

Returns a list of all symbols that are mapped to variables, syntax, and imports in

for the

corresponding to the

’s

.

Performs the import corresponding to

in the top-level environment of

, like a top-level

. The

argument must be either a datum that corresponds to a quoted

for

, which includes module paths, or it can be a

.

Module paths in quoted-raw-require-spec are resolved with respect to current-load-relative-directory or current-directory (if the former is #f), even if the current namespace corresponds to a module body.

Changed in version 6.90.0.16 of package base: Added the namespace optional argument.

Like

for syntax exported from the module, but exported variables at the namespace’s

are treated differently: the export’s current value is copied to a top-level variable in

.

Changed in version 6.90.0.16 of package base: Added the namespace optional argument.

Like

, but for each exported variable at the

’s

, the export’s value is copied to a corresponding top-level variable that is made immutable. Despite setting the top-level variable, the corresponding identifier is bound as imported.

Changed in version 6.90.0.16 of package base: Added the namespace optional argument.

Changed in version 6.90.0.16 of package base: Added the namespace optional argument.

Attaches the instantiated module named by

in

(at its

) to the

of

.

In addition to modname, every module that it imports (directly or indirectly) is also recorded in the current namespace’s module registry, and instances at the same phase are also attached to dest-namespace (while visits at the module’s phase and instances at higher or lower phases are not attached, nor even made available for on-demand visits). The inspector of the module invocation in dest-namespace is the same as inspector of the invocation in src-namespace.

If modname is not a symbol, the current module name resolver is called to resolve the path, but no module is loaded; the resolved form of modname is used as the module name in dest-namespace.

If modname refers to a submodule or a module with submodules, unless the module was loaded from bytecode (i.e., a ".zo" file) independently from submodules within the same top-level module, then declarations for all submodules within the module’s top-level module are also attached to dest-namespace.

If modname does not refer to an instantiated module in src-namespace, or if the name of any module to be attached already has a different declaration or same-phase instance in dest-namespace, then the exn:fail:contract exception is raised.

If src-namespace and dest-namespace do not have the same base phase, then the exn:fail:contract exception is raised.

Unlike namespace-require, namespace-attach-module does not instantiate the module, but copies the module instance from the source namespace to the target namespace.

Examples:

Like

, but the module specified by

need only be declared (and not necessarily

d) in

, and the module is merely declared in

.

Changes the inspector for the instance of the module referenced by

in

’s

so that it is controlled by the current code inspector. The given

must currently control the invocation of the module in

’s

, otherwise the inspector is not changed. See also

.

Returns the

of the given namespace. This value is useful only for identification via

.

Calls

while holding a reentrant lock for the namespace’s

.

Namespace functions do not automatically use the registry lock, but it can be used via namespace-call-with-registry-lock among threads that load and instantiate modules to avoid internal race conditions. On-demand instantiation of available modules also takes the lock; see Module Expansion, Phases, and Visits.

Added in version 8.1.0.5 of package base.

Returns a namespace that corresponds to the body of an instantiated module in

’s

and in the

’s

, making the module

for on-demand

at

’s

. The returned namespace has the same

as

. Modifying a binding in the resulting namespace changes the binding seen in modules that require the namespace’s module.

Module paths in a top-level require expression are resolved with respect to the namespace’s module. New provide declarations are not allowed.

If the current code inspector does not control the invocation of the module in src-namespace’s module registry, the exn:fail:contract exception is raised; see also Code Inspectors.

Bindings in the result namespace cannot be modified if the compile-enforce-module-constants parameter was true when the module was declared, unless the module declaration itself included assignments to the binding via set!.

Changed in version 6.90.0.16 of package base: Added the src-namespace optional argument.

Changed in version 6.90.0.16 of package base: Added the namespace optional argument.

Returns #f if the module declaration for module-path-index defines sym and exports it unprotected, #t otherwise (which may mean that the symbol corresponds to an unexported definition, a protected export, or an identifier that is not defined at all within the module).

The module-path-index argument can be a symbol; see Compiled Modules and References for more information on module path indices.

Typically, the arguments to module-provide-protected? correspond to the first two elements of a list produced by identifier-binding.

Returns

if the variable represented by

will retain its current value (i.e.,

refers to a variable that cannot be further modified by

or

),

otherwise.

Returns an empty namespace that shares module declarations and instances with the namespace in which varref is instantiated, and with the same phase as varref.

If

refers to a

, then the result is a namespace for the module’s body in the referenced variable’s

; the result is the same as a namespace obtained via

, and the module is similarly made

if it is not available already.

If varref refers to a top-level variable, then the result is the namespace in which the referenced variable is defined.

If varref refers to a top-level variable, then the result is #f.

If varref refers to a top-level variable, then the result is #f.

If

refers to a

, the result is a path or symbol naming the module’s source (which is typically, but not always, the same as in the

). If the relevant module is a

, the result corresponds to the enclosing top-level module’s source.

If varref refers to a top-level variable, then the result is #f.

Returns the

of the variable referenced by

.

Returns the

in which the module is instantiated for the variable referenced by

, or

if the variable for

is not within a module.

For a variable with a module, the result is less than the result of (variable-reference->phase varref) by n when the variable is bound at phase level n within the module.

Returns

if the module of the variable reference itself (not necessarily a referenced variable) is compiled in unsafe mode,

otherwise.

can be enabled through the

interface or enable for a module with

.

The variable-reference-from-unsafe? procedure is intended for use as

(variable-reference-from-unsafe? (#%variable-reference))

which the compiler can optimize to a literal #t or #f (since the enclosing module is being compiled in unsafe mode or not).

Added in version 6.12.0.4 of package base.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4