2174 lines
80 KiB
Text
2174 lines
80 KiB
Text
|
% Copyright 2005-2017 Cisco Systems, Inc.
|
||
|
|
%
|
||
|
|
% Licensed under the Apache License, Version 2.0 (the "License");
|
||
|
|
% you may not use this file except in compliance with the License.
|
||
|
|
% You may obtain a copy of the License at
|
||
|
|
%
|
||
|
|
% http://www.apache.org/licenses/LICENSE-2.0
|
||
|
|
%
|
||
|
|
% Unless required by applicable law or agreed to in writing, software
|
||
|
|
% distributed under the License is distributed on an "AS IS" BASIS,
|
||
|
|
% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
|
|
% See the License for the specific language governing permissions and
|
||
|
|
% limitations under the License.
|
||
|
|
\chapter{Syntactic Extension and Modules\label{CHPTSYNTAX}}
|
||
|
|
|
||
|
|
This chapter describes the {\ChezScheme} extensions to the
|
||
|
|
syntax-case syntactic abstraction mechanism now standardized in
|
||
|
|
the Revised$^6$ Report.
|
||
|
|
These extensions include
|
||
|
|
the module system (Section~\ref{SECTSYNTAXMODULES}),
|
||
|
|
meta definitions (Section~\ref{SECTSYNTAXMETA}),
|
||
|
|
conditional expansion (Section~\ref{SECTSYNTAXMETACOND})
|
||
|
|
\scheme{syntax-rules} fenders,
|
||
|
|
\scheme{fluid-let-syntax},
|
||
|
|
and \scheme{include}.
|
||
|
|
|
||
|
|
|
||
|
|
\section{Fluid Keyword Bindings\label{SECTSYNTAXDEFINITIONS}}
|
||
|
|
|
||
|
|
Keyword bindings established via the Revised$^6$ Report
|
||
|
|
\scheme{define-syntax}, \scheme{let-syntax}, or \scheme{letrec-syntax}
|
||
|
|
forms may be rebound temporarily with \scheme{fluid-let-syntax}.
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{fluid-let-syntax}{\categorysyntax}{(fluid-let-syntax ((\var{keyword} \var{expr}) \dots) \var{form_1} \var{form_2} \dots)}
|
||
|
|
\returns see explanation
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
\noindent
|
||
|
|
Each \var{expr} must evaluate to a transformer.
|
||
|
|
\scheme{fluid-let-syntax} is similar to the standard \scheme{let-syntax}, except
|
||
|
|
that instead of introducing new bindings for the keywords
|
||
|
|
\scheme{\var{keyword} \dots},
|
||
|
|
\scheme{fluid-let-syntax} temporarily alters the existing bindings
|
||
|
|
for the keywords during the expansion of its body.
|
||
|
|
That is, during the expansion of \scheme{\var{form_1} \var{form_2} \dots},
|
||
|
|
the visible lexical (or top-level) binding
|
||
|
|
for each \scheme{keyword} is temporarily replaced by a new association
|
||
|
|
between the keyword and the corresponding transformer.
|
||
|
|
This affects any references to the keyword that resolve
|
||
|
|
to the same lexical (or top-level) binding whether the references occur
|
||
|
|
in the text of the body or are introduced during its expansion.
|
||
|
|
In contrast, \scheme{let-syntax} captures only those references that
|
||
|
|
occur within the text of its body.
|
||
|
|
|
||
|
|
The following example shows how \scheme{fluid-let-syntax}
|
||
|
|
differs from \scheme{let-syntax}.
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(let ([f (lambda (x) (+ x 1))])
|
||
|
|
(let-syntax ([g (syntax-rules ()
|
||
|
|
[(_ x) (f x)])])
|
||
|
|
(let-syntax ([f (syntax-rules ()
|
||
|
|
[(_ x) x])])
|
||
|
|
(g 1)))) ;=> 2
|
||
|
|
|
||
|
|
(let ([f (lambda (x) (+ x 1))])
|
||
|
|
(let-syntax ([g (syntax-rules ()
|
||
|
|
[(_ x) (f x)])])
|
||
|
|
(fluid-let-syntax ([f (syntax-rules ()
|
||
|
|
[(_ x) x])])
|
||
|
|
(g 1)))) ;=> 1
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
\noindent
|
||
|
|
The two expressions are identical except that the inner
|
||
|
|
\scheme{let-syntax} form
|
||
|
|
in the first expression is a \scheme{fluid-let-syntax} form in the second.
|
||
|
|
In the first expression, the \scheme{f} occurring in the expansion of
|
||
|
|
\scheme{(g 1)} refers to
|
||
|
|
the \scheme{let}-bound variable \scheme{f}, whereas in the second it refers
|
||
|
|
to the keyword \scheme{f} by virtue of the fluid syntax binding for
|
||
|
|
\scheme{f}.
|
||
|
|
|
||
|
|
\index{integrable procedures}\index{\scheme{define-integrable}}%
|
||
|
|
The following code employs \scheme{fluid-let-syntax} in the definition
|
||
|
|
of a \scheme{define-integrable} form that is similar
|
||
|
|
to \scheme{define} for procedure definitions except that it causes the
|
||
|
|
code for the procedure to be \emph{integrated}, or inserted, wherever
|
||
|
|
a direct call to the procedure is found.
|
||
|
|
No semantic difference is visible between procedures defined with
|
||
|
|
\scheme{define-integrable} and those defined with \scheme{define}, except that
|
||
|
|
a top-level \scheme{define-integrable} form must appear before the first
|
||
|
|
reference to the defined identifier.
|
||
|
|
Lexical scoping is preserved, the actual parameters
|
||
|
|
in an integrated call are evaluated once and at the proper time,
|
||
|
|
integrable procedures may be used as first-class values, and
|
||
|
|
recursive procedures do not cause indefinite recursive expansion.
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(define-syntax define-integrable
|
||
|
|
(syntax-rules (lambda)
|
||
|
|
[(_ name (lambda formals form1 form2 ...))
|
||
|
|
(begin
|
||
|
|
(define xname
|
||
|
|
(fluid-let-syntax ([name (identifier-syntax xname)])
|
||
|
|
(lambda formals form1 form2 ...)))
|
||
|
|
(define-syntax name
|
||
|
|
(lambda (x)
|
||
|
|
(syntax-case x ()
|
||
|
|
[_ (identifier? x) #'xname]
|
||
|
|
[(_ arg (... ...))
|
||
|
|
#'((fluid-let-syntax ([name (identifier-syntax xname)])
|
||
|
|
(lambda formals form1 form2 ...))
|
||
|
|
arg
|
||
|
|
(... ...))]))))]))
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
\noindent
|
||
|
|
A \scheme{define-integrable} has the following form.
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(define-integrable \var{name} \var{lambda-expression})
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
\noindent
|
||
|
|
A \scheme{define-integrable} form expands into a pair of definitions: a syntax
|
||
|
|
definition of \var{name} and a variable definition of \scheme{xname}.
|
||
|
|
The transformer for \var{name} converts apparent calls to
|
||
|
|
\var{name} into direct calls to \var{lambda-expression}.
|
||
|
|
Since the resulting forms are merely direct \scheme{lambda} applications
|
||
|
|
(the equivalent of \scheme{let} expressions),
|
||
|
|
the actual parameters are evaluated exactly once and before evaluation
|
||
|
|
of the procedure's body, as required.
|
||
|
|
All other references to \var{name} are replaced with references to
|
||
|
|
\scheme{xname}.
|
||
|
|
The definition of \scheme{xname} binds it to the value of
|
||
|
|
\var{lambda-expression}.
|
||
|
|
This allows the procedure to be used as a first-class value.
|
||
|
|
Because \scheme{xname} is introduced by the transformer, the binding for
|
||
|
|
\scheme{xname} is not visible anywhere except where references to it
|
||
|
|
are introduced by the transformer for \var{name}.
|
||
|
|
|
||
|
|
Within \var{lambda-expression}, wherever it appears, \var{name}
|
||
|
|
is rebound to a transformer that expands all references into references
|
||
|
|
to \scheme{xname}.
|
||
|
|
The use of \index{\scheme{fluid-let-syntax}}\scheme{fluid-let-syntax}
|
||
|
|
for this purpose prevents indefinite
|
||
|
|
expansion from indirect recursion among integrable procedures.
|
||
|
|
This allows the procedure to be recursive without causing indefinite
|
||
|
|
expansion.
|
||
|
|
Nothing special is done by \scheme{define-integrable} to maintain lexical
|
||
|
|
scoping, since lexical scoping is maintained automatically by the
|
||
|
|
expander.
|
||
|
|
|
||
|
|
{\ChezScheme} integrates locally defined procedures automatically when it is
|
||
|
|
appropriate to do so.
|
||
|
|
It cannot integrate procedures defined at top-level,
|
||
|
|
however, since code that assigns top-level variables can be introduced
|
||
|
|
into the system (via \scheme{eval} or \scheme{load}) at any time.
|
||
|
|
\scheme{define-integrable} can be used to force the integration of
|
||
|
|
procedures bound at top-level, even if the integration of locally bound
|
||
|
|
procedures is left to the compiler.
|
||
|
|
It can also be used to force the integration of large procedures that
|
||
|
|
the compiler would not normally integrate.
|
||
|
|
(The \scheme{expand/optimize} procedure is useful for determining when
|
||
|
|
integration does or does not take place.)
|
||
|
|
|
||
|
|
\section{Syntax-Rules Transformers\label{SECTSYNTAXRULES}}
|
||
|
|
|
||
|
|
{\ChezScheme} extends \scheme{syntax-rules} to permit clause to include
|
||
|
|
fenders just like those allowed within \scheme{syntax-case} clauses.
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{syntax-rules}{\categorysyntax}{(syntax-rules (\var{literal} \dots) \var{clause} \dots)}
|
||
|
|
\returns a transformer
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
\noindent
|
||
|
|
Each \index{literals}\var{literal} must be an identifier other than
|
||
|
|
an underscore (~\scheme{_}~) or ellipsis (~\scheme{...}~).
|
||
|
|
Each clause must take the form below.
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(\var{pattern} \var{template})
|
||
|
|
(\var{pattern} \var{fender} \var{template})
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
\noindent
|
||
|
|
The first form is the only form supported by the Revised$^6$ Report.
|
||
|
|
|
||
|
|
|
||
|
|
\section{Syntax-Case Transformers\label{SECTSYNTAXCASE}}
|
||
|
|
|
||
|
|
{\ChezScheme} provides several procedures and syntactic forms that may
|
||
|
|
be used to simplify the coding of certain syntactic abstractions.
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{syntax->list}{\categoryprocedure}{(syntax->list \var{syntax-object})}
|
||
|
|
\returns a list of syntax objects
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
\noindent
|
||
|
|
This procedure takes a syntax object representing
|
||
|
|
a list-structured form and returns a list of syntax objects, each representing
|
||
|
|
the corresponding subform of the input form.
|
||
|
|
|
||
|
|
%Programmers are encouraged to use this procedure even when the current
|
||
|
|
%{\ChezScheme} implementation of \scheme{syntax-case} guarantees that
|
||
|
|
%the output of a \scheme{syntax} form is a list, since future versions of
|
||
|
|
%{\ChezScheme} may remove these guarantees in the interest of maintaining
|
||
|
|
%better source information.
|
||
|
|
|
||
|
|
\scheme{syntax->list} may be defined as follows.
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(define syntax->list
|
||
|
|
(lambda (ls)
|
||
|
|
(syntax-case ls ()
|
||
|
|
[() '()]
|
||
|
|
[(x . r) (cons #'x (syntax->list #'r))])))
|
||
|
|
|
||
|
|
#'(a b c) ;=> #<syntax (a b c)>
|
||
|
|
(syntax->list #'(a b c)) ;=> (#<syntax a> #<syntax b> #<syntax c>)
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
\scheme{syntax->list} is not required for list structures constructed
|
||
|
|
from individual pattern variable values or sequences of pattern-variable
|
||
|
|
values, since such structures are already lists.
|
||
|
|
For example:
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(list? (with-syntax ([x #'a] [y #'b] [z #'c]) #'(x y z)))) ;=> #t
|
||
|
|
(list? (with-syntax ([(x ...) #'(a b c)]) #'(x ...))) ;=> #t
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{syntax->vector}{\categoryprocedure}{(syntax->vector \var{syntax-object})}
|
||
|
|
\returns a vector of syntax objects
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
\noindent
|
||
|
|
This procedure takes a syntax object representing
|
||
|
|
a vector-structured form and returns a vector of syntax objects, each representing
|
||
|
|
the corresponding subform of the input form.
|
||
|
|
|
||
|
|
%Programmers are encouraged to use this procedure even when the current
|
||
|
|
%{\ChezScheme} implementation of \scheme{syntax-case} guarantees that
|
||
|
|
%the output of a \scheme{syntax} form is a vector, since future versions of
|
||
|
|
%{\ChezScheme} may remove these guarantees in the interest of maintaining
|
||
|
|
%better source information.
|
||
|
|
|
||
|
|
\scheme{syntax->vector} may be defined as follows.
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(define syntax->vector
|
||
|
|
(lambda (v)
|
||
|
|
(syntax-case v ()
|
||
|
|
[#(x ...) (apply vector (syntax->list #'(x ...)))])))
|
||
|
|
|
||
|
|
#'#(a b c) ;=> #<syntax #(a b c)>
|
||
|
|
(syntax->vector #'#(a b c)) ;=> #(#<syntax a> #<syntax b> #<syntax c>)
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
\scheme{syntax->vector} is not required for vector structures constructed
|
||
|
|
from individual pattern variable values or sequences of pattern-variable
|
||
|
|
values, since such structures are already vectors.
|
||
|
|
For example:
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(vector? (with-syntax ([x #'a] [y #'b] [z #'c]) #'#(x y z)))) ;=> #t
|
||
|
|
(vector? (with-syntax ([(x ...) #'(a b c)]) #'#(x ...))) ;=> #t
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{syntax-object->datum}{\categoryprocedure}{(syntax-object->datum \var{obj})}
|
||
|
|
\returns \var{obj} stripped of syntactic information
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
\noindent
|
||
|
|
\scheme{syntax-object->datum} is identical to the Revised$^6$ Report
|
||
|
|
\scheme{syntax->datum}.
|
||
|
|
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{datum}{\categorysyntax}{(datum \var{template})}
|
||
|
|
\returns see below
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
\scheme{(datum \var{template})} is a convenient shorthand syntax for
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(syntax->datum (syntax \var{template}))
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
\var{datum} may be defined simply as follows.
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(define-syntax datum
|
||
|
|
(syntax-rules ()
|
||
|
|
[(_ t) (syntax->datum #'t)]))
|
||
|
|
|
||
|
|
(with-syntax ((a #'(a b c))) (datum a)) ;=> (a b c)
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{datum->syntax-object}{\categoryprocedure}{(datum->syntax-object \var{template-identifier} \var{obj})}
|
||
|
|
\returns a syntax object
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
\scheme{datum->syntax-object} is identical to the Revised$^6$ Report
|
||
|
|
\scheme{datum->syntax}.
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{with-implicit}{\categorysyntax}{(with-implicit (\var{id_0} \var{id_1} \dots) \var{body_1} \var{body_2} \dots)}
|
||
|
|
\returns see below
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
This form abstracts over the common usage of \scheme{datum->syntax}
|
||
|
|
for creating implicit identifiers (see above).
|
||
|
|
The form
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(with-implicit (\var{id_0} \var{id_1} \dots)
|
||
|
|
\var{body_1} \var{body_2} \dots)
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
is equivalent to
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(with-syntax ([\var{id_1} (datum->syntax #'\var{id_0} '\var{id_1})] \dots)
|
||
|
|
\var{body_1} \var{body_2} \dots)
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
\scheme{with-implicit} can be defined simply as follows.
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(define-syntax with-implicit
|
||
|
|
(syntax-rules ()
|
||
|
|
[(_ (tid id ...) b1 b2 ...)
|
||
|
|
(with-syntax ([id (datum->syntax #'tid 'id)] ...)
|
||
|
|
b1 b2 ...)]))
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
We can use \scheme{with-implicit} to simplify the (correct version of)
|
||
|
|
\scheme{loop} above.
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(define-syntax loop
|
||
|
|
(lambda (x)
|
||
|
|
(syntax-case x ()
|
||
|
|
[(k e ...)
|
||
|
|
(with-implicit (k break)
|
||
|
|
#'(call-with-current-continuation
|
||
|
|
(lambda (break)
|
||
|
|
(let f () e ... (f)))))])))
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{include}{\categorysyntax}{(include \var{path})}
|
||
|
|
\returns unspecified
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
\noindent
|
||
|
|
\var{path} must be a string.
|
||
|
|
\scheme{include} expands into a \scheme{begin} expression containing
|
||
|
|
the forms found in the file named by \var{path}.
|
||
|
|
For example, if the file \scheme{f-def.ss} contains
|
||
|
|
% the expression
|
||
|
|
\scheme{(define f (lambda () x))}, the expression
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(let ([x "okay"])
|
||
|
|
(include "f-def.ss")
|
||
|
|
(f))
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
\noindent
|
||
|
|
evaluates to \scheme{"okay"}.
|
||
|
|
An include form is treated as a definition if it appears within a
|
||
|
|
sequence of definitions and the forms on the file named by
|
||
|
|
\var{path} are all definitions, as in the above example.
|
||
|
|
If the file contains expressions instead, the \scheme{include} form is
|
||
|
|
treated as an expression.
|
||
|
|
|
||
|
|
\scheme{include} may be defined portably as follows, although
|
||
|
|
{\ChezScheme} uses an implementation-dependent definition that allows
|
||
|
|
it to capture and maintain source information for included code.
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(define-syntax include
|
||
|
|
(lambda (x)
|
||
|
|
(define read-file
|
||
|
|
(lambda (fn k)
|
||
|
|
(let ([p (open-input-file fn)])
|
||
|
|
(let f ([x (read p)])
|
||
|
|
(if (eof-object? x)
|
||
|
|
(begin (close-input-port p) '())
|
||
|
|
(cons (datum->syntax k x)
|
||
|
|
(f (read p))))))))
|
||
|
|
(syntax-case x ()
|
||
|
|
[(k filename)
|
||
|
|
(let ([fn (datum filename)])
|
||
|
|
(with-syntax ([(exp ...) (read-file fn #'k)])
|
||
|
|
#'(begin exp ...)))])))
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
\noindent
|
||
|
|
The definition of \scheme{include} uses \scheme{datum->syntax} to convert
|
||
|
|
the objects read from the file into syntax objects in the proper
|
||
|
|
lexical context, so that identifier references and definitions within
|
||
|
|
those expressions are scoped where the \scheme{include} form appears.
|
||
|
|
|
||
|
|
In {\ChezScheme}'s implementation of \scheme{include},
|
||
|
|
the parameter \scheme{source-directories} (Section~\ref{SECTSYSTEMSOURCE})
|
||
|
|
determines the set of directories searched for source files not identified
|
||
|
|
by absolute path names.
|
||
|
|
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader\label{desc:syntax-error}
|
||
|
|
\formdef{syntax-error}{\categoryprocedure}{(syntax-error \var{obj} \var{string} \dots)}
|
||
|
|
\returns does not return
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
Syntax errors may be reported with \scheme{syntax-error}, which produces
|
||
|
|
a message by concatenating \scheme{\var{string} \dots} and a printed
|
||
|
|
representation of \var{obj}.
|
||
|
|
If no string arguments are provided, the string \scheme{"invalid syntax"}
|
||
|
|
is used instead.
|
||
|
|
When \var{obj} is a syntax object, the syntax-object wrapper is
|
||
|
|
stripped (as with \scheme{syntax->datum}) before the printed representation
|
||
|
|
is created.
|
||
|
|
If source file information is present in the syntax-object wrapper,
|
||
|
|
\scheme{syntax-error} incorporates this information into the error
|
||
|
|
message.
|
||
|
|
|
||
|
|
\scheme{syntax-case} and \scheme{syntax-rules} call \scheme{syntax-error}
|
||
|
|
automatically if the input fails to match one of the clauses.
|
||
|
|
|
||
|
|
We can use \scheme{syntax-error} to precisely report the cause
|
||
|
|
of the errors detected in the following definition of
|
||
|
|
(unnamed) \scheme{let}.
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(define-syntax let
|
||
|
|
(lambda (x)
|
||
|
|
(define check-ids!
|
||
|
|
(lambda (ls)
|
||
|
|
(unless (null? ls)
|
||
|
|
(unless (identifier? (car ls))
|
||
|
|
(syntax-error (car ls) "let cannot bind non-identifier"))
|
||
|
|
(check-ids! (cdr ls)))))
|
||
|
|
(define check-unique!
|
||
|
|
(lambda (ls)
|
||
|
|
(unless (null? ls)
|
||
|
|
(let ([x (car ls)])
|
||
|
|
(when (let mem? ([ls (cdr ls)])
|
||
|
|
(and (not (null? ls))
|
||
|
|
(or (bound-identifier=? x (car ls))
|
||
|
|
(mem? (cdr ls)))))
|
||
|
|
(syntax-error x "let cannot bind two occurrences of")))
|
||
|
|
(check-unique! (cdr ls)))))
|
||
|
|
(syntax-case x ()
|
||
|
|
[(_ ((i e) ...) b1 b2 ...)
|
||
|
|
(begin
|
||
|
|
(check-ids! #'(i ...))
|
||
|
|
(check-unique! #'(i ...))
|
||
|
|
#'((lambda (i ...) b1 b2 ...) e ...))])))
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
With this change, the expression
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(let ([a 3] [a 4]) (+ a a))
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
produces the error message ``let cannot bind two occurrences of \scheme{a}.''
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{literal-identifier=?}{\categoryprocedure}{(literal-identifier=? \var{identifier_1} \var{identifier_2})}
|
||
|
|
\returns see below
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
This procedure is identical to the Revised$^6$ Report
|
||
|
|
\scheme{free-identifier=?}, and is provided for backward
|
||
|
|
compatibility only.
|
||
|
|
|
||
|
|
\section{Compile-time Values and Properties\label{SECTSYNTAXCTVS}}
|
||
|
|
|
||
|
|
When defining sets of dependent macros, it is often convenient to attach
|
||
|
|
information to identifiers in the same \emph{compile time environment}
|
||
|
|
that the expander uses to record information about variables, keywords,
|
||
|
|
module names, etc.
|
||
|
|
For example, a record-type definition macro, like
|
||
|
|
\scheme{define-record-type}, might need to attach information to the
|
||
|
|
record-type name in the compile-time environment for use in handling child
|
||
|
|
record-type definitions.
|
||
|
|
|
||
|
|
{\ChezScheme} provides two mechanisms for attaching information to
|
||
|
|
identifiers in the compile-time environment: compile-time values and
|
||
|
|
compile-time properties.
|
||
|
|
A compile-time value is a kind of transformer that can be
|
||
|
|
associated with an identifier via \scheme{define-syntax},
|
||
|
|
\scheme{let-syntax}, \scheme{letrec-syntax}, and \scheme{fluid-let-syntax}.
|
||
|
|
When an identifier is associated with a compile-time value, it cannot
|
||
|
|
also have any other meaning, and an attempt to reference it as an
|
||
|
|
ordinary identifier results in a syntax error.
|
||
|
|
A compile-time property, on the other hand, is maintained alongside
|
||
|
|
an existing binding, providing additional information about the
|
||
|
|
binding.
|
||
|
|
Properties are ignored when ordinary references to an identifier
|
||
|
|
occur.
|
||
|
|
|
||
|
|
The mechanisms used by a macro to obtain compile-time values and
|
||
|
|
properties are similar.
|
||
|
|
In both cases, the macro's transformer returns a procedure \var{p}
|
||
|
|
rather than a syntax object.
|
||
|
|
The expander invokes \var{p} with one argument, an environment-lookup
|
||
|
|
procedure \var{lookup}, which \var{p} can then use to obtain compile-time
|
||
|
|
values and properties for one or more identifiers before it constructs the
|
||
|
|
macro's final output.
|
||
|
|
\var{lookup} accepts one or two identifier arguments.
|
||
|
|
With one argument, \var{id}, \var{lookup} returns the compile-time
|
||
|
|
value of \var{id}, or \scheme{#f} if \var{id} has no compile-time value.
|
||
|
|
With two arguments, \var{id} and \var{key}, \var{lookup} returns the
|
||
|
|
value of \var{id}'s \var{key} property, or \scheme{#f} if \var{id}
|
||
|
|
has no \var{key} property.
|
||
|
|
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{make-compile-time-value}{\categoryprocedure}{(make-compile-time-value \var{obj})}
|
||
|
|
\returns a compile-time value
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
A compile time value is a kind of transformer with which a keyword may
|
||
|
|
be associated by any of the keyword binding constructs, e.g., \scheme{define-syntax}
|
||
|
|
or \scheme{let-syntax}.
|
||
|
|
The transformer encapsulates the supplied \var{obj}.
|
||
|
|
The encapsulated object may be retrieved as described above.
|
||
|
|
|
||
|
|
The following example illustrates how this feature might be used to define
|
||
|
|
a simple syntactic record-definition mechanism where the record type descriptor
|
||
|
|
is generated at expansion time.
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(define-syntax drt
|
||
|
|
(lambda (x)
|
||
|
|
(define construct-name
|
||
|
|
(lambda (template-identifier . args)
|
||
|
|
(datum->syntax template-identifier
|
||
|
|
(string->symbol
|
||
|
|
(apply string-append
|
||
|
|
(map (lambda (x)
|
||
|
|
(if (string? x)
|
||
|
|
x
|
||
|
|
(symbol->string (syntax->datum x))))
|
||
|
|
args))))))
|
||
|
|
(define do-drt
|
||
|
|
(lambda (rname fname* prtd)
|
||
|
|
(with-syntax ([rname rname]
|
||
|
|
[rtd (make-record-type-descriptor
|
||
|
|
(syntax->datum rname) prtd #f #f #f
|
||
|
|
(list->vector
|
||
|
|
(map (lambda (fname)
|
||
|
|
`(immutable ,(syntax->datum fname)))
|
||
|
|
fname*)))]
|
||
|
|
[make-rname (construct-name rname "make-" rname)]
|
||
|
|
[rname? (construct-name rname rname "?")]
|
||
|
|
[(rname-fname ...)
|
||
|
|
(map (lambda (fname)
|
||
|
|
(construct-name fname rname "-" fname))
|
||
|
|
fname*)]
|
||
|
|
[(i ...) (enumerate fname*)])
|
||
|
|
#'(begin
|
||
|
|
(define-syntax rname (make-compile-time-value 'rtd))
|
||
|
|
(define rcd (make-record-constructor-descriptor 'rtd #f #f))
|
||
|
|
(define make-rname (record-constructor rcd))
|
||
|
|
(define rname? (record-predicate 'rtd))
|
||
|
|
(define rname-fname (record-accessor 'rtd i))
|
||
|
|
...))))
|
||
|
|
(syntax-case x (parent)
|
||
|
|
[(_ rname (fname ...))
|
||
|
|
(for-all identifier? #'(rname fname ...))
|
||
|
|
(do-drt #'rname #'(fname ...) #f)]
|
||
|
|
[(_ rname pname (fname ...))
|
||
|
|
(for-all identifier? #'(rname pname fname ...))
|
||
|
|
(lambda (lookup)
|
||
|
|
(let ([prtd (lookup #'pname)])
|
||
|
|
(unless (record-type-descriptor? prtd)
|
||
|
|
(syntax-error #'pname "unrecognized parent record type"))
|
||
|
|
(do-drt #'rname #'(fname ...) prtd)))])))
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(drt prec (x y))
|
||
|
|
(drt crec prec (z))
|
||
|
|
(define r (make-crec 1 2 3))
|
||
|
|
(prec? r) ;=> #t
|
||
|
|
(prec-x r) ;=> 1
|
||
|
|
(crec-z r) ;=> 3
|
||
|
|
prec ;=> \var{exception: invalid syntax prec}
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{compile-time-value?}{\categoryprocedure}{(compile-time-value? \var{obj})}
|
||
|
|
\returns \scheme{#t} if \var{obj} is a compile-time value; \scheme{#f} otherwise
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(define-syntax x (make-compile-time-value "eggs"))
|
||
|
|
(compile-time-value? (top-level-syntax 'x)) ;=> #t
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{compile-time-value-value}{\categoryprocedure}{(compile-time-value-value \var{ctv})}
|
||
|
|
\returns the value of a compile-time value
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(define-syntax x (make-compile-time-value "eggs"))
|
||
|
|
(compile-time-value-value (top-level-syntax 'x)) ;=> "eggs"
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{define-property}{\categorysyntax}{(define-property \var{id} \var{key} \var{expr})}
|
||
|
|
\returns unspecified
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
A \scheme{define-property} form attaches a property to an
|
||
|
|
existing identifier binding without disturbing the existing meaning
|
||
|
|
of the identifier in the scope of that binding.
|
||
|
|
It is typically used by one macro to record information about a binding
|
||
|
|
for use by another macro.
|
||
|
|
Both \var{id} and \var{key} must be identifiers.
|
||
|
|
The expression \var{expr} is evaluated when the \scheme{define-property}
|
||
|
|
form is expanded, and a new property associating \var{key} with the
|
||
|
|
value of \var{expr} is attached to the existing binding of
|
||
|
|
\var{id}, which must have a visible local or top-level binding.
|
||
|
|
|
||
|
|
\scheme{define-property} is a definition and can appear anywhere
|
||
|
|
other definitions can appear.
|
||
|
|
The scope of a property introduced by \scheme{define-property} is the
|
||
|
|
entire body in which the \scheme{define-property} form appears or global
|
||
|
|
if it appears at top level, except
|
||
|
|
where it is replaced by a property for the same \var{id} and
|
||
|
|
\var{key} or where the binding to which it is attached is shadowed.
|
||
|
|
Any number of properties can be attached to the same binding with
|
||
|
|
different keys.
|
||
|
|
Attaching a new property with the same name as an property already
|
||
|
|
attached to a binding shadows the existing property with the new
|
||
|
|
property.
|
||
|
|
|
||
|
|
The following example defines a macro, \scheme{get-info}, that retrieves
|
||
|
|
the \scheme{info} property of a binding, defines the variable \scheme{x},
|
||
|
|
attaches an \scheme{info} property to the binding of \scheme{x}, retrieves
|
||
|
|
the property via \scheme{get-info}, references \scheme{x} to show that
|
||
|
|
its normal binding is still intact, and uses \scheme{get-info} again
|
||
|
|
within the scope of a different binding of \scheme{x} to show that the
|
||
|
|
properties are shadowed as well as the outer binding of \scheme{x}.
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(define info)
|
||
|
|
(define-syntax get-info
|
||
|
|
(lambda (x)
|
||
|
|
(lambda (lookup)
|
||
|
|
(syntax-case x ()
|
||
|
|
[(_ q)
|
||
|
|
(let ([info-value (lookup #'q #'info)])
|
||
|
|
#`'#,(datum->syntax #'* info-value))]))))
|
||
|
|
(define x "x-value")
|
||
|
|
(define-property x info "x-info")
|
||
|
|
(get-info x) ;=> "x-info"
|
||
|
|
x ;=> "x-value"
|
||
|
|
(let ([x "inner-x-value"]) (get-info x)) ;=> #f
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
For debugging, it is often useful to have a form that retrieves
|
||
|
|
an arbitrary property, given an identifier and a key.
|
||
|
|
The \index{\scheme{get-property}}\scheme{get-property} macro below does
|
||
|
|
just that.
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(define-syntax get-property
|
||
|
|
(lambda (x)
|
||
|
|
(lambda (r)
|
||
|
|
(syntax-case x ()
|
||
|
|
[(_ id key)
|
||
|
|
#`'#,(datum->syntax #'* (r #'id #'key))]))))
|
||
|
|
(get-property x info) ;=> "x-info"
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
The bindings for both identifiers must be visible where
|
||
|
|
\scheme{get-property} is used.
|
||
|
|
|
||
|
|
The version of \scheme{drt} defined below is like the one defined using
|
||
|
|
\scheme{make-compile-time-value} above, except that it defines the
|
||
|
|
record name as a macro that raises an exception with a more descriptive
|
||
|
|
message, while attaching the record type descriptor to the binding as a
|
||
|
|
separate property.
|
||
|
|
The variable \scheme{drt-key} defined along with \scheme{drt} is used
|
||
|
|
only as the key for the property that \scheme{drt} attaches to a record
|
||
|
|
name.
|
||
|
|
Both \scheme{drt-key} and \scheme{drt} are defined within a module that
|
||
|
|
exports only the latter, ensuring that the properties used by \scheme{drt}
|
||
|
|
cannot be accessed or forged.
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(library (drt) (export drt) (import (chezscheme))
|
||
|
|
(define drt-key)
|
||
|
|
(define-syntax drt
|
||
|
|
(lambda (x)
|
||
|
|
(define construct-name
|
||
|
|
(lambda (template-identifier . args)
|
||
|
|
(datum->syntax template-identifier
|
||
|
|
(string->symbol
|
||
|
|
(apply string-append
|
||
|
|
(map (lambda (x)
|
||
|
|
(if (string? x)
|
||
|
|
x
|
||
|
|
(symbol->string (syntax->datum x))))
|
||
|
|
args))))))
|
||
|
|
(define do-drt
|
||
|
|
(lambda (rname fname* prtd)
|
||
|
|
(with-syntax ([rname rname]
|
||
|
|
[rtd (make-record-type-descriptor
|
||
|
|
(syntax->datum rname) prtd #f #f #f
|
||
|
|
(list->vector
|
||
|
|
(map (lambda (fname)
|
||
|
|
`(immutable ,(syntax->datum fname)))
|
||
|
|
fname*)))]
|
||
|
|
[make-rname (construct-name rname "make-" rname)]
|
||
|
|
[rname? (construct-name rname rname "?")]
|
||
|
|
[(rname-fname ...)
|
||
|
|
(map (lambda (fname)
|
||
|
|
(construct-name fname rname "-" fname))
|
||
|
|
fname*)]
|
||
|
|
[(i ...) (enumerate fname*)])
|
||
|
|
#'(begin
|
||
|
|
(define-syntax rname
|
||
|
|
(lambda (x)
|
||
|
|
(syntax-error x "invalid use of record name")))
|
||
|
|
(define rcd (make-record-constructor-descriptor 'rtd #f #f))
|
||
|
|
(define-property rname drt-key 'rtd)
|
||
|
|
(define make-rname (record-constructor rcd))
|
||
|
|
(define rname? (record-predicate 'rtd))
|
||
|
|
(define rname-fname (record-accessor 'rtd i))
|
||
|
|
...))))
|
||
|
|
(syntax-case x (parent)
|
||
|
|
[(_ rname (fname ...))
|
||
|
|
(for-all identifier? #'(rname fname ...))
|
||
|
|
(do-drt #'rname #'(fname ...) #f)]
|
||
|
|
[(_ rname pname (fname ...))
|
||
|
|
(for-all identifier? #'(rname pname fname ...))
|
||
|
|
(lambda (lookup)
|
||
|
|
(let ([prtd (lookup #'pname #'drt-key)])
|
||
|
|
(unless prtd
|
||
|
|
(syntax-error #'pname "unrecognized parent record type"))
|
||
|
|
(do-drt #'rname #'(fname ...) prtd)))]))))
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(import (drt))
|
||
|
|
(drt prec (x y))
|
||
|
|
(drt crec prec (z))
|
||
|
|
(define r (make-crec 1 2 3))
|
||
|
|
(prec? r) ;=> #t
|
||
|
|
(prec-x r) ;=> 1
|
||
|
|
(crec-z r) ;=> 3
|
||
|
|
prec ;=> \var{exception: invalid use of record name prec}
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
\section{Modules\label{SECTSYNTAXMODULES}}
|
||
|
|
|
||
|
|
\index{modules}Modules are used to help organize programs into separate
|
||
|
|
parts that interact cleanly via declared interfaces.
|
||
|
|
Although modular programming is typically used to facilitate the development
|
||
|
|
of large programs possibly written by many individuals, it may also be
|
||
|
|
used in {\ChezScheme} at a ``micro-modular'' level, since {\ChezScheme}
|
||
|
|
module and import forms are definitions and may appear anywhere any other
|
||
|
|
kind of definition may appear, including within a \scheme{lambda} body
|
||
|
|
or other local scope.
|
||
|
|
|
||
|
|
Modules control visibility of bindings and can be viewed as extending
|
||
|
|
lexical scoping to allow more precise control over where bindings are
|
||
|
|
or are not visible.
|
||
|
|
Modules export identifier bindings, i.e., variable bindings, keyword
|
||
|
|
bindings, or module name bindings.
|
||
|
|
Modules may be \emph{named} or \emph{anonymous}.
|
||
|
|
Bindings exported from a named module may be made visible via an import
|
||
|
|
form wherever the module's name is visible.
|
||
|
|
Bindings exported from an anonymous module are implicitly imported where
|
||
|
|
the module form appears.
|
||
|
|
Anonymous modules are useful for hiding some of a set of bindings while
|
||
|
|
allowing the remaining bindings in the set to be visible.
|
||
|
|
|
||
|
|
Some of the text and examples given in this section are
|
||
|
|
adapted from the paper
|
||
|
|
``Extending the scope of syntactic
|
||
|
|
abstraction''~\cite{waddell:modules}, which describes modules and their
|
||
|
|
implementation in more detail.
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{module}{\categorysyntax}{(module \var{name} \var{interface} \var{defn} \dots \var{init} \dots)}
|
||
|
|
\formdef{module}{\categorysyntax}{(module \var{interface} \var{defn} \dots \var{init} \dots)}
|
||
|
|
\returns unspecified
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
\noindent
|
||
|
|
\var{name} is an identifier, \scheme{\var{defn} \dots}
|
||
|
|
are definitions, and \scheme{\var{init} \dots} are expressions.
|
||
|
|
\var{interface} is a list of exports \scheme{(\var{export} \dots)},
|
||
|
|
where each \var{export} is either an identifier \var{identifier}
|
||
|
|
or of the form \scheme{(\var{identifier} \var{export} \dots)}.
|
||
|
|
|
||
|
|
The first syntax for \scheme{module} establishes a named scope that
|
||
|
|
encapsulates a set of identifier bindings.
|
||
|
|
The exported bindings may be made visible via \scheme{import} or
|
||
|
|
\scheme{import-only} (Section~\ref{SECTLIBRARYIMPORTEXPORTFORMS})
|
||
|
|
anywhere the module name is visible.
|
||
|
|
The second syntax for \scheme{module} introduces an anonymous module
|
||
|
|
whose bindings are implicitly imported (as if by \scheme{import} of a
|
||
|
|
hidden module name) where the module form appears.
|
||
|
|
|
||
|
|
A module consists of a (possibly empty) set of
|
||
|
|
definitions and a (possibly empty) sequence of initialization expressions.
|
||
|
|
The identifiers defined within a module are visible within the body
|
||
|
|
of the module and, if exported, within the scope of an import for the
|
||
|
|
module.
|
||
|
|
Each identifier listed in a module's interface must be defined within
|
||
|
|
or imported into that module.
|
||
|
|
A \scheme{module} form is a definition and can appear anywhere other
|
||
|
|
definitions can appear, including
|
||
|
|
at the top level of a program, nested within the bodies of
|
||
|
|
\scheme{lambda} expressions, nested within \scheme{library} and
|
||
|
|
top-level program forms, and nested within other modules.
|
||
|
|
Also, because module names are scoped like other identifiers,
|
||
|
|
modules and libraries may export module names as well as variables and keywords.
|
||
|
|
|
||
|
|
When an interface contains an export of the form
|
||
|
|
\scheme{(\var{identifier} \var{export} \dots)}, only \var{identifier} is
|
||
|
|
visible in the importing context.
|
||
|
|
The identifiers within \scheme{\var{export} \dots} are
|
||
|
|
\emph{indirect imports}, as if declared via an
|
||
|
|
\scheme{indirect-export} form (Section~\ref{SECTLIBRARYIMPORTEXPORTFORMS}).
|
||
|
|
|
||
|
|
Module names occupy the same namespace as other identifiers and follow
|
||
|
|
the same scoping rules.
|
||
|
|
Unless exported, identifiers defined within a module are visible only
|
||
|
|
within that module.
|
||
|
|
|
||
|
|
Expressions within a module can reference identifiers bound outside of
|
||
|
|
the module.
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(let ([x 3])
|
||
|
|
(module m (plusx)
|
||
|
|
(define plusx (lambda (y) (+ x y))))
|
||
|
|
(import m)
|
||
|
|
(let ([x 4])
|
||
|
|
(plusx 5))) ;=> 8
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
\noindent
|
||
|
|
Similarly, \scheme{import} does not prevent access to identifiers that
|
||
|
|
are visible where the import form appears, except for those variables
|
||
|
|
shadowed by the imported identifiers.
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(module m (y) (define y 'm-y))
|
||
|
|
(let ([x 'local-x] [y 'local-y])
|
||
|
|
(import m)
|
||
|
|
(list x y)) ;=> (local-x m-y)
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
On the other hand, use of \scheme{import-only} within a module
|
||
|
|
establishes an isolated scope in
|
||
|
|
which the only visible identifiers are those exported by the
|
||
|
|
imported module.
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(module m (y) (define y 'm-y))
|
||
|
|
(let ([x 'local-x] [y 'local-y])
|
||
|
|
(import-only m)
|
||
|
|
x) ;=> Error: x is not visible
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
\noindent
|
||
|
|
This is sometimes desirable for static verification that no
|
||
|
|
identifiers are used except those explicitly imported into a
|
||
|
|
module or local scope.
|
||
|
|
|
||
|
|
Unless a module imported via \scheme{import-only} exports
|
||
|
|
\scheme{import} or
|
||
|
|
\scheme{import-only} and the name of at least one module, subsequent
|
||
|
|
imports within the scope of the \scheme{import-only} form are not
|
||
|
|
possible.
|
||
|
|
To create an isolated scope containing the exports of more than one
|
||
|
|
module without making \scheme{import} or \scheme{import-only}
|
||
|
|
visible, all of the modules to be imported must be listed in the
|
||
|
|
same \scheme{import-only} form.
|
||
|
|
|
||
|
|
Another solution is to create a single module that contains
|
||
|
|
the exports of each of the other modules.
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(module m2 (y) (define y 'y))
|
||
|
|
(module m1 (x) (define x 'x))
|
||
|
|
(module mega-module (cons x y)
|
||
|
|
(import m1)
|
||
|
|
(import m2)
|
||
|
|
(import scheme))
|
||
|
|
(let ([y 3])
|
||
|
|
(import-only mega-module)
|
||
|
|
(cons x y)) ;=> (x . y)
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
\bigskip
|
||
|
|
Before it is compiled, a source program is translated into
|
||
|
|
a core language program containing no syntactic abstractions, syntactic
|
||
|
|
definitions, library definitions, module definitions, or import forms.
|
||
|
|
Translation is performed by a \emph{syntax expander} that
|
||
|
|
processes the forms in the source program via recursive descent.
|
||
|
|
|
||
|
|
A \scheme{define-syntax} form associates a keyword
|
||
|
|
with a transformer in a translation-time environment.
|
||
|
|
When the expander encounters a keyword, it invokes the
|
||
|
|
associated transformer and reprocesses the resulting form.
|
||
|
|
A \scheme{module} form associates a module name with an interface.
|
||
|
|
When the expander encounters an \scheme{import} form, it extracts the
|
||
|
|
corresponding module interface from the translation-time environment and makes
|
||
|
|
the exported bindings visible in the scope where the \scheme{import} form
|
||
|
|
appears.
|
||
|
|
|
||
|
|
Internal definitions and definitions within a \scheme{module}
|
||
|
|
body are processed from left to right so that a module's definition
|
||
|
|
and import may appear within the same sequence of definitions.
|
||
|
|
Expressions appearing within a body and the right-hand sides of variable
|
||
|
|
definitions, however, are translated
|
||
|
|
only after the entire set of definitions has been processed, allowing
|
||
|
|
full mutual recursion among variable and syntactic definitions.
|
||
|
|
|
||
|
|
Module and import forms affect only the visibility of identifiers in
|
||
|
|
the source program, not their meanings.
|
||
|
|
In particular, variables are bound to locations whether defined within or
|
||
|
|
outside of a module, and \scheme{import} does not introduce new locations.
|
||
|
|
Local variables are renamed as necessary to preserve the scoping
|
||
|
|
relationships established by both modules and syntactic abstractions.
|
||
|
|
Thus, the expression:
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(let ([x 1])
|
||
|
|
(module m (x setter)
|
||
|
|
(define-syntax x (identifier-syntax z))
|
||
|
|
(define setter (lambda (x) (set! z x)))
|
||
|
|
(define z 5))
|
||
|
|
(let ([y x] [z 0])
|
||
|
|
(import m)
|
||
|
|
(setter 3)
|
||
|
|
(+ x y z))) ;=> 4
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
is equivalent to the following program
|
||
|
|
in which identifiers have been consistently renamed as indicated by
|
||
|
|
subscripts.
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(let ([x\var{_0} 1])
|
||
|
|
(define-syntax x\var{_1} (identifier-syntax z\var{_1}))
|
||
|
|
(define setter\var{_1} (lambda (x\var{_2}) (set! z\var{_1} x\var{_2})))
|
||
|
|
(define z\var{_1} 5)
|
||
|
|
(let ([y\var{_3} x\var{_0}] [z\var{_3} 0])
|
||
|
|
(setter\var{_1} 3)
|
||
|
|
(+ x\var{_1} y\var{_3} z\var{_3})))
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
Definitions within a top-level \scheme{begin}, \scheme{lambda}, top-level program,
|
||
|
|
\scheme{library}, or \scheme{module} body
|
||
|
|
are processed from left to right by the expander at expand time, and the
|
||
|
|
variable definitions are evaluated from left-to-right at run time.
|
||
|
|
Initialization expressions appearing within a \scheme{module} body
|
||
|
|
are evaluated in sequence after the evaluation of the variable
|
||
|
|
definitions.
|
||
|
|
|
||
|
|
Mutually recursive modules can be defined in several ways.
|
||
|
|
In the following program, \scheme{a} and \scheme{b} are mutually recursive
|
||
|
|
modules exported by an anonymous module whose local scope is used to
|
||
|
|
statically link the two.
|
||
|
|
For example,
|
||
|
|
the free variable \scheme{y} within module \scheme{a} refers to
|
||
|
|
the binding for \scheme{y}, provided by importing \scheme{b},
|
||
|
|
in the enclosing module.
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(module (a b)
|
||
|
|
(module a (x) (define x (lambda () y)))
|
||
|
|
(module b (y) (define y (lambda () x)))
|
||
|
|
(import a)
|
||
|
|
(import b))
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
\noindent
|
||
|
|
The following syntactic abstraction generalizes this pattern to
|
||
|
|
permit the definition of multiple mutually recursive modules.
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(define-syntax rec-modules
|
||
|
|
(syntax-rules (module)
|
||
|
|
[(_ (module m (id ...) form ...) ...)
|
||
|
|
(module (m ...)
|
||
|
|
(module m (id ...) form ...) ...
|
||
|
|
(import m) ...)]))
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
Because a module can re-export imported bindings,
|
||
|
|
it is quite easy to provide multiple views on a single
|
||
|
|
module, as \scheme{s} and \scheme{t} provide for \scheme{r}
|
||
|
|
below, or to combine several modules into a compound,
|
||
|
|
as \scheme{r} does.
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(module p (x y)
|
||
|
|
(define x 1) (define y 2))
|
||
|
|
(module q (y z)
|
||
|
|
(define y 3) (define z 4))
|
||
|
|
(module r (a b c d)
|
||
|
|
(import* p (a x) (b y))
|
||
|
|
(import* q (c y) (d z)))
|
||
|
|
(module s (a c) (import r))
|
||
|
|
(module t (b d) (import r))
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
To allow interfaces to be separated from implementations,
|
||
|
|
the following syntactic abstractions support the definition and use of
|
||
|
|
named interfaces.
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(define-syntax define-interface
|
||
|
|
(syntax-rules ()
|
||
|
|
[(_ name (export ...))
|
||
|
|
(define-syntax name
|
||
|
|
(lambda (x)
|
||
|
|
(syntax-case x ()
|
||
|
|
[(_ n defs)
|
||
|
|
(with-implicit (n export ...)
|
||
|
|
#'(module n (export ...) .
|
||
|
|
defs))])))]))
|
||
|
|
|
||
|
|
(define-syntax define-module
|
||
|
|
(syntax-rules ()
|
||
|
|
[(_ name interface defn ...)
|
||
|
|
(interface name (defn ...))]))
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
\noindent
|
||
|
|
\scheme{define-interface} creates an interface macro that, given a module
|
||
|
|
name and a list of definitions, expands into a module definition with
|
||
|
|
a concrete interface.
|
||
|
|
|
||
|
|
\scheme{with-implicit} is used to ensure that the introduced
|
||
|
|
\scheme{export} identifiers are visible in the same scope as the name of
|
||
|
|
the module in the \scheme{define-module} form.
|
||
|
|
|
||
|
|
\noindent
|
||
|
|
\scheme{define-interface} and \scheme{define-module} can be used as
|
||
|
|
follows.
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(define-interface simple (a b))
|
||
|
|
(define-module m simple
|
||
|
|
(define-syntax a (identifier-syntax 1))
|
||
|
|
(define b (lambda () c))
|
||
|
|
(define c 2))
|
||
|
|
(let () (import m) (+ a (b))) ;=> 3
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
The abstract module facility defined below allows a module interface to
|
||
|
|
be satisfied incrementally when module forms are evaluated.
|
||
|
|
This permits flexibility in the separation between the interface and
|
||
|
|
implementation, supports separate compilation of mutually recursive
|
||
|
|
modules, and permits redefinition of module implementations.
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(define-syntax abstract-module
|
||
|
|
(syntax-rules ()
|
||
|
|
[(_ name (ex ...) (kwd ...) defn ...)
|
||
|
|
(module name (ex ... kwd ...)
|
||
|
|
(declare ex) ...
|
||
|
|
defn ...)]))
|
||
|
|
|
||
|
|
(define-syntax implement
|
||
|
|
(syntax-rules ()
|
||
|
|
[(_ name form ...)
|
||
|
|
(module () (import name) form ...)]))
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
\noindent
|
||
|
|
Within an \scheme{abstract-module} form,
|
||
|
|
each of the exports in the list \scheme{\var{ex} \dots} must be
|
||
|
|
variables.
|
||
|
|
The values of these variables are supplied by one or more separate
|
||
|
|
\scheme{implement} forms.
|
||
|
|
Since keyword bindings must be present at compile time,
|
||
|
|
they cannot be satisfied incrementally and are instead listed as
|
||
|
|
separate exports and defined within the abstract module.
|
||
|
|
|
||
|
|
Within an \scheme{implement} form,
|
||
|
|
the sequence of forms \scheme{\var{form} \dots} is a sequence of
|
||
|
|
zero or more definitions followed by a sequence of zero or more
|
||
|
|
expressions.
|
||
|
|
Since the module used in the expansion of \scheme{implement} does
|
||
|
|
not export anything, the definitions are all local to the
|
||
|
|
\scheme{implement} form.
|
||
|
|
The expressions may be arbitrary expressions, but should include
|
||
|
|
one \scheme{satisfy} form for each variable whose definition is
|
||
|
|
supplied by the \scheme{implement} form.
|
||
|
|
A \scheme{satisfy} form has the syntax
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(satisfy \var{variable} \var{expr})
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
\noindent
|
||
|
|
\scheme{declare} and \scheme{satisfy} may simply be the equivalents of
|
||
|
|
\scheme{define} and \scheme{set!}.
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(define-syntax declare (identifier-syntax define))
|
||
|
|
(define-syntax satisfy (identifier-syntax set!))
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
\noindent
|
||
|
|
Alternatively, \scheme{declare} can initialize the declared variable to
|
||
|
|
the value of a flag known only to \scheme{declare} and \scheme{satisfy},
|
||
|
|
and \scheme{satisfy} can verify that this flag is still present to insure
|
||
|
|
that only one attempt to satisfy the value of a given identifier is
|
||
|
|
made.
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(module ((declare cookie) (satisfy cookie))
|
||
|
|
(define cookie "chocolate chip")
|
||
|
|
(define-syntax declare
|
||
|
|
(syntax-rules () [(_ var) (define var cookie)]))
|
||
|
|
(define-syntax satisfy
|
||
|
|
(syntax-rules ()
|
||
|
|
[(_ var exp)
|
||
|
|
(if (eq? var cookie)
|
||
|
|
(set! var exp)
|
||
|
|
(assertion-violationf 'satisfy
|
||
|
|
"value of variable ~s has already been satisfied"
|
||
|
|
'var))])))
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
Using \scheme{abstract-module} and \scheme{implement}, we can define
|
||
|
|
mutually recursive and separately compilable modules as follows.
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(abstract-module e (even?) (pred)
|
||
|
|
(define-syntax pred
|
||
|
|
(syntax-rules () [(_ exp) (- exp 1)])))
|
||
|
|
|
||
|
|
(abstract-module o (odd?) ())
|
||
|
|
|
||
|
|
(implement e
|
||
|
|
(import o)
|
||
|
|
(satisfy even?
|
||
|
|
(lambda (x)
|
||
|
|
(or (zero? x) (odd? (pred x))))))
|
||
|
|
|
||
|
|
(implement o
|
||
|
|
(import e)
|
||
|
|
(satisfy odd?
|
||
|
|
(lambda (x) (not (even? x)))))
|
||
|
|
|
||
|
|
(let () (import-only e) (even? 38)) ;=> #t
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{only}{\categorysyntax}{only}
|
||
|
|
\formdef{except}{\categorysyntax}{except}
|
||
|
|
\formdef{add-prefix}{\categorysyntax}{add-prefix}
|
||
|
|
\formdef{drop-prefix}{\categorysyntax}{drop-prefix}
|
||
|
|
\formdef{rename}{\categorysyntax}{rename}
|
||
|
|
\formdef{alias}{\categorysyntax}{alias}
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
\noindent
|
||
|
|
These identifiers are auxiliary keywords for \scheme{import}
|
||
|
|
and \scheme{import-only}.
|
||
|
|
It is a syntax violation to reference these identifiers except in
|
||
|
|
contexts where they are recognized as auxiliary keywords.
|
||
|
|
|
||
|
|
\section{Standalone import and export forms\label{SECTSYNTAXIMPORTEXPORTFORMS}}
|
||
|
|
|
||
|
|
The local import and export forms described in
|
||
|
|
Section~\ref{SECTLIBRARYIMPORTEXPORTFORMS} can be used
|
||
|
|
equally well for and within modules.
|
||
|
|
|
||
|
|
\section{Built-in Modules\label{SECTSYNTAXBUILTINMODULES}}
|
||
|
|
|
||
|
|
Five modules are built-in to {\ChezScheme}: \index{\scheme{scheme} module}\scheme{scheme},
|
||
|
|
\index{\scheme{r5rs} module}\scheme{r5rs}, \index{\scheme{r5rs-syntax} module}\scheme{r5rs-syntax}, \index{\scheme{ieee} module}\scheme{ieee}, and
|
||
|
|
\index{\scheme{$system} module}\scheme{$system}.
|
||
|
|
Each module is immutable, i.e., the exported bindings cannot be
|
||
|
|
altered.
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{scheme}{\categorymodule}{scheme}
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
\noindent
|
||
|
|
\scheme{scheme} contains all user-visible top-level bindings
|
||
|
|
(variables, keywords, and module names) built into {\ChezScheme}.
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{r5rs}{\categorymodule}{r5rs}
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
\noindent
|
||
|
|
\scheme{r5rs} contains all top-level bindings
|
||
|
|
(variables and keywords) defined in the
|
||
|
|
Revised$^5$ Report on Scheme.
|
||
|
|
The bindings exported from \scheme{r5rs} are precisely those that are
|
||
|
|
available within an expression evaluated via \scheme{eval} with the
|
||
|
|
environment specifier returned by
|
||
|
|
\index{\scheme{scheme-report-environment}}\scheme{scheme-report-environment}.
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{r5rs-syntax}{\categorymodule}{r5rs-syntax}
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
\noindent
|
||
|
|
\scheme{r5rs-syntax} contains all top-level keyword bindings
|
||
|
|
defined in the Revised$^5$ Report on Scheme.
|
||
|
|
The bindings exported from \scheme{r5rs-syntax} are precisely those that are
|
||
|
|
available within an expression evaluated via \scheme{eval} with the
|
||
|
|
environment specifier returned by
|
||
|
|
\index{\scheme{null-environment}}\scheme{null-environment}.
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{ieee}{\categorymodule}{ieee}
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
\noindent
|
||
|
|
\scheme{ieee} contains all top-level bindings
|
||
|
|
(variables and keywords) defined in the
|
||
|
|
ANSI/IEEE standard for Scheme.
|
||
|
|
The bindings exported from \scheme{ieee} are precisely those that are
|
||
|
|
available within an expression evaluated via \scheme{eval} with the
|
||
|
|
environment specifier returned by
|
||
|
|
\index{\scheme{ieee-environment}}\scheme{ieee-environment}.
|
||
|
|
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{$system}{\categorymodule}{$system}
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
\noindent
|
||
|
|
\scheme{$system} contains all user-visible top-level bindings built
|
||
|
|
into {\ChezScheme} along with various undocumented system bindings.
|
||
|
|
|
||
|
|
|
||
|
|
\section{Meta Definitions\label{SECTSYNTAXMETA}}
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\noskipentryheader
|
||
|
|
\formdef{meta}{\categorysyntax}{(meta . \var{definition})}
|
||
|
|
\returns unspecified
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
The \scheme{meta} keyword is actually a prefix that can be placed in
|
||
|
|
front of any definition keyword, e.g.,
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(meta define x 3)
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
It tells the expander that any variable definition resulting
|
||
|
|
from the definition is to be an expand-time definition available only
|
||
|
|
to the right-hand sides of other meta definitions and, most importantly,
|
||
|
|
transformer expressions.
|
||
|
|
It is used to define expand-time helpers and other information for use
|
||
|
|
by one or more \scheme{syntax-case} transformers.
|
||
|
|
|
||
|
|
% (module count-let (count let)
|
||
|
|
% (meta define counter 0)
|
||
|
|
% (define-syntax count (lambda (x) counter))
|
||
|
|
% (define-syntax let
|
||
|
|
% (lambda (x)
|
||
|
|
% (import scheme)
|
||
|
|
% (set! counter (+ counter 1))
|
||
|
|
% (syntax-case x () [(_ . stuff) #'(let . stuff)]))))
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(module M (helper1 a b)
|
||
|
|
(meta define helper1
|
||
|
|
(lambda (---)
|
||
|
|
---))
|
||
|
|
(meta define helper2
|
||
|
|
(lambda (---)
|
||
|
|
--- (helper2 ---) ---))
|
||
|
|
(define-syntax a
|
||
|
|
(lambda (x)
|
||
|
|
--- (helper1 ---) ---))
|
||
|
|
(define-syntax b
|
||
|
|
(lambda (x)
|
||
|
|
--- (helper1 ---) ---
|
||
|
|
--- (helper2 ---) ---)))
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
The right-hand-side expressions of a syntax definition or meta definition
|
||
|
|
can refer only to identifiers whose values are already available in the
|
||
|
|
compile-time environment.
|
||
|
|
Because of the left-to-right expansion order for \scheme{library},
|
||
|
|
\scheme{module}, \scheme{lambda}, and similar bodies, this implies a
|
||
|
|
semantics similar to \scheme{let*} for a sequence of meta definitions,
|
||
|
|
in which each right-hand side can refer only to the variables defined
|
||
|
|
earlier in the sequence.
|
||
|
|
An exception is that the right-hand side of a meta definition can refer
|
||
|
|
to its own name as long as the reference is not evaluated until after
|
||
|
|
the value of the expression has been computed.
|
||
|
|
This permits meta definitions to be self-recursive but not mutually
|
||
|
|
recursive.
|
||
|
|
The right-hand side of a meta definition can, however, build syntax
|
||
|
|
objects containing occurrences of any identifiers defined in the body
|
||
|
|
in which the meta definition appears.
|
||
|
|
|
||
|
|
Meta definitions propagate through macro expansion, so one can write,
|
||
|
|
for example:
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(module (a)
|
||
|
|
(meta define-record foo (x))
|
||
|
|
(define-syntax a
|
||
|
|
(let ([q (make-foo #''q)])
|
||
|
|
(lambda (x) (foo-x q)))))
|
||
|
|
a ;=> q
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
where define-record is a macro that expands into a set of defines.
|
||
|
|
|
||
|
|
It is also sometimes convenient to write
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(meta begin defn \dots)
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
or
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(meta module {exports} defn \dots)
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
or
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(meta include "\var{path}")
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
to create groups of meta bindings.
|
||
|
|
|
||
|
|
\section{Conditional expansion\label{SECTSYNTAXMETACOND}}
|
||
|
|
|
||
|
|
Expansion-time decisions can be made via \scheme{meta-cond}, which is
|
||
|
|
similar to \scheme{cond} but evaluates the test expressions at
|
||
|
|
expansion time and can be used in contexts where definitions are
|
||
|
|
expected as well as in expression contexts.
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{meta-cond}{\categorysyntax}{(meta-cond \var{clause_1} \var{clause_2} \dots)}
|
||
|
|
\returns see below
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
Each \var{clause} but the last must take the form:
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(\var{test} \var{expr_1} \var{expr_2} \dots)
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
The last may take the same form or be an \scheme{else} clause of the form:
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(\var{else} \var{expr_1} \var{expr_2} \dots)
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
During expansion, the \var{test} expressions are evaluated in order until
|
||
|
|
one evaluates to a true value or until all of the tests have been
|
||
|
|
evaluated.
|
||
|
|
If a \var{test} evaluates to a true value, the \scheme{meta-cond} form
|
||
|
|
expands to a \scheme{begin} form containing the corresponding
|
||
|
|
expressions \scheme{\var{expr_1} \var{expr_2} \dots}.
|
||
|
|
If no \var{test} evaluates to a true value and an \scheme{else} clause
|
||
|
|
is present, the \scheme{meta-cond} form expands to a \scheme{begin} form
|
||
|
|
containing the expressions \scheme{\var{expr_1} \var{expr_2} \dots} from
|
||
|
|
the \scheme{else} clause.
|
||
|
|
Otherwise the \scheme{meta-cond} expression expands into a call to
|
||
|
|
the \scheme{void} procedure.
|
||
|
|
|
||
|
|
\scheme{meta-cond} might be defined as follows.
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(define-syntax meta-cond
|
||
|
|
(syntax-rules ()
|
||
|
|
[(_ [a0 a1 a2 ...] [b0 b1 b2 ...] ...)
|
||
|
|
(let-syntax ([expr (cond
|
||
|
|
[a0 (identifier-syntax (begin a1 a2 ...))]
|
||
|
|
[b0 (identifier-syntax (begin b1 b2 ...))]
|
||
|
|
...)])
|
||
|
|
expr)]))
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
\scheme{meta-cond} is used to choose, at expansion time, from among a
|
||
|
|
set of possible forms.
|
||
|
|
For example, one might have safe (error-checking) and unsafe
|
||
|
|
(non-error-checking) versions of a procedure and decide which to
|
||
|
|
call based on the compile-time optimization level, as shown
|
||
|
|
below.
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(meta-cond
|
||
|
|
[(= (optimize-level) 3) (unsafe-frob x)]
|
||
|
|
[else (safe-frob x)])
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
\section{Aliases\label{SECTSYNTAXALIAS}}
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\noskipentryheader
|
||
|
|
\formdef{alias}{\categorysyntax}{(alias \var{id_1} \var{id_2})}
|
||
|
|
\returns unspecified
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
\scheme{alias} is a definition and can appear anywhere
|
||
|
|
other definitions can appear.
|
||
|
|
It is used to transfer the binding from one identifier to
|
||
|
|
another.
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(let ([x 3]) (alias y x) (set! y 4) (list x y)) ;=> (4 4)
|
||
|
|
|
||
|
|
(module lisp (if)
|
||
|
|
(module (scheme:if)
|
||
|
|
(import scheme)
|
||
|
|
(alias scheme:if if))
|
||
|
|
(define-syntax if
|
||
|
|
(syntax-rules ()
|
||
|
|
[(_ e_1 e_2 e_3)
|
||
|
|
(scheme:if (not (memq e_1 '(#f ()))) e_2 e_3)])))
|
||
|
|
(define (length ls)
|
||
|
|
(import lisp)
|
||
|
|
(if ls (+ (length (cdr ls)) 1) 0))
|
||
|
|
(length '(a b c)) ;=> 3
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
Because of left-to-right expansion order, aliases should appear after
|
||
|
|
the definition of the right-hand-side identifier, e.g.:
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(let ()
|
||
|
|
(import-only (chezscheme))
|
||
|
|
(define y 3)
|
||
|
|
(alias x y)
|
||
|
|
x) ;=> 3
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
rather than:
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(let ()
|
||
|
|
(import-only (chezscheme))
|
||
|
|
(alias x y)
|
||
|
|
(define y 3)
|
||
|
|
x) ;=> \var{exception: unbound identifier}
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
|
||
|
|
\section{Annotations\label{SECTSYNTAXANNOTATIONS}}
|
||
|
|
|
||
|
|
\index{annotations}%
|
||
|
|
When source code is read from a file by \scheme{load},
|
||
|
|
\scheme{compile-file}, or variants of these, such as
|
||
|
|
\scheme{load-library}, the reader attaches \emph{annotations} to each
|
||
|
|
object read from the file.
|
||
|
|
These annotations identify the file and the position of the object within
|
||
|
|
the file.
|
||
|
|
Annotations are tracked through the compilation process and associated
|
||
|
|
with compiled code at run time.
|
||
|
|
The expander and compiler use the annotations to produce syntax errors
|
||
|
|
and compiler warnings that identify the location of the offending form,
|
||
|
|
and the inspector uses them to identify the locations of calls and
|
||
|
|
procedure definitions.
|
||
|
|
The compiler and run time also use annotations to associate source
|
||
|
|
positions with profile counts.
|
||
|
|
|
||
|
|
While these annotations are usually maintained ``behind the scenes,''
|
||
|
|
the programmer can manipulate them directly via a set
|
||
|
|
of routines for creating and accessing annotations.
|
||
|
|
|
||
|
|
Annotations are values of a type distinct from other types and have
|
||
|
|
four components: an expression, possibly with annotated subexpressions,
|
||
|
|
a \emph{source object}, a stripped version of the expression, and
|
||
|
|
usage options.
|
||
|
|
Annotations can be created via
|
||
|
|
\index{\scheme{make-annotation}}\scheme{make-annotation}, which has
|
||
|
|
three required arguments corresponding to the first three components
|
||
|
|
and an optional fourth argument corresponding to the fourth component.
|
||
|
|
The second argument must be a source object, and the third argument should be a
|
||
|
|
stripped version of the first argument, i.e., equivalent to the first
|
||
|
|
argument with each annotation replaced by its expression component.
|
||
|
|
An annotation is essentially equivalent to its stripped component as a
|
||
|
|
representation of source code, with the source information attached and
|
||
|
|
available to the expander or evaluator.
|
||
|
|
The optional fourth argument, if present, must be an enumeration set over
|
||
|
|
the symbols \scheme{debug} and \scheme{profile} and defaults to an
|
||
|
|
enumeration set containing both \scheme{debug} and \scheme{profile}.
|
||
|
|
|
||
|
|
Annotations marked \scheme{debug} are used for compile-time error
|
||
|
|
reporting and run-time error reporting and inspection; annotations
|
||
|
|
marked \scheme{profile} are used for profiling.
|
||
|
|
Annotations created by the Scheme reader are always marked both
|
||
|
|
\scheme{debug} and \scheme{profile}, but other readers and parsers
|
||
|
|
might choose to mark some annotations only \scheme{debug} or only
|
||
|
|
\scheme{profile}.
|
||
|
|
In particular, it might be useful to annotate multiple
|
||
|
|
expressions in the output of a parser with the same source object
|
||
|
|
for debugging purposes and mark only one of them \scheme{profile}
|
||
|
|
to avoid duplicate counts.
|
||
|
|
It might also be useful to mark no expressions \scheme{profile} and
|
||
|
|
instead introduce explicit \scheme{profile} forms
|
||
|
|
(Section~\ref{SECTMISCPROFILE}) to identify the set of source
|
||
|
|
locations to be profiled.
|
||
|
|
|
||
|
|
\index{source objects}%
|
||
|
|
Source objects are also values of a type distinct from other types and
|
||
|
|
also have three or five components: a \emph{source-file descriptor} (sfd),
|
||
|
|
a beginning file position (bfp), an ending file position (efp),
|
||
|
|
an optional beginning line, and an optional beginning
|
||
|
|
column. The sfd identifies the file from which an expression is read and the
|
||
|
|
bfp and efp identify the range of character positions occupied by the object
|
||
|
|
in the file, with the bfp being inclusive and the efp being exclusive.
|
||
|
|
The line and column are either both numbers or both not present.
|
||
|
|
A source object can be created via
|
||
|
|
\index{\scheme{make-source-object}}\scheme{make-source-object}, which
|
||
|
|
takes either three or five arguments corresponding to these components.
|
||
|
|
The first argument must be a source-file descriptor, the second and
|
||
|
|
third must be nonnegative exact integers, the second must not be
|
||
|
|
greater than the third, and the fourth and fifth (if provided) must
|
||
|
|
be positive exact integers.
|
||
|
|
|
||
|
|
\index{source-file descriptors}%
|
||
|
|
Source-file descriptors are also values of a type distinct
|
||
|
|
from all other types and have two components: the file's path,
|
||
|
|
represented by a string, and a checksum, represented by a number.
|
||
|
|
The path might or might not be an absolute path depending on how
|
||
|
|
the file's path was specified when the source-file descriptor was
|
||
|
|
created.
|
||
|
|
The checksum is computed based on the file's length and contents
|
||
|
|
when the file is created and checked by tools that look for the
|
||
|
|
source file to make sure that the proper file has been found and
|
||
|
|
has not been modified.
|
||
|
|
Source-file descriptors can be created with
|
||
|
|
\index{\scheme{make-source-file-descriptor}}\scheme{make-source-file-descriptor},
|
||
|
|
which accepts two arguments: a string naming the path and a binary
|
||
|
|
input port, along with an optional third boolean argument, \var{reset?},
|
||
|
|
which defaults to false.
|
||
|
|
\scheme{make-source-file-descriptor} computes a checksum based on
|
||
|
|
the contents of the port, starting at its current position.
|
||
|
|
It resets the port, using \scheme{set-port-position!}, after computing
|
||
|
|
the checksum if \var{reset?} is true; otherwise, it leaves the
|
||
|
|
port at end-of-file.
|
||
|
|
|
||
|
|
The procedures that create, check for, and access annotations,
|
||
|
|
source objects, and source-file descriptors are summarized below
|
||
|
|
and described in more detail later in this section.
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(make-annotation \var{obj} \var{source-object} \var{obj}) ;-> \var{annotation}
|
||
|
|
(annotation? \var{obj}) ;-> \var{boolean}
|
||
|
|
(annotation-expression \var{annotation}) ;-> \var{obj}
|
||
|
|
(annotation-source \var{annotation}) ;-> \var{source-object}
|
||
|
|
(annotation-stripped \var{annotation}) ;-> \var{obj}
|
||
|
|
|
||
|
|
(make-source-object \var{sfd} \var{uint} \var{uint}) ;-> \var{source-object}
|
||
|
|
(make-source-object \var{sfd} \var{uint} \var{uint} \var{uint} \var{uint}) ;-> \var{source-object}
|
||
|
|
(source-object? \var{obj}) ;-> \var{boolean}
|
||
|
|
(source-object-sfd \var{source-object}) ;-> \var{sfd}
|
||
|
|
(source-object-bfp \var{source-object}) ;-> \var{uint}
|
||
|
|
(source-object-efp \var{source-object}) ;-> \var{uint}
|
||
|
|
(source-object-line \var{source-object}) ;-> \var{uint} or #f
|
||
|
|
(source-object-column \var{source-object}) ;-> \var{uint} or #f
|
||
|
|
|
||
|
|
(make-source-file-descriptor \var{string} \var{binary-input-port}) ;-> \var{sfd}
|
||
|
|
(make-source-file-descriptor \var{string} \var{binary-input-port} \var{reset?}) ;-> \var{sfd}
|
||
|
|
(source-file-descriptor? \var{obj}) ;-> \var{boolean}
|
||
|
|
(source-file-descriptor-checksum \var{sfd}) ;-> \var{obj}
|
||
|
|
(source-file-descriptor-path \var{sfd}) ;-> \var{obj}
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
A program might open a source file with
|
||
|
|
\scheme{open-file-input-port}, create an sfd using
|
||
|
|
\index{\scheme{make-source-file-descriptor}}\scheme{make-source-file-descriptor},
|
||
|
|
create a textual port from the binary port using transcoded-port, and
|
||
|
|
create source objects and annotations for each of the objects it reads
|
||
|
|
from the file.
|
||
|
|
If a custom reader is not required, the Scheme
|
||
|
|
reader can be used to read annotations via the
|
||
|
|
\index{\scheme{get-datum/annotations}}\scheme{get-datum/annotations}
|
||
|
|
procedure:
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(get-datum/annotations \var{textual-input-port} \var{sfd} \var{uint}) ;-> \var{obj}, \var{uint}
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
\scheme{get-datum/annotations} is like \scheme{get-datum} but instead of returning
|
||
|
|
a plain datum, it returns an annotation encapsulating a datum (possibly with nested
|
||
|
|
annotations), a source object, and the plain (stripped) datum.
|
||
|
|
It also returns a second value, the position of the first character beyond the
|
||
|
|
object in the file.
|
||
|
|
Character positions are accepted and returned by
|
||
|
|
\scheme{get-datum/annotations} so that the textual port need not support
|
||
|
|
\scheme{port-position} and need not report positions in characters
|
||
|
|
if it does support \scheme{port-position}.
|
||
|
|
(Positions are usually reported in bytes.)
|
||
|
|
The bfp and efp positions recorded in the annotations returned by
|
||
|
|
\scheme{get-datum/annotations} are correct only if the positions supplied
|
||
|
|
to it are correct.
|
||
|
|
|
||
|
|
Once read, an annotation can be passed to the expander, interpreter, or
|
||
|
|
compiler.
|
||
|
|
The procedures \scheme{eval}, \scheme{expand}, \scheme{interpret},
|
||
|
|
and \scheme{compile} all accept annotated or unannotated input.
|
||
|
|
|
||
|
|
Two additional procedures complete the set of annotation-related primitives:
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(open-source-file \var{sfd}) ;-> #f or \var{port}
|
||
|
|
(syntax->annotation \var{obj}) ;-> #f or \var{annotation}
|
||
|
|
\endschemedisplay
|
||
|
|
|
||
|
|
\index{\scheme{open-source-file}}\scheme{open-source-file} attempts to
|
||
|
|
locate and open the source file identified by \var{sfd}.
|
||
|
|
It returns a textual input port, positioned at the beginning of the file,
|
||
|
|
if successful, and \scheme{#f} otherwise.
|
||
|
|
|
||
|
|
\index{\scheme{syntax->annotation}}\scheme{syntax->annotation} accepts
|
||
|
|
a syntax object.
|
||
|
|
If the syntax object's expression is annotated, it returns the
|
||
|
|
annotation; otherwise, it returns \scheme{#f}.
|
||
|
|
It can be used by a macro to extract source information, when
|
||
|
|
available, from an input form.
|
||
|
|
|
||
|
|
The procedure \scheme{datum->syntax} accepts either an
|
||
|
|
annotated or unannotated input datum.
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{make-annotation}{\categoryprocedure}{(make-annotation \var{obj} \var{source-object} \var{stripped-obj})}
|
||
|
|
\formdef{make-annotation}{\categoryprocedure}{(make-annotation \var{obj} \var{source-object} \var{stripped-obj} \var{options})}
|
||
|
|
\returns an annotation
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
The annotation is formed with \var{obj} as its expression component,
|
||
|
|
\var{source-object} as its source-object component, and \var{stripped-obj}
|
||
|
|
as its stripped component.
|
||
|
|
\var{obj} should represent an expression, possibly with embedded
|
||
|
|
annotations.
|
||
|
|
\var{stripped-obj} should be a stripped version of \var{obj}, i.e.,
|
||
|
|
equivalent to \var{obj} with each annotation replaced by its
|
||
|
|
expression component.
|
||
|
|
\var{options}, if present must be an enumeration set over
|
||
|
|
the symbols \scheme{debug} and \scheme{profile}, and defaults to an
|
||
|
|
enumeration set containing both \scheme{debug} and \scheme{profile}.
|
||
|
|
Annotations marked \scheme{debug} are used for compile-time error
|
||
|
|
reporting and run-time error reporting and inspection; annotations
|
||
|
|
marked \scheme{profile} are used for profiling.
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{annotation?}{\categoryprocedure}{(annotation? \var{obj})}
|
||
|
|
\returns \scheme{#t} if \var{obj} is an annotation, otherwise \scheme{#f}
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{annotation-expression}{\categoryprocedure}{(annotation-expression \var{annotation})}
|
||
|
|
\returns the expression component of \var{annotation}
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{annotation-source}{\categoryprocedure}{(annotation-source \var{annotation})}
|
||
|
|
\returns the source-object component of \var{annotation}
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{annotation-stripped}{\categoryprocedure}{(annotation-stripped \var{annotation})}
|
||
|
|
\returns the stripped component of \var{annotation}
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{annotation-options}{\categoryprocedure}{(annotation-options \var{annotation})}
|
||
|
|
\returns the options enumeration set of \var{annotation}
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{make-source-object}{\categoryprocedure}{(make-source-object \var{sfd} \var{bfp} \var{efp})}
|
||
|
|
\formdef{make-source-object}{\categoryprocedure}{(make-source-object \var{sfd} \var{bfp} \var{efp} \var{line} \var{column})}
|
||
|
|
\returns a source object
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
\var{sfd} must be a source-file descriptor.
|
||
|
|
\var{bfp} and \var{efp} must be exact nonnegative integers, and \var{bfp}
|
||
|
|
should not be greater than \var{efp}.
|
||
|
|
\var{line} and \var{column} must be exact positive integers.
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{source-object?}{\categoryprocedure}{(source-object? \var{obj})}
|
||
|
|
\returns \scheme{#t} if \var{obj} is a source object, otherwise \scheme{#f}
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{source-object-sfd}{\categoryprocedure}{(source-object-sfd \var{source-object})}
|
||
|
|
\returns the sfd component of \var{source-object}
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{source-object-bfp}{\categoryprocedure}{(source-object-bfp \var{source-object})}
|
||
|
|
\returns the bfp component of \var{source-object}
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{source-object-efp}{\categoryprocedure}{(source-object-efp \var{source-object})}
|
||
|
|
\returns the efp component of \var{source-object}
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{source-object-line}{\categoryprocedure}{(source-object-line \var{source-object})}
|
||
|
|
\returns the line component of \var{source-object} if present, otherwise \scheme{#f}
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{source-object-column}{\categoryprocedure}{(source-object-column \var{source-object})}
|
||
|
|
\returns the column component of \var{source-object} if present, otherwise \scheme{#f}
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{current-make-source-object}{\categorythreadparameter}{current-make-source-object}
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
\noindent
|
||
|
|
\scheme{current-make-source-object} is used by the reader to construct
|
||
|
|
a source object for an annotation. \scheme{current-make-source-object}
|
||
|
|
is initially bound to \scheme{make-source-object}, and the reader always
|
||
|
|
calls the function bound to the parameter with three arguments.
|
||
|
|
|
||
|
|
Adjust this parameter to, for example, eagerly convert a position integer
|
||
|
|
to a file-position object, instead of delaying the conversion to
|
||
|
|
\scheme{locate-source}.
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{make-source-file-descriptor}{\categoryprocedure}{(make-source-file-descriptor \var{string} \var{binary-input-port})}
|
||
|
|
\formdef{make-source-file-descriptor}{\categoryprocedure}{(make-source-file-descriptor \var{string} \var{binary-input-port} \var{reset?})}
|
||
|
|
\returns a source-file descriptor
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
To compute the checksum encapsulated in the source-file descriptor,
|
||
|
|
this procedure must read all of the data from
|
||
|
|
\var{binary-input-port}.
|
||
|
|
If \var{reset?} is present and \scheme{#t}, the port is reset to its
|
||
|
|
original position, as if via \scheme{port-position}.
|
||
|
|
Otherwise, it is left pointing at end-of-file.
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{source-file-descriptor?}{\categoryprocedure}{(source-file-descriptor? \var{obj})}
|
||
|
|
\returns \scheme{#t} if \var{obj} is a source-file descriptor, otherwise \scheme{#f}
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{source-file-descriptor-checksum}{\categoryprocedure}{(source-file-descriptor-checksum \var{sfd})}
|
||
|
|
\returns the checksum component of \var{sfd}
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{source-file-descriptor-path}{\categoryprocedure}{(source-file-descriptor-path \var{sfd})}
|
||
|
|
\returns the path component of \var{sfd}
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
\var{sfd} must be a source-file descriptor.
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{source-file-descriptor}{\categoryprocedure}{(source-file-descriptor \var{path} \var{checksum})}
|
||
|
|
\returns a new source-file-descriptor
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
\var{path} must be a string, and \var{checksum} must be an exact nonnegative integer.
|
||
|
|
This procedure can be used to construct custom source-file descriptors or to reconstitute
|
||
|
|
source-file descriptors from the \var{path} and \var{checksum} components.
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{annotation-option-set}{\categorysyntax}{(annotation-option-set \var{symbol} \dots)}
|
||
|
|
\returns an annotation-options enumeration set
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
\noindent
|
||
|
|
Annotation-options enumeration sets may be passed to \scheme{make-annotation} to
|
||
|
|
control whether the annotation is used for debugging, profiling, both, or neither.
|
||
|
|
Accordingly, each \var{symbol} must be either \var{debug} or \scheme{profile}.
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{syntax->annotation}{\categoryprocedure}{(syntax->annotation \var{obj})}
|
||
|
|
\returns an annotation or \scheme{#f}
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
If \var{obj} is an annotation or syntax-object encapsulating an annotation,
|
||
|
|
the annotation is returned.
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{get-datum/annotations}{\categoryprocedure}{(get-datum/annotations \var{textual-input-port} \var{sfd} \var{bfp})}
|
||
|
|
\returns see below
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
\var{sfd} must be a source-file descriptor.
|
||
|
|
\var{bfp} must be an exact nonnegative integer and should be the
|
||
|
|
character position of the next character to be read from
|
||
|
|
\var{textual-input-port}.
|
||
|
|
|
||
|
|
This procedure returns two values: an annotated object and an ending
|
||
|
|
file position.
|
||
|
|
In most cases, \var{bfp} should be 0 for the first call
|
||
|
|
to \scheme{get-datum/annotation} at the start of a file,
|
||
|
|
and it should be the second return value of the preceding
|
||
|
|
call to \scheme{get-datum/annotation} for each subsequent
|
||
|
|
call.
|
||
|
|
This protocol is necessary to handle files containing multiple-byte
|
||
|
|
characters, since file positions do not necessarily correspond
|
||
|
|
to character positions.
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{open-source-file}{\categoryprocedure}{(open-source-file \var{sfd})}
|
||
|
|
\returns a port or \scheme{#f}
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
\var{sfd} must be a source-file descriptor.
|
||
|
|
This procedure attempts to locate and open the source file identified
|
||
|
|
by \var{sfd}.
|
||
|
|
It returns a textual input port, positioned at the beginning of the file,
|
||
|
|
if successful, and \scheme{#f} otherwise.
|
||
|
|
It can fail even if a file with the correct name exists in one of
|
||
|
|
the source directories when the file's checksum does not match the
|
||
|
|
checksum recorded in \var{sfd}.
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{locate-source}{\categoryprocedure}{(locate-source \var{sfd} \var{pos})}
|
||
|
|
\formdef{locate-source}{\categoryprocedure}{(locate-source \var{sfd} \var{pos} \var{use-cache?})}
|
||
|
|
\returns see below
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
\var{sfd} must be a source-file descriptor, and \var{pos} must be an
|
||
|
|
exact nonnegative integer.
|
||
|
|
|
||
|
|
This procedure either uses cached information from a previous
|
||
|
|
request for \var{sfd} (only when \var{use-cache?} is provided as true)
|
||
|
|
or attempts to locate and open the source file identified
|
||
|
|
by \var{sfd}.
|
||
|
|
If successful, it returns three values: a string \var{path}, an exact
|
||
|
|
nonnegative integer \var{line}, and an exact nonnegative integer \var{char}
|
||
|
|
representing the absolute pathname, line, and character position within
|
||
|
|
the line represented by the specified source-file descriptor and file
|
||
|
|
position.
|
||
|
|
If unsuccessful, it returns zero values.
|
||
|
|
It can fail even if a file with the correct name exists in one of
|
||
|
|
the source directories when the file's checksum does not match the
|
||
|
|
checksum recorded in \var{sfd}.
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{locate-source-object-source}{\categoryprocedure}{(locate-source-object-source \var{source-object} \var{get-start?} \var{use-cache?})}
|
||
|
|
\returns see below
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
This procedure is similar to \scheme{locate-source}, but instead of
|
||
|
|
taking an sfd and a position, it takes a source object plus a request
|
||
|
|
for either the start or end location.
|
||
|
|
|
||
|
|
If \var{get-start?} is true and \var{source-object} has a line and column,
|
||
|
|
this procedure returns the path in
|
||
|
|
\var{source-objects}'s sfd, \var{source-object}'s line, and
|
||
|
|
\var{source-objects}'s column.
|
||
|
|
|
||
|
|
If \var{source-object} has no line and column, then
|
||
|
|
this procedure calls \scheme{locate-source} on
|
||
|
|
\var{source-object}'s sfd, either \var{source-object}'s bfp or efp
|
||
|
|
depending on \var{get-start?}, and \var{use-cache?}.
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{current-locate-source-object-source}{\categorythreadparameter}{current-locate-source-object-source}
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
\noindent
|
||
|
|
|
||
|
|
\scheme{current-locate-source-object-source} determines the
|
||
|
|
source-location lookup function that is used by the system to report
|
||
|
|
errors based on source objects. This parameter is initially bound to
|
||
|
|
\scheme{locate-source-object-object}.
|
||
|
|
|
||
|
|
Adjust this parameter to control the way that source locations are
|
||
|
|
extracted from source objects, possibly using recorded information,
|
||
|
|
caches, and the filesystem in a way different from
|
||
|
|
\scheme{locate-source-object-object}.
|
||
|
|
|
||
|
|
|
||
|
|
\section{Source Tables\label{SECTSYNTAXSOURCETABLES}}
|
||
|
|
|
||
|
|
Source tables provide an efficient way to associate information
|
||
|
|
with source objects both in memory and on disk, such as the coverage information
|
||
|
|
saved to \scheme{.covin} files when
|
||
|
|
\index{\scheme{generate-covin-files}}\scheme{generate-covin-files} is
|
||
|
|
set to \scheme{#t}
|
||
|
|
and the profile counts associated with source objects by
|
||
|
|
\index{\scheme{with-profile-tracker}}\scheme{with-profile-tracker}
|
||
|
|
(Section~\ref{SECTMISCPROFILE}).
|
||
|
|
|
||
|
|
Source tables are manipulated via hashtable-like accessors and setters
|
||
|
|
(Section~\ref{SECTMISCHASHTABLES}, {\TSPLFOUR} Section~\ref{TSPL:SECTHASHTABLES}), e.g.,
|
||
|
|
\index{\scheme{source-table-ref}}\scheme{source-table-ref} and \index{\scheme{source-table-set!}}\scheme{source-table-set!}.
|
||
|
|
They can be saved to files via
|
||
|
|
\index{\scheme{put-source-table}}\scheme{put-source-table}
|
||
|
|
and restored via
|
||
|
|
\index{\scheme{get-source-table!}}\scheme{get-source-table!}.
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{make-source-table}{\categoryprocedure}{(make-source-table)}
|
||
|
|
\returns a source table
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
A source table contains associations between source objects and arbitrary
|
||
|
|
values. For purposes of the source-table operations described below, two
|
||
|
|
source objects are the same if they have the same source-file descriptor,
|
||
|
|
equal beginning file positions and equal ending file positions.
|
||
|
|
Two source-file descriptors are the same if they have the same path and
|
||
|
|
checksum.
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{source-table?}{\categoryprocedure}{(source-table? \var{obj})}
|
||
|
|
\returns \scheme{#t} if \var{obj} is a source-table; \scheme{#f} otherwise
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{source-table-set!}{\categoryprocedure}{(source-table-set! \var{source-table} \var{source-object} \var{obj})}
|
||
|
|
\returns unspecified
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
\scheme{source-table-set!} associates \var{source-object}
|
||
|
|
with \var{obj} in \var{source-table}, replacing the
|
||
|
|
existing association, if any.
|
||
|
|
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{source-table-ref}{\categoryprocedure}{(source-table-ref \var{source-table} \var{source-object} \var{default})}
|
||
|
|
\returns see below
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
\noindent
|
||
|
|
\var{default} may be any Scheme value.
|
||
|
|
|
||
|
|
\scheme{source-table-ref} returns the value
|
||
|
|
associated with \var{source-object} in \var{source-table}.
|
||
|
|
If no value is associated with \var{source-object} in \var{source-table},
|
||
|
|
\scheme{source-table-ref} returns \var{default}.
|
||
|
|
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{source-table-contains?}{\categoryprocedure}{(source-table-contains? \var{source-table} \var{source-object})}
|
||
|
|
\returns \scheme{#t} if an association for \var{source-object} exists in \var{source-table}, \scheme{#f} otherwise
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{source-table-cell}{\categoryprocedure}{(source-table-cell \var{source-table} \var{source-object} \var{default})}
|
||
|
|
\returns a pair (see below)
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
\noindent
|
||
|
|
\var{default} may be any Scheme value.
|
||
|
|
|
||
|
|
If no value is associated with \var{source-object} in \var{source-table},
|
||
|
|
\scheme{source-table-cell} modifies \var{source-table} to associate \var{source-object} with
|
||
|
|
\var{default}.
|
||
|
|
Regardless, it returns a pair whose car is \var{source-object} and whose cdr is
|
||
|
|
the associated value.
|
||
|
|
Changing the cdr of this pair effectively updates the table to
|
||
|
|
associate \var{source-object} with a new value.
|
||
|
|
The car field of the pair should not be modified.
|
||
|
|
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{source-table-delete!}{\categoryprocedure}{(source-table-delete! \var{source-table} \var{source-object})}
|
||
|
|
\returns unspecified
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
\scheme{source-table-delete!} drops the association
|
||
|
|
for \var{source-object} from \var{source-table}, if
|
||
|
|
one exists.
|
||
|
|
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{source-table-size}{\categoryprocedure}{(source-table-size \var{source-table})}
|
||
|
|
\returns the number of entries in \var{source-table}
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{put-source-table}{\categoryprocedure}{(put-source-table \var{textual-output-port} \var{source-table})}
|
||
|
|
\returns unspecified
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
\noindent
|
||
|
|
This procedure writes a representation of the information stored in \var{source-table} to the port.
|
||
|
|
|
||
|
|
|
||
|
|
%----------------------------------------------------------------------------
|
||
|
|
\entryheader
|
||
|
|
\formdef{get-source-table!}{\categoryprocedure}{(get-source-table! \var{textual-input-port} \var{source-table})}
|
||
|
|
\formdef{get-source-table!}{\categoryprocedure}{(get-source-table! \var{textual-input-port} \var{source-table} \var{combine})}
|
||
|
|
\returns unspecified
|
||
|
|
\listlibraries
|
||
|
|
\endentryheader
|
||
|
|
|
||
|
|
The port must be positioned at a representation of source-table
|
||
|
|
information written by some previous call to \scheme{put-source-table},
|
||
|
|
which reads the information and merges it into \scheme{source-table}.
|
||
|
|
|
||
|
|
If present and non-false, \var{combine} must be a procedure and
|
||
|
|
should accept two arguments.
|
||
|
|
It is called whenever associations for the same source object are
|
||
|
|
present both in \var{source-table} and in the information read from
|
||
|
|
the port.
|
||
|
|
In this case, \var{combine} is passed two arguments: the associated
|
||
|
|
value from \var{source-table} and the associated value from the
|
||
|
|
port (in that order) and must return one value, which is recorded
|
||
|
|
as the new associated value for the source object in \var{source-table}.
|
||
|
|
|
||
|
|
If \var{combine} is not present, \var{combine} is \scheme{#f}, or
|
||
|
|
no association for a source object read from the port already exists
|
||
|
|
in \var{source-table}, the value read from the port is recorded as
|
||
|
|
the associated value of the source object in \var{source-table}.
|
||
|
|
|
||
|
|
\schemedisplay
|
||
|
|
(define st (make-source-table))
|
||
|
|
(call-with-port (open-input-file "profile.out1")
|
||
|
|
(lambda (ip) (get-source-table! ip st)))
|
||
|
|
(call-with-port (open-input-file "profile.out2")
|
||
|
|
(lambda (ip) (get-source-table! ip st +)))
|
||
|
|
\endschemedisplay
|