The mzlib/etc library re-exports the following
scheme/base and other libraries:
Lifts the exprs so that they are evaluated once at the “top
level” of the current context, and the result of the last
expr is used for every evaluation of the
begin-lifted form.
When this form is used as a run-time expression within a module, the
“top level” corresponds to the module’s top level, so that each
expr is evaluated once for each invocation of the
module. When it is used as a run-time expression outside of a module,
the “top level” corresponds to the true top level. When this form is
used in a define-syntax, letrec-syntax,
etc. binding, the “top level” corresponds to the beginning of the
binding’s right-hand side. Other forms may redefine “top level”
(using local-expand/capture-lifts) for the expressions that
they enclose.
Similar to
define-syntaxes, but instead of a single body
expression, a sequence of definitions follows the sequence of defined
identifiers. For each
identifier, the
defns should
include a definition for
id/proc. The value
for
id/proc is used as the (expansion-time)
value for
id.
The define-syntax-set form is useful for defining a set of
syntax transformers that share helper functions, though
begin-for-syntax now serves essentially the same purposes.
| (evcase key-expr (value-expr body-expr ...) ...+) |
| (evcase key-expr (value-expr body-expr ...) ... [else body-expr ...]) |
The
evcase form is similar to
case, except that
expressions are provided in each clause instead of a sequence of
data. After
key-expr is evaluated, each
value-expr
is evaluated until a value is found that is
eqv? to the key
value; when a matching value is found, the corresponding
body-exprs are evaluated and the value(s) for the last is the
result of the entire
evcase expression.
The else literal is recognized either as unbound (like in the
mzscheme language) or bound as else from
scheme/base.
Returns v.
| (let+ clause body-expr ...+) |
| |
| clause | | = | | (val target expr) | | | | | | | (rec target expr) | | | | | | | (vals (target ...) expr) | | | | | | | (recs (target expr) ...) | | | | | | | (_ expr ...) | | | | | | | | target | | = | | id | | | | | | | (values id ...) |
|
A binding construct that specifies scoping on a per-binding basis
instead of a per-expression basis. It helps eliminate rightward-drift
in programs. It looks similar to
let, except each clause has
an additional keyword tag before the binding variables.
Each clause has one of the following forms:
(val target expr) : Binds target
non-recursively to expr.
(rec target expr) : Binds target recursively to
expr.
(vals (target expr) ...) : The targets are
bound to the exprs. The environment of the exprs is
the environment active before this clause.
(recs (target expr) ...) : The targetss are
bound to the exprs. The environment of the exprs
includes all of the targetss.
(_ expr ...) : Evaluates the exprs without
binding any variables.
The clauses bind left-to-right. When a target is
(values id ...), multiple values returned by the
corresponding expression are bound to the multiple variables.
Examples: |
|
'(1 2) |
| > (let ([x 1]) | | (let+ ([val x 3] | | [val y x]) | | y)) |
|
3 |
| (loop-until start done? next f) → void? |
| start : any/c |
| done? : (any/c . -> . any) |
| next : (any/c . -> . any/c) |
| f : (any/c . -> . any) |
Repeatedly invokes the f procedure until the done?
procedure returns #t:
Supports optional (but not keyword) arguments like
lambda from
scheme/base.
| (recur id bindings body ...+) |
Equivalent to
(let id bindings body ...+).
| (rec id value-expr) |
| (rec (id arg-id ...) expr) |
| (rec (id arg-id ... . rest-id) expr) |
Equivalent, respectively, to
Expands to an expression that evaluates to the directory of the file
containing the source datum. If datum is not
supplied, then the entire (this-expression-source-directory)
expression is used as datum.
If datum has a source module, then the expansion attempts to
determine the module’s run-time location. This location is determined
by preserving the lexical context of datum in a syntax
object, extracting its source module path at run time, and then
resolving the module path.
Otherwise, datum’s source file is determined through source
location information associated with datum, if it is
present. As a last resort, current-load-relative-directory is
used if it is not #f, and current-directory is used
if all else fails.
A directory path derived from source location is always stored in
bytes in the expanded code, unless the file is within the result of
find-collects-dir, in which case the expansion records the
path relative to (find-collects-dir) and then reconstructs it
using (find-collects-dir) at run time.
Creates a new hash-table providing the quoted flags (if any) to
make-hash-table, and then mapping each key to the
corresponding values.