Next: Debugging, Previous: Data structures, Up: The Kawa Scheme language [Contents][Index]
This procedure returns a specifier for the environment that
results by starting with an empty environment and then
importing each list, considered as an import-set, into it.
The bindings of the environment represented by the specifier
are immutable, as is the environment itself.
See the eval function for examples.
This procedure returns an environment that contains no variable bindings, but contains (syntactic) bindings for all the syntactic keywords.
The effect of assigning to a variable in this environment (such
as let) is undefined.
The version must be an exact non-negative inetger corresponding to a version of one of the Revisedversion Reports on Scheme. The procedure returns an environment that contains exactly the set of bindings specified in the corresponding report.
This implementation supports version that is 4 or 5.
The effect of assigning to a variable in this environment (such
as car) is undefined.
This procedure return an environment that contains implementation-defined bindings, as well as top-level user bindings.
Return true #t if there is a binding for symbol
in environment; otherwise returns #f.
Call proc for each key in the environment,
which may be any argument to eval, such as
(interaction-environment) or a call to
the environment procedure.
The proc is called with two arguments:
The binding’s key, and an accumulator value.
The init is the initial accumulator value;
the result returned by proc is used for subsequent accumulator values.
The value returned by environment-fold is the final
acumulator value.
A key is normally a symbol,
but can also be a KeyPair object (a pair of a symbol and a
property symbol used to implement Common Lisp-style property lists).
(environment-fold (environment '(scheme write)) cons '()) ⇒ (display write-shared write write-simple)
To get all the predefined bindings use (environment '(kawa base)).
Evaluate the init expressions. Then modify the dynamic bindings for the variables to the values of the init expressions, and evaluate the body expressions. Return the result of the last expression in body. Before returning, restore the original bindings. The temporary bindings are only visible in the current thread, and its descendent threads.
If node is specified, returns the base-URI property
of the node. If the node does not have the base-URI
property, returns #f.
(The XQuery version returns the empty sequence in that case.)
In the zero-argument case, returns the "base URI" of the current context.
By default the base URI is the current working directory (as a URL).
While a source file is loaded, the base URI is temporarily
set to the URL of the document.
This procedure evaluates expression in the environment indicated
by environment.
The default for environment is the result
of (interaction-environment).
(eval ’(* 7 3) (environment '(scheme base)))
⇒ 21
(let ((f (eval '(lambda (f x) (f x x))
(null-environment 5))))
(f + 10))
⇒ 20
(eval '(define foo 32) (environment '(scheme base)))
⇒ error is signaled
The path can be an (absolute) URL or a filename
of a source file, which is read and evaluated line-by-line.
The path can also be a fully-qualified class name.
(Mostly acts like the -f command-line option,
but with different error handling.)
Since load is a run-time function it doesn’t know
about the enclosing lexical environment, and the latter
can’t know about definitions introduced by load.
For those reasons it is highly recommended that you use instead use
require or include.
Evaluation is done in the specified environment,
which defauls to result of (interaction-environment).
The load-relative procedure is like load,
except that path is a
URI that is relative to the context’s current base URI.
Next: Debugging, Previous: Data structures, Up: The Kawa Scheme language [Contents][Index]