racket/collects/eopl/doc.txt

124 lines
3.8 KiB
Plaintext

The _Essentials of Programming Languages_ (a.k.a _EoPL_) language in
DrScheme provides all of the functions of R5RS, plus the forms and
procedures described below. It is intended for use with the textbook
Essentials of Programming Languages, Second Edition
Friedman, Wand, and Haynes
MIT Press, 2001
Differences from the book:
* Datatypes must be defined before they are used in `cases'
expressions. This constraint enables better and earlier error
reporting.
Some examples in the book's code (or at least the code distributed
for the book) must be changed by moving datatype definitions
earlier.
* The sllgen: functions have been changed to syntactic forms. This
change is also related to better error reporting.
All examples in the book work work with the sllgen: forms.
----------------------------------------
> (define-datatype id predicate-id (variant-id (field-id predicate-expr) ...) ...)
Defines the datatype `id' and a function `predicate-id' that returns
#t for instances of the datatype, and #f for any other value.
Each `variant-id' is defined as a constructor function that creates
an instance of the datatype; the constructor takes as many arguments
as the variant's `field-id's, and each argument is checked by
applying the function produced by the variant's `predicate-expr'.
In DrScheme v209 and older, when constructor-based printing was
used, variant instances were printed with a `make-' prefix before
the variant name. Thus, for compatibility, in addition to
`variant-id', `make-variant-id' is also defined for each
`variant-id' (to the same constructor as `variant-id').
> (cases datatype-id expr (variant-id (field-id ...) result-expr ...) ...)
> (cases datatype-id expr (variant-id (field-id ...) result-expr ...) ... (else result-expr ...))
Branches on the datatype instance produced by `expr', which must be
an instance of the specified `datatype-id' (previously defined with
`define-datatype').
> sllgen:make-string-scanner
> sllgen:make-string-parser
> sllgen:make-stream-parser
> sllgen:make-define-datatypes
> sllgen:show-define-datatypes
> sllgen:list-define-datatypes
Defined in the EoPL textbook's Appendix A. However, the DrScheme
versions are syntactic forms, instead of procedures, and the
arguments must be either quoted literal tables or identifiers that
are defined (at the top level) to quoted literal tables.
> sllgen:make-rep-loop
Defined in the EoPL textbook's Appendix A (and still a function).
> eopl:error
As in the book.
> eopl:printf
> eopl:pretty-print
Same as MzScheme's `printf' and `pretty-print'.
> list-of
> always?
As in the book.
> empty
The empty list.
> (time expr)
Evaluates `expr', and prints timing information before returning the
result.
> (collect-garbage)
Performs a garbage collection (useful for repeatable timings).
> (trace id ...)
> (untrace id ...)
For debugging: `trace' redefines each `id' at the top level (bound
to a procedure) so that it prints arguments on entry and results on
exit. `untrace' reverses the action of `trace' for the given `id's.
Tracing a function causes tail-calls in the original function to
become non-tail calls.
> (provide provide-spec ...)
Useful only with a module that uses _(lib "eopl.ss" "eopl")_ as a
language: exports identifiers from the module. See the MzScheme
manual for information on `provided-spec'.
> eopl:error-stop
Defined only in the top-level namespace (i.e., not in a module);
mutate this variable to install an exception-handling
thunk. Typically, the handler thunk escapes through a continuation.
The "eopl.ss" module sets this variable to #f in the current
namespace when it executes.
> (install-eopl-exception-handler)
Sets MzScheme's exception handler to one that checks
`eopl:error-stop'.
The "eopl.ss" module calls this function when it executes.