[R6RS] R6RS core/library strawman proposal
Anton van Straaten
anton at appsolutions.com
Wed Mar 22 10:45:41 EST 2006
I'm sure this is being posted too late to be read properly before our
call today. However, if you have a chance to read the 3-minute intro
below, and take a look at the syntax examples at the beginning of the
proposal proper, I can fill in the details in a few minutes on the
phone, if the agenda allows. Kent, I could use 5-10 minutes for this,
if it's not too last-minute.
R6RS core/library strawman proposal
In order to provide a suitable framework for the split between core
language features and libraries, as well as to allow programmers to
specify which language features a given library depends on, this
proposal augments or replaces the <language> specification in SRFI 83
with a simple s-exp specification which allows certain language features
to be composed.
To demonstrate the composition possibilities, two "primitive" languages
have been specified: 'r6rs-primitives' and 'r6rs-pure-primitives'
These implement a language which contains the primitive expression types
defined in R5RS 4.1. The only difference between the two primitive
languages is that the 'pure' variant does not provide SET!
Whether this choice between pure & impure primitive languages is
ultimately provided is not the primary point here: the intent is to
raise the possibility of a choice between primitive languages. If such
a choice is not provided, it simply reduces the set of primitive
languages to one, i.e. 'r6rs-primitive'.
In addition to the primitive languages, the proposed language
specification mechanism allows a macro system to be specified, either
'syntax-rules' or 'syntax-case'.
By specifying the combination of a primitive language, a macro system,
and libraries, various useful "derived language" variants can be
specified. To illustrate the possibilities, this proposal specifies a
number of such variants, such as 'r6rs', 'r6rs-pure', 'r6rs-small', and
'r6rs-big'. For now, the details of these variants are less important
than the semantics of the language specification mechanism.
For syntax and examples, skip ahead past the Notes & Issues below to the
first section of the actual proposal.
Notes & Issues
* This proposal currently mostly avoids the term "core". It is intended
to provide a framework which will allow for appropriate definitions of
terms such as "core", and for addressing the organizational requirements
of the R6RS document.
* Features defined as "primitive" may not correspond exactly to the
actual primitive features in any given implementation. However, a
similar situation existed for the R5RS. The term "primitive" is not
intended to mandate any implementation characteristics, other than the
specified organization of libraries. In this proposal, "primitive"
essentially describes features which cannot reasonably be obtained by
importing from a SRFI 83 library, without requiring some magical
semantics for library imports.
* The <macro-system> clause in the syntax of the <language> form could
be replaced by a more general <language-slice>* clause, which would
support composition of modular sets of primitive language features,
other than macro systems. This could make sense if there were a larger
set of primitive features that needed to be combined compositionally.
* The two primitive languages, 'r6rs-pure-primitives' and
'r6rs-primitives' differ only in that the latter includes SET! Assuming
this ability to specify a pure language is adopted, there may be more
concise ways to achieve it than by providing two separate primitive
* The ability to specify a pure language may be more of a benefit to
programmers and to certain tools, than to compilers which can, of
course, detect the use of SET! Specifying only a single primitive
language which includes SET! could simplify the proposal slightly.
* The proposal vaguely specifies a catch-all library named 'standard'.
This is the rug under which many details have been swept. This will be
fleshed out once some agreement on the basic framework is obtained. The
more specific libraries are currently mostly based on the list provided
by Will, of functionality which a library should be able to exclude from
the language it uses.
* How much should this proposal actually require of implementations? At
a minimum, an implementation should be required to support a set of
predefined languages such as 'r6rs' and 'r6rs-big'. Beyond this, the
ability to support specification of other languages could be optional in
certain respects. Such cases have been flagged in the proposal.
The library proposal, SRFI 83, specifies a single language in which
libraries can be written, "scheme://r6rs". This core/library proposal
breaks the "scheme://r6rs" language down into smaller components,
proposes additional languages composed from those components, and
provides a means of specifying libraries which depend on a composition
of language components.
In order to support composition of language features, this proposal
defines two "primitive" languages ('r6rs-primitives' and
'r6rs-pure-primitives') as well as two macro systems ('syntax-rules' and
'syntax-case'). The remaining R6RS language functionality is divided
into libraries. These components can be composed to achieve a variety
of languages with different feature sets.
SRFI 83 defines the following syntax for the LIBRARY form:
(library <lib-path> <language>
SRFI 83 only specifies a single possible <language> form, namely
"scheme://r6rs". This proposal adds the following syntax for the
<language> = (scheme <derived-language>)
| (scheme <primitive-language>)
| (scheme <primitive-language> <macro-system>)
; NOTE: the latter two variants could be optional
<primitive-language> = r6rs-primitives | r6rs-pure-primitives
<derived-language> = r6rs-pure | r6rs-small | r6rs | r6rs-big
<macro-system> = syntax-rules | syntax-case
A typical library definition therefore looks like this:
(library "hello" (scheme r6rs)
(library "hello" (scheme r6rs-small)
(import "iteration-syntax" ; import DO and named LET
A lower-level definition (if supported by an implementation) looks like
(library "hello" (scheme r6rs-pure-primitives syntax-case)
The various language identifiers, macro system identifiers, and
libraries are described below.
Primitive language: r6rs-pure-primitives
This language includes all of the "primitive expression types" described
in R5RS 4.1, with the exception of SET! The expression types in
question are as follows:
Variable references: <variable>
Literal expressions: (quote <datum>)
Application: (<rator> <rand> ...)
Procedures: (lambda <formals> <body>)
Conditionals: (if t a b)
(if t a)
In addition, this language includes support for definitions as described
in R5RS 5.2, i.e. 'define'
The quasiquote reader shortcuts (` , ,@) will exist in this language,
but the identifiers quasiquote, unquote, and unquote-splicing will be
Primitive language: r6rs-primitives
This language is a superset of the r6rs-pure-primitives language, with a
single addition: support for the assignment syntax, SET!
Macro system: syntax-rules
Provides define-syntax, let-syntax, letrec-syntax, and the syntax-rules
Macro system: syntax-case
Provides define-syntax, let-syntax, letrec-syntax, the syntax-case macro
system, and syntax-rules.
The following libraries must be provided as part of an R6RS
implementation, as libraries importable via the SRFI 83 IMPORT form.
The core-syntax library contains derived expression types which most
Scheme programs are expected to use.
R5RS 4.2.1 Conditionals: cond, case, and, or
R5RS 4.2.2 Binding constructs: let, let*, letrec
R5RS 4.2.6 Quasiquotation: quasiquote, unquote, unquote-splicing
R5RS 4.2.3 Sequencing: begin
This library is currently a catch-all intended to include all
essentially non-controversial R6RS procedures. More controversial
procedures and derived syntax are defined in the libraries below. If
the 'standard' library exists in a future versions of this proposal, it
is likely to be composed of a number of other libraries. For the
current purposes, this library includes and provides the functionality
of the core-syntax library above.
R5RS 4.2.4: do, named let
R5RS 4.2.5: delay
R5RS 6.4: force
R5RS 6.3.2: set-car! set-cdr!
values, call-with-values, let-values, etc.
load, eval, scheme-report-environment, null-environment
Hash tables, hash functions (latter possibly separate library).
R6RS will specify one or more derived languages, including the 'r6rs'
language. The languages listed below are examples of the kind of
derived languages which might be specified.
The derived languages are so named because they are equivalent to a
language obtained from a combination of a primitive language and a set
of libraries. For example, a library which uses the derived language
'r6rs-pure' would be written as follows:
(library "hello" (scheme r6rs-pure)
This same library could be implemented in terms of the
r6rs-pure-primitives language as follows:
(library "hello" (scheme r6rs-pure-primitives syntax-rules)
In the languages defined below, the above equivalence is presented as
(scheme r6rs-pure-primitives syntax-rules)
Derived language: r6rs-pure
As defined above. This language provides only non-mutating Scheme
operations and hygienic-only macros (syntax-rules).
Derived language: r6rs-small
This is a fairly complete R6RS language which excludes certain less
essential or controversial features such as DO, named LET, fixnum and
flonum operations (fx* and fl*), SET-CAR!, SET-CDR!, and multiple value
handling forms. Its definition is as follows:
(scheme r6rs-primitives syntax-case)
Derived language: r6rs
This is a complete R6RS language which only excludes certain libraries
not considered part of the base R6RS language, e.g. promises, hash
tables, records, and 'eval'.
(import iteration-syntax fixnums flonums pair-mutation multiple-values)
(scheme r6rs-primitives syntax-case)
(import standard iteration-syntax fixnums flonums pair-mutation
Derived language: r6rs-big
This is a complete R6RS language which includes all features defined in
(import promises eval records hash-tables)
(scheme r6rs-primitives syntax-case)
(import standard iteration-syntax promises fixnums flonums
pair-mutation multiple-values eval records hash-tables)
Derived language: r5rs
This is a compatibility language which provides only those features
found in R5RS.
(scheme r6rs-primitives syntax-rules)
The above assumes that the 'r6rs-primitives' language is compatible with
r5rs. The 'r5rs-standard' library may be composed of certain compatible
r6rs libraries - details to follow.
More information about the R6RS