Scheme Requests for Implementation

Scheme Requests for Implementation
Scheme Requests for Implementation
SRFIs extend the Scheme programming language. You can help. Start by
joining the discussion
on one of our mailing lists.
Arvydas Silanskas's
index.scheme.org
is an increasingly comprehensive index of Scheme implementations, standards, and SRFIs.
Shiro Kawai's
Practical Scheme
includes a
cross-reference
showing which Scheme implementations support which SRFIs. It's a wiki page, so please help keep it up to date.
The SRFIs
Search for
Filter by
Show
abstracts
Sort by
269
Portable Test Definitions
, by Andrew Tropin and Ramin Honary
Draft:
2026-04-02
Keywords:
Testing
See also
SRFI 64: A Scheme API for test suites
This SRFI defines a portable API for test definitions that is
decoupled from test execution and reporting. It provides three
primitives: the universal
is
macro for
assertions,
test
for grouping assertions into
independently executable units, and
suite
for organizing
tests into hierarchies. Tests and suites can carry user-provided
metadata to adjust the behavior of a test runner, for example, to
select tests by tags or to enforce timeout values. The API is tiny,
yet capable and flexible. By focusing on the definition and leaving
execution semantics to test runners, this SRFI offers a common ground
that can reduce fragmentation among testing libraries.
Unlike side-effect-driven testing frameworks (e.g. SRFI-64),
this API produces first-class runtime entities, making it easy to
filter, schedule, wrap them in exception guards and continuation
barriers, run in arbitrary order, and re-run dynamically generated
test subsets. In addition to the usual CLI test runners, it enables
runtime-friendly test runners that integrate well with highly
interactive development workflows inside REPLs and IDEs, significantly
increasing control over test execution and shortening the feedback
loop.
To bridge the test definitions and test runners, the SRFI specifies
a message-passing programming interface, and test loading and
execution semantics recommendations for test runner implementers.
268
Multidimensional Array Literals
, by Per Bothner (SRFI 163), Peter McGoron (design), John Cowan (editor and steward), and Wolfgang Corcoran-Mathe (implementation)
Draft:
2026-03-30
Keywords:
Reader Syntax
See also
SRFI 25: Multi-dimensional Array Primitives
SRFI 122: Nonempty Intervals and Generalized Arrays
, and
SRFI 231: Intervals and Generalized Arrays
This is a specification of a lexical syntax for multi-dimensional arrays. Textually it is an alteration of
SRFI 163
, which is an extension of the
Common Lisp array reader syntax
to handle non-zero lower bounds and optional uniform element types (compatibly with
SRFI 4
and
SRFI 160
). It can be used in conjunction with
SRFI 25
SRFI 122
, or
SRFI 231
. There are recommendations for output formatting,
read-array
and
write-array
procedures, and a suggested
format-array
procedure.
267
Raw String Syntax
, by Peter McGoron
Draft:
2026-01-17
Keywords:
Reader Syntax
Raw strings are a lexical syntax for strings that do not interpret escapes inside of them and are useful in cases where the string data has a lot of characters such as
or
that would otherwise have to be escaped. This SRFI proposes a raw string syntax that allows for a customized delimiter to enclose the character data. Importantly, for any string, there exists a delimiter such that the raw string using that delimiter can represent the string verbatim. The raw strings in this SRFI do not do any special whitespace handling.
266
The expr syntax
, by José Bollo
Draft:
2026-01-16
Keywords:
Syntax
See also
SRFI 105: Curly-infix-expressions
The syntax
expr
allows one to write arithmetic expressions using a syntax near to mathematical notation, potentially improving the readability of Scheme programs.
265
The CFG Language
, by Marc Nieper-Wißkirchen
Draft:
2025-10-30
Keywords:
Control Flow
Library name: cfg
See also
SRFI 42: Eager Comprehensions
and
SRFI 242: The CFG Language
This SRFI defines a language to describe control-flow graphs (CFGs) suitable for formulating iterative and recursive algorithms. Using the notion of a CFG term, this language can be seamlessly embedded in the Scheme language. Complex CFG terms can be composed from simple CFG terms.
The language described in this SRFI is not meant to be directly used in programs but by library authors to build abstractions like loop facilities on top of it.
264
String Syntax for Scheme Regular Expressions
, by Sergei Egorov
Final:
2025-10-11
Keywords:
Data Structure
Text
See also
SRFI 115: Scheme Regular Expressions
This SRFI proposes SSRE, an alternative string-based syntax for Scheme Regular Expressions as defined by
SRFI 115
. String syntax is both compact and familiar to many regexp users; it is translated directly into SRE S-expressions, providing equivalent constructs. While the proposed syntax mostly follows PCRE, it takes into account specifics of Scheme string syntax and limitations of SRE, leaving out constructs that either duplicate functionality provided by Scheme strings or have no SRE equivalents. The repertoire of named sets and boundary conditions can be extended via a parameter mechanism. Extensions to PCRE syntax allow concise expression of operations on named character sets.
263
Prototype Object System
, by Daniel Ziltener
Draft:
2025-06-09
Keywords:
Object-Oriented Programming
See also
SRFI 20: Simple object system
This SRFI proposes a "Self"-inspired prototype object system. Such an object system works by having prototype objects that are derived repeatedly to modify, extend, and use them, and is interacted with by passing messages.
262
Extensible pattern matcher
, by Daphne Preston-Kendal
Draft:
2025-05-07
Keywords:
Pattern Matching
Library name: match
See also
SRFI 200: Pattern Matching
SRFI 204: Wright-Cartwright-Shinn Pattern Matcher
SRFI 241: Match — Simple Pattern-Matching Syntax to Express Catamorphisms on Scheme Data
, and
SRFI 257: Simple extendable pattern matcher with backtracking
A pattern matching form which can operate on arbitrary Scheme values is defined. It conforms to the following design principles.
The syntax of patterns is declarative. The syntax is extensible in the same way that Scheme’s procedural syntax is extensible by macros.
For most use cases, the use of the pattern matcher should produce code which is essentially as efficient at run time as equivalent procedural Scheme code would be, assuming a moderately optimizing Scheme implementation. This applies only when the equivalent code is also equivalently correct in terms of handling of error cases (i.e. including all type checks done automatically by the pattern matcher). However, using extension syntax should not cause this principle to be violated (provided the extension syntax is appropriately implemented).
261
Portable SRFI Library Reference
, by WANG Zheng
Final:
2025-11-07
Keywords:
Modules
See also
SRFI 97: SRFI Libraries
This SRFI proposal addresses systemic compatibility issues exposed by the
SRFI 97
-defined library reference format
(srfi : ...)
and advocates for two more modernized, portable and readable alternatives:
(srfi srfi-)
and
(srfi -)
260
Generated Symbols
, by Marc Nieper-Wißkirchen
Final:
2025-05-07
Keywords:
Data Structure
See also
SRFI 258: Uninterned symbols
This SRFI defines the procedure
generate-symbol
. Each time it is invoked, the procedure returns a new symbol whose name cannot be guessed. The returned symbol is a standard symbol for all purposes; it obeys write/read invariance and it is equal to another symbol if and only if their names are spelled the same.
259
Tagged procedures with type safety
, by Daphne Preston-Kendal
Final:
2025-05-07
Keywords:
Data Structure
Library name: tagged-procedures
See also
SRFI 229: Tagged Procedures
Tagged procedures are procedures with boxes attached, which can be used to create applicable records and other abstractions. This SRFI proposes a variant with the notion of a tagging protocol, analogous to a record type definition, for ensuring encapsulation and security for tagged procedures.
258
Uninterned symbols
, by Wolfgang Corcoran-Mathe
Final:
2025-03-26
Keywords:
Data Structure
See also
SRFI 260: Generated Symbols
An uninterned symbol is not the same as any other symbol, even one with the same name. These symbols are useful in macro programming and in other situations where guaranteed-unique names are needed. A survey of uninterned and uniquely named symbols in Scheme is also provided.
257
Simple extendable pattern matcher with backtracking
, by Sergei Egorov
Final:
2025-12-22
Keywords:
Pattern Matching
See also
SRFI 200: Pattern Matching
SRFI 204: Wright-Cartwright-Shinn Pattern Matcher
SRFI 241: Match — Simple Pattern-Matching Syntax to Express Catamorphisms on Scheme Data
, and
SRFI 262: Extensible pattern matcher
Pattern matching extends Scheme's repertoire of conditional constructs, allowing decomposition of compound data structures and binding their parts to variables. This SRFI proposes one such construct,
match
, which offers all the core functionality specified in
SRFI 200
, while extending it with support for non-linear patterns and backtracking. The proposed construct is modular and supports easy extension through the
define-match-pattern
mechanism. It can be implemented portably in R⁷RS-Small.
256
Minimal extension to SRFI 9/R7RS small record type definitions for inheritance
, by Daphne Preston-Kendal
Withdrawn:
2025-02-08
Keywords:
Data Structure
Record Type
See also
SRFI 9: Defining Record Types
SRFI 99: ERR5RS Records
, and
SRFI 237: R6RS Records (refined)
A SRFI 9-style
define-record-type
is specified which allows subtyping while preserving encapsulation, in that the field structure of supertypes remains an implementation detail with which subtypes need not concern themselves.
255
Restarting conditions
, by Wolfgang Corcoran-Mathe
Final:
2024-12-22
Keywords:
Exceptions
See also
SRFI 249: Restarting conditions
When an exceptional situation is encountered by a program, it usually creates a condition object describing the situation, and then passes control to an exception handler. The signaler and handler are two different parts of a system, between which there is a barrier of abstraction. In order to recover gracefully and flexibly from exceptional situations, however, the signaler can provide multiple ways by which the handler can restart the computation, some of which may require extra input. Often, the choice of method of recovery is left up to a human user, who may be prompted for the input needed to recover. This SRFI proposes a mechanism called
restarters
, which uses a new type of condition object and an associated exception handler to encapsulate the information necessary to restart a computation. We also describe the behavior and interface of
interactor
procedures, which implement interactive restarts.
254
Ephemerons and Guardians
, by Marc Nieper-Wißkirchen
Draft:
2024-09-11
Keywords:
Garbage Collection
See also
SRFI 124: Ephemerons
and
SRFI 246: Guardians
This SRFI describes three concepts associated with the storage management of a Scheme system,
ephemerons
guardians
, and
transport cell guardians
An ephemeron is a record structure with a
key
and a
value
field. An ephemeron can be
broken
. Breaking an ephemeron replaces the key and value with
#f
. An implementation of this SRFI breaks an ephemeron when it proves that the storage occupied by the key could be reclaimed if the ephemeron were broken.
A guardian is a structure containing objects as
guarded
or
resurrected
elements. Initially, guardians are empty. Objects can be added in guarded elements to the guardian by the programmer. An implementation of this SRFI resurrects an element when it proves that the storage occupied by the object could be reclaimed if all guardians in the system were empty. Objects from resurrected elements can be queried and removed from the guardian by the programmer. Instead of the object itself, a
representative
can be returned.
A transport cell guardian is a structure containing
transport cells
, similar to a guardian. Whenever an object in a guarded transport cell in the transport cell guardian is moved by the garbage collector, the transport cell is resurrected so that it can be queried by the programmer.
253
Data (Type-)Checking
, by Artyom Bologov
Final:
2024-11-15
Keywords:
Record Type
Type Checking
See also
SRFI 143: Fixnums
SRFI 144: Flonums
SRFI 145: Assumptions
, and
SRFI 187: ALAMBDA and ADEFINE
Data validation and type checking (supposedly) make for more correct code. And faster code too, sometimes. And, in rare cases, code that's easier to follow than un-checked code. Unfortunately, Scheme does not have many (type-)checking primitives out of the box. This SRFI provides some, with the aim of allowing more performant and correct code with minimum effort on the user side. Both (manual) argument checking/validation (
check-arg
) and return value(s) (
values-checked
) checking/coercion are provided. Syntax sugar like
define-checked
and
define-record-type-checked
is added on top.
252
Property Testing
, by Antero Mejr
Final:
2024-04-25
Keywords:
Testing
See also
SRFI 64: A Scheme API for test suites
SRFI 158: Generators and Accumulators
, and
SRFI 194: Random data generators
This defines an extension of the
SRFI 64
test suite API to support property testing. It uses
SRFI 158
generators to generate test inputs, which allows for the creation of custom input generators. It uses
SRFI 194
as the source of random data, so that the generation of random test inputs can be made deterministic. For convenience, it also provides procedures to create test input generators for the types specified in R7RS-small. The interface to run property tests is similar to that of
SRFI 64
, and a property-testing-specific test runner is specified in order to display the results of the propertized tests.
251
Mixing groups of definitions with expressions within bodies
, by Sergei Egorov
Final:
2024-05-06
Keywords:
Binding
See also
SRFI 245: Mixing definitions and expressions within bodies
Scheme has traditionally required procedure bodies and the bodies of derived constructs
such as
let
to contain definitions followed by commands/expressions.
This SRFI proposes to allow mixing commands and groups of definitions in such bodies, so that each
command/expression is in the scope of all local definition groups preceding it, but not in scope of
the local definition groups following it. This approach is backwards compatible with R7RS and
upholds the intuitive rule that to find the definition of a lexical variable, one has
to look
up
the source code tree.
250
Insertion-ordered hash tables
, by John Cowan and Daphne Preston-Kendal
Final:
2025-10-27
Keywords:
Data Structure
See also
SRFI 69: Basic hash tables
SRFI 125: Intermediate hash tables
SRFI 126: R6RS-based hashtables
, and
SRFI 128: Comparators (reduced)
This SRFI defines an interface to hash tables, which are widely recognized as a fundamental data structure for a wide variety of applications. A hash table is a data structure that:
Is disjoint from all other types.
Provides a mapping from objects known as
keys
to corresponding objects known as
values
Keys may be any Scheme objects in some kinds of hash tables, but are restricted in other kinds.
Values may be any Scheme objects.
Provides an
equality predicate
which defines when a proposed key is the same as an existing key. No table may contain more than one value for a given key.
Provides a
hash function
which maps a candidate key into a non-negative exact integer.
Supports mutation as the primary means of setting the contents of a table.
Provides key lookup and destructive update in (expected) amortized constant time, provided that a satisfactory hash function is available.
Does not guarantee that whole-table operations work in the presence of concurrent mutation of the whole hash table. (Values may be safely mutated.)
Unlike the hash tables of
SRFI 125
, which is the direct ancestor of this specification, the hash tables described here are ordered by insertion: that is, associations inserted earlier in the history of the hash table appear earlier in the ordering. Advances in the implementations of hash tables, as provided by C++, Python, JavaScript, etc., make the provision of this new facility practical. As a result, the hash tables of this SRFI do not necessarily interoperate with the hash tables of SRFI 125,
SRFI 126
, or existing R6RS implementations.
249
Restarting conditions
, by John Cowan
Withdrawn:
2024-09-13
Keywords:
Exceptions
See also
SRFI 255: Restarting conditions
When an exceptional situation is encountered by a program, it may create a
condition
object describing the situation and then signal the condition and pass control to a condition handler. The signaler and handler are two different parts of a system, between which there is a barrier of abstraction. In order to recover gracefully and flexibly from exceptional situations, however, the signaler can provide multiple ways by which the handler can restart the computation, some of which may require extra input. Often, the decision of which method of recovery to choose is left up to a human user, who may be prompted for the input needed to recover. This SRFI proposes a simple mechanism called
restarters
to encapsulate the information necessary to restart a computation with associated interactive prompters.
248
Minimal delimited continuations
, by Marc Nieper-Wißkirchen
Final:
2025-01-24
Keywords:
Continuations
See also
SRFI 226: Control Features
Scheme's exception system is extended so that exception handlers gain access to the delimited continuation representing the rest of the computation of the call of the thunk guarded by the handler. Algebraic effect handlers can be directly expressed in this extended exception system. The system directly implements the
shift0
reset0
delimited control operators. It is well known that other delimited control operators like
prompt0
control0
or
reset
shift
are expressible in
shift0
reset0
(and vice versa).
247
Syntactic Monads
, by Marc Nieper-Wißkirchen
Final:
2023-12-24
Keywords:
Syntax
This SRFI extends Scheme with a simple mechanism to implicitly add formal arguments to procedure definitions and to implicitly add arguments to procedure calls. Contrary to parameters (also known as fluids or dynamically bound variables), which can be used for the same purpose, no runtime overhead is generated.
246
Guardians
, by John Cowan
Withdrawn:
2024-09-11
Keywords:
Garbage Collection
Superseded
See also
SRFI 254: Ephemerons and Guardians
Guardians allow programs to protect objects from deallocation by the garbage collector and to determine which objects would otherwise have been deallocated. When the object has associated non-memory resources, a program can register it with a guardian. The GC will mark inaccessible objects but will not collect them; at the program's convenience, inaccessible objects are removed from the guardian and their non-memory resources are disposed of. Guardians allow objects to be saved from deallocation indefinitely so that they can be reused or so that clean-up or other actions can be performed using the data stored within the objects. Guardians avoid the problems associated with classical finalizers detailed in the Rationale section.
245
Mixing definitions and expressions within bodies
, by Daphne Preston-Kendal
Withdrawn:
2024-04-04
Keywords:
Binding
See also
SRFI 251: Mixing groups of definitions with expressions within bodies
Scheme has traditionally required procedure bodies and the bodies of derived constructs such as
let
to contain definitions followed by expressions. This SRFI proposes to allow expressions to appear before and intermingled with definitions in such bodies, as was allowed in program bodies by the R6RS and in library bodies by R7RS small.
244
Multiple-value Definitions
, by Marc Nieper-Wißkirchen
Final:
2023-02-05
Keywords:
Binding
Multiple-Value Returns
Library name: define-values
define-values
form is a definition that binds multiple variables from a single expression returning multiple values.
243
Unreadable Data
, by Lassi Kortela
Withdrawn:
2023-11-30
Keywords:
Reader Syntax
This SRFI suggests how the Scheme reader and writer should handle unreadable data in general, and unreadable objects in particular.
242
The CFG Language
, by Marc Nieper-Wißkirchen
Final:
2023-10-29
Keywords:
Control Flow
Library name: cfg
See also
SRFI 42: Eager Comprehensions
and
SRFI 265: The CFG Language
This SRFI defines a language to describe control-flow graphs (CFGs) suitable for formulating iterative and recursive algorithms. Using the notion of a CFG term, this language can be seamlessly embedded in the Scheme language. Complex CFG terms can be composed from simple CFG terms.
241
Match — Simple Pattern-Matching Syntax to Express Catamorphisms on Scheme Data
, by Marc Nieper-Wißkirchen
Final:
2023-03-23
Keywords:
Pattern Matching
Syntax
Library name: match
See also
SRFI 200: Pattern Matching
SRFI 204: Wright-Cartwright-Shinn Pattern Matcher
SRFI 257: Simple extendable pattern matcher with backtracking
, and
SRFI 262: Extensible pattern matcher
This SRFI describes a simple pattern matcher based on one originally devised by Kent Dybvig, Dan Friedman, and Eric Hilsdale, which has a catamorphism feature to perform recursion automatically.
240
Reconciled Records
, by Marc Nieper-Wißkirchen
Final:
2023-05-02
Keywords:
Data Structure
Record Type
See also
SRFI 9: Defining Record Types
SRFI 57: Records
SRFI 76: R6RS Records
SRFI 99: ERR5RS Records
SRFI 131: ERR5RS Record Syntax (reduced)
SRFI 136: Extensible record types
SRFI 150: Hygienic ERR5RS Record Syntax (reduced)
, and
SRFI 237: R6RS Records (refined)
This SRFI defines a version of the
define-record-type
definition of
RS
and
SRFI 237
that extends the
define-record-type
syntax of
RS
, reconciling both systems.
This SRFI is meant to be adopted by R
RS-large to integrate essentially the R
RS record system compatibly with the existing R
RS-small record system.
239
Destructuring Lists
, by Marc Nieper-Wißkirchen
Final:
2023-01-23
Keywords:
Syntax
Library name: list-case
This SRFI provides the
list-case
, the syntactic fundamental list destructor.
238
Codesets
, by Lassi Kortela
Final:
2023-01-16
Keywords:
Operating System
Error Handling
Introspection
Library name: codesets
See also
SRFI 170: POSIX API
SRFI 198: Foreign Interface Status
, and
SRFI 199: POSIX errno manipulation
Many programming interfaces rely on a set of condition codes where each code has a numeric ID, a mnemonic symbol, and a human-readable message. This SRFI defines a facility to translate between numbers and symbols in a codeset and to fetch messages by code. Examples are given using the Unix
errno
and
signal
codesets.
237
R6RS Records (refined)
, by Marc Nieper-Wißkirchen
Final:
2023-05-02
Keywords:
Data Structure
Record Type
See also
SRFI 9: Defining Record Types
SRFI 57: Records
SRFI 76: R6RS Records
SRFI 99: ERR5RS Records
SRFI 131: ERR5RS Record Syntax (reduced)
SRFI 136: Extensible record types
SRFI 150: Hygienic ERR5RS Record Syntax (reduced)
SRFI 240: Reconciled Records
, and
SRFI 256: Minimal extension to SRFI 9/R7RS small record type definitions for inheritance
The record mechanism of R
RS is refined. In particular, the triad of record names, record-type descriptors and record constructor descriptors can be effectively ignored and replaced with the single notion of a record descriptor. We also remove the restriction that the syntactic layer can only define one constructor per record type defined.
236
Evaluating expressions in an unspecified order
, by Marc Nieper-Wißkirchen
Final:
2022-11-22
Keywords:
Control Flow
Syntax
Library name: independently
This SRFI defines the
independently
syntax, which can be
used to combine side effects into one expression without
specifying their relative order.
235
Combinators
, by John Cowan (spec) and Arvydas Silanskas (implementation)
Final:
2023-02-28
Keywords:
Miscellaneous
This SRFI contains various procedures that accept and return procedures, as well as a few others, drawn from
an earlier version of Chicken
. Common Lisp has a few of them too, and more come from
the Standard Prelude from
Programming Praxis
. Using these procedures helps to keep code terse and reduce the need for ad hoc lambdas.
234
Topological Sorting
, by John Cowan and Arne Babenhauserheide
Final:
2024-09-24
Keywords:
Algorithm
Topological sorting is an algorithm that takes a graph consisting of nodes and other nodes that depend on them, forming a partial order, and returns a list representing a total ordering of the graph. If the graph is cyclic, the topological sort will fail. The procedure
topological-sort
returns three values. If sorting succeeds, the first value contains the result and the second and third are
#false
. If sorting fails, the result is
#false
and the second and third value may provide additional information about the error.
233
INI files
, by John Cowan (spec) and Arvydas Silanskas (implementation)
Final:
2022-10-13
Keywords:
I/O
An INI file is a configuration file that consists of key-value
pairs for properties, and sections that group the properties. The
name of these configuration files comes from the filename extension
INI
, short for initialization.
The format has become an informal standard in many contexts of configuration.
This SRFI provides access to the contents of an INI file.
232
Flexible curried procedures
, by Wolfgang Corcoran-Mathe
Final:
2022-04-06
Keywords:
Syntax
See also
SRFI 26: Notation for Specializing Parameters without Currying
and
SRFI 219: Define higher-order lambda
Scheme lacks a flexible way to create and apply curried procedures. This SRFI describes
curried
, a variant of
lambda
that creates true curried procedures which also behave just like ordinary Scheme procedures. They can be applied to their arguments one by one, all at once, or anywhere in between, without any novel syntax.
curried
also supports nullary and variadic procedures, and procedures created with it have predictable behavior when applied to surplus arguments.
231
Intervals and Generalized Arrays
, by Bradley J. Lucier
Final:
2022-09-25
Keywords:
Data Structure
Numbers
See also
SRFI 122: Nonempty Intervals and Generalized Arrays
SRFI 164: Enhanced multi-dimensional Arrays
SRFI 179: Nonempty Intervals and Generalized Arrays (Updated)
, and
SRFI 268: Multidimensional Array Literals
This SRFI specifies an array mechanism for Scheme. Arrays as defined here are quite general; at their most basic, an array is simply a mapping, or function, from multi-indices of exact integers $i_0,\ldots,i_{d-1}$ to Scheme values. The set of multi-indices $i_0,\ldots,i_{d-1}$ that are valid for a given array form the
domain
of the array. In this SRFI, each array's domain consists of the cross product of intervals of exact integers $[l_0,u_0)\times[l_1,u_1)\times\cdots\times[l_{d-1},u_{d-1})$ of $\mathbb Z^d$, $d$-tuples of integers. Thus, we introduce a data type called $d$-
intervals
, or more briefly
intervals
, that encapsulates this notion. (We borrow this terminology from, e.g., Elias Zakon's
Basic Concepts of Mathematics
.) Specialized variants of arrays provide portable programs with efficient representations for common use cases.
This is a revised and improved version of
SRFI 179
230
Atomic Operations
, by Marc Nieper-Wißkirchen
Final:
2021-11-15
Keywords:
Concurrency
See also
SRFI 18: Multithreading support
and
SRFI 226: Control Features
This SRFI defines atomic operations for the Scheme programming language. An
atomic operation
is an operation that, even in the presence of multiple threads, is either executed completely or not at all. Atomic operations can be used to implement mutexes and other synchronization primitives, and they can be used to make concurrent algorithms lock-free. For this, this SRFI defines two data types,
atomic flags
and
atomic (fixnum) boxes
, whose contents can be queried and mutated atomically. Moreover, each atomic operation comes with a
memory order
that defines the level of synchronization with other threads.
229
Tagged Procedures
, by Marc Nieper-Wißkirchen
Final:
2021-11-15
Keywords:
Data Structure
See also
SRFI 259: Tagged procedures with type safety
This SRFI defines
tagged procedures
, which are procedures that are tagged with a Scheme value when created through the syntax
lambda/tag
and
case-lambda/tag
. The value of the tag of a procedure can be retrieved with
procedure-tag
, and the predicate
procedure/tag?
discerns whether a procedure is tagged.
228
Composing Comparators
, by Daphne Preston-Kendal
Final:
2022-12-10
Keywords:
Comparison
Library name: composing-comparators
See also
SRFI 128: Comparators (reduced)
and
SRFI 162: Comparators sublibrary
Further procedures for defining
SRFI 128
comparators.
Best enjoyed in combination with
SRFI 162
227
Optional Arguments
, by Marc Nieper-Wißkirchen (spec and R6RS implementation) and Daphne Preston-Kendal (R7RS implementation)
Final:
2021-11-16
Keywords:
Binding
See also
SRFI 89: Optional positional and named parameters
This SRFI specifies the
opt-lambda
syntax, which generalizes
lambda
. An
opt-lambda
expression evaluates to a procedure that takes a number of required and a number of optional (positional) arguments whose default values are determined by evaluating corresponding expressions when the procedure is called.
This SRFI also specifies a variation
opt*-lambda
, which is to
opt-lambda
as
let*
is to
let
and the related binding constructs
let-optionals
and
let-optionals*
Finally, for those who prefer less explicit procedure definitions, a sublibrary provides
define-optionals
and
define-optionals*
226
Control Features
, by Marc Nieper-Wißkirchen
Final:
2023-04-25
Keywords:
Continuations
Control Flow
See also
SRFI 18: Multithreading support
SRFI 34: Exception Handling for Programs
SRFI 39: Parameter objects
SRFI 45: Primitives for Expressing Iterative Lazy Algorithms
SRFI 97: SRFI Libraries
SRFI 154: First-class dynamic extents
SRFI 155: Promises
SRFI 157: Continuation marks
, and
SRFI 158: Generators and Accumulators
Whenever an expression is evaluated during the run of a Scheme program, there is a continuation awaiting the values of the expression. It is a distinguishing property of the Scheme programming language to offer a procedure (named
call/cc
) that captures the current continuation as a procedure, which, when called, aborts the then-current continuation and reinstates the captured one.
One can visualize a continuation as a list of (continuation) frames where a non-tail call adds a frame to the top of the list and where the return from a non-tail call removes the appropriate frame.
Moreover, each expression is evaluated in a dynamic environment that conceptually holds the values of parameters like the current output port and the dynamic-wind stack at the point of evaluation. As the dynamic environment is captured and reinstated along the continuation when the
call/cc
machinery is used, we can view it conceptually as part of the continuation.
The libraries defined in this SRFI are all concerned with continuations in a wider sense. More specifically, the topics are as follows:
Continuation Prompts
A continuation prompt is a special continuation frame that is tagged with a so-called prompt tag. Procedures to install continuation prompts and to abort the current continuation and escape back to a previously installed continuation prompt are provided. Moreover, continuation prompts are equipped with handlers that are invoked when a continuation is aborted to them.
Continuations
When continuations are captured, the list of captured continuation frames is always delimited by some continuation prompt. This extends the semantics of Scheme’s
call-with-current-continuation
. Moreover, a procedure to capture so-called composable continuations is provided. As opposed to continuations captured by
call-with-current-continuation
, invoking a composable continuation does not abort the then-current continuation, so composable continuations behave like ordinary procedures. Together with continuation prompts, composable continuations allow one to implement the various proposed sets of control operators for delimited continuations. Finally, a primitive (
call-in-continuation
) is provided that allows calling a procedure in a given continuation instead of just delivering values to it.
Continuation Marks
Continuation marks are a provided feature that allows one to attach arbitrary information to continuation frames that is captured and reinstated along with the rest of the continuation. Conceptually, exception handlers and parameters are implemented in terms of continuation marks, but the syntax and procedures defined in this SRFI allow the user to use them in more general ways. Moreover, they reify the notion of a tail call, allowing one, for example, to test for tail context.
Exceptions
The exception mechanism of
R6RS
and
R7RS
is reinterpreted with respect to the concepts introduced in this SRFI. (Here, and in what follows we mean the so-called small language when we speak about
R7RS
.) Moreover, the
with-exception-handler
procedure and the
guard
syntax gain additional tail-context guarantees.
Parameters
The parameter object mechanism of
SRFI 39
and
R7RS
is reinterpreted with respect to the concepts introduced in this SRFI. Procedures to retrieve the current parameterization and to reinstall it later are provided. Moreover, the
parameterize
syntax gains an additional tail-context guarantee. To support an alternative model of parameters that is linked to the dynamic extent and not to the current parameterization, the notion of a parameter-like object and the
temporarily
syntax are introduced.
Fluids
Fluids are a syntactic reinterpretation of parameter objects.
Delayed evaluation
The syntax and procedures on delayed evaluation of
R7RS
are revisited and redefined to handle the following satisfactorily: the parameterization of the delayed expression being forced, the treatment of exceptions raised during forcing of delayed expressions, and iterative lazy algorithms. Moreover, their semantics are detailed with respect to the concepts introduced in this SRFI, and promises can naturally deliver an arbitrary number of values when being forced. Finally, the initial continuation of a delayed expression being forced is defined in a way that makes it interchangeable with the initial continuation of a thread.
Threads
The thread mechanism of
SRFI 18
is detailed with respect to the concepts introduced in this SRFI. In particular, mutation of parameter objects in multi-threaded applications is specified. In order to support timeout arguments in a type-safe way, a minimal API on time objects is included as well.
Large parts of this SRFI have been inspired by the control operators provided by
Racket
225
Dictionaries
, by John Cowan (spec) and Arvydas Silanskas (implementation)
Final:
2022-09-27
Keywords:
Data Structure
See also
SRFI 146: Mappings
and
SRFI 167: Ordered Key Value Store
The procedures of this SRFI allow callers to manipulate an object that maps keys to values without the caller needing to know exactly what the type of the object is. Such an object is called a
dictionary
or
dict
in this SRFI.
224
Integer Mappings
, by Wolfgang Corcoran-Mathe
Final:
2021-06-30
Keywords:
Data Structure
See also
SRFI 146: Mappings
and
SRFI 189: Maybe and Either: optional container types
Integer maps, or
fxmappings
, are finite sets, where each element is an association between a fixnum (exact integer) key and an arbitrary Scheme object. They are similar to the general mappings of
SRFI 146
, but the restricted key-type allows implementations of fxmappings to benefit from optimized structures and algorithms. This library provides a rich set of operations on fxmappings, including analogues of most of the forms provided by SRFI 146. Fxmappings have no intrinsic order, but may be treated as ordered sets, using the natural ordering on keys; a substantial sublibrary for working with fxmappings in this fashion is included.
223
Generalized binary search procedures
, by Daphne Preston-Kendal
Final:
2021-07-27
Keywords:
Miscellaneous
Library name: bisect
See also
SRFI 43: Vector library
and
SRFI 133: Vector Library (R7RS-compatible)
Generalized procedures for binary search of vector-like data structures are provided which can be applied to any sequence type, including ones defined by the user, together with applications of these procedures for Scheme’s built-in vectors.
222
Compound Objects
, by John Cowan (text) and Arvydas Silanskas (implementation)
Final:
2021-07-20
Keywords:
Data Structure
Compound objects are analogous to R6RS compound conditions, and are suitable for use in creating and handling conditions on non-R6RS systems, among other purposes. They encapsulate an immutable sequence of subobjects, which can be any object except another compound object. It is possible to implement R6RS compound conditions on top of compound objects, but not vice versa. Note that this SRFI does not provide any analogue to R6RS
simple
conditions, which are just records.
221
Generator/accumulator sub-library
, by John Cowan (text) and Arvydas Silanskas (implementation)
Final:
2021-05-28
Keywords:
Data Structure
See also
SRFI 158: Generators and Accumulators
This is a set of convenience routines for generators and accumulators intended to blend in with
SRFI 158
. The authors recommend that they be added to the
(srfi 158)
library provided by users or implementations. If they are approved by the R7RS-large process, they can also be added to
(r7rs generator)
220
Line directives
, by Lassi Kortela
Withdrawn:
2021-04-20
Keywords:
Reader Syntax
Many language-agnostic programming tools rely on specially formatted source code comments to annotate the code with metadata. Such "magic comments" are hard for both humans and computers to parse reliably, as the purpose of a comment is to be free-form text that is not interpreted by machine.
This SRFI extends the standard Scheme directive syntax (
#!
) to support
line directives
. They look like magic comments to language-agnostic tools but read as S-expressions in Scheme, combining the portability of magic comments with the well-defined syntax and easy parsing of ordinary Scheme code.
219
Define higher-order lambda
, by Lassi Kortela
Final:
2021-04-04
Keywords:
Binding
Syntax
Library name: define
See also
SRFI 201: Syntactic Extensions to the Core Scheme Bindings
and
SRFI 232: Flexible curried procedures
This SRFI codifies the following shorthand syntax, which some Scheme implementations have had for a long time.
(define ((outer-name outer-args ...) inner-args ...) inner-body ...)
218
Unicode Numerals
, by John Cowan (text) and Arvydas Silanskas (implementation)
Withdrawn:
2021-01-30
Keywords:
Internationalization
These procedures allow the creation and interpretation of numerals using any set of Unicode digits that support positional notation.
217
Integer Sets
, by John Cowan (text) and Wolfgang Corcoran-Mathe (implementation)
Final:
2021-02-15
Keywords:
Data Structure
See also
SRFI 113: Sets and bags
Integer sets, or
iset
s, are unordered collections of fixnums. (Fixnums are exact integers within certain implementation-specified bounds.)
216
SICP Prerequisites (Portable)
, by Vladimir Nikishkin
Final:
2021-01-21
Keywords:
SICP
See also
SRFI 203: A Simple Picture Language in the Style of SICP
This SRFI follows
SRFI 203
in providing "out-of-the-box" support for hosting the exercises suggested by
Structure and Interpretation of Computer Programs
in portable Scheme.
Whereas SRFI 203 focused on the necessarily non-portable aspects of the problem set (the graphics), this SRFI aims to provide support for the rest of the features, which are far more widespread, often already provided, and in reality mostly need just a common vocabulary.
This SRFI provides procedures for working with time data, multi-threading, and streams, as well as SICP names for
true
and
false
None of these procedures is fit for production use. They are only designed for pedagogical purposes.
Students, however, are expected to be able to just write
(include (srfi sicp))
and have the code from the book run without problems (apart from those intended by the book authors).
215
Central Log Exchange
, by Göran Weinholt
Final:
2021-01-11
Keywords:
Operating System
Library name: logging
This SRFI specifies a central log exchange for Scheme that
connects log producers with log consumers. It allows multiple
logging systems to interoperate and co-exist in the same
program. Library code can produce log messages without knowledge
of which log system is actually used. Simple applications can
easily get logs on standard output, while more advanced
applications can send them to a full logging system.
214
Flexvectors
, by Adam Nelson
Final:
2021-03-18
Keywords:
Data Structure
See also
SRFI 117: Queues based on lists
SRFI 125: Intermediate hash tables
SRFI 133: Vector Library (R7RS-compatible)
SRFI 134: Immutable Deques
, and
SRFI 158: Generators and Accumulators
flexvector
, also known as a dynamic array or an arraylist, is a mutable vector-like data structure with an adjustable size. Flexvectors allow fast random access and fast insertion/removal at the end. This SRFI defines a suite of operations on flexvectors, modeled after
SRFI 133
's vector operations.
213
Identifier Properties
, by Marc Nieper-Wißkirchen
Final:
2021-03-21
Keywords:
Binding
Syntax
Using the
define-property
definition described in this SRFI, expand-time properties can be associated with identifiers in a referentially transparent and lexically scoped way.
212
Aliases
, by Marc Nieper-Wißkirchen
Final:
2021-02-12
Keywords:
Syntax
This SRFI introduces
alias definitions
, a syntactic extension. An alias definition transfers the binding of one identifier to another, effectively aliasing the identifier.
211
Scheme Macro Libraries
, by Marc Nieper-Wißkirchen
Final:
2022-07-19
Keywords:
Syntax
See also
SRFI 46: Basic Syntax-rules Extensions
SRFI 93: R6RS Syntax-Case Macros
, and
SRFI 139: Syntax parameters
This SRFI describes common syntactic extensions of the
syntax-rules
macro facility of R5RS and the base R6RS and R7RS libraries. In particular, library namespaces are defined where these extensions can be located and which can be tested against in
cond-expand
forms.
210
Procedures and Syntax for Multiple Values
, by Marc Nieper-Wißkirchen
Final:
2021-02-12
Keywords:
Binding
Multiple-Value Returns
See also
SRFI 8: receive: Binding to multiple values
SRFI 11: Syntax for receiving multiple values
, and
SRFI 71: Extended LET-syntax for multiple values
This SRFI extends the Scheme standard with procedures and syntax dealing with multiple values, including syntax to create lists and vectors from expressions returning multiple values and procedures returning the elements of a list or vector as multiple values.
209
Enums and Enum Sets
, by John Cowan (text) and Wolfgang Corcoran-Mathe (implementation)
Final:
2020-12-17
Keywords:
Data Structure
Enums are objects that serve to form sets of distinct classes that specify different modes of operation for a procedure. Their use fosters portable and readable code.
208
NaN procedures
, by Emmanuel Medernach (design), John Cowan (editor), and Wolfgang Corcoran-Mathe (implementation)
Final:
2021-02-23
Keywords:
Data Structure
Numbers
This SRFI provides procedures that dissect NaN (Not a Number) inexact values.
207
String-notated bytevectors
, by Daphne Preston-Kendal (external notation), John Cowan (procedure design), and Wolfgang Corcoran-Mathe (implementation)
Final:
2020-10-29
Keywords:
Reader Syntax
Library name: bytestrings
To ease the human reading and writing of Scheme code involving binary data that for mnemonic reasons corresponds as a whole or in part to ASCII-coded text, a notation for bytevectors is defined which allows printable ASCII characters to be used literally without being converted to their corresponding integer forms. In addition, this SRFI provides a set of procedures known as the bytestring library for constructing a bytevector from a sequence of integers, characters, strings, and/or bytevectors, and for manipulating bytevectors as if they were strings as far as possible.
206
Auxiliary Syntax Keywords
, by Marc Nieper-Wißkirchen
Final:
2020-12-21
Keywords:
Syntax
See also
SRFI 139: Syntax parameters
and
SRFI 213: Identifier Properties
This SRFI defines a mechanism for defining auxiliary syntax keywords independently in different modules in such a way that they still have the same binding so that they can be used interchangeably as literal identifiers in
syntax-rules
and
syntax-case
expressions and can be both imported under the same name without conflicts.
205
POSIX Terminal Fundamentals
, by John Cowan and Harold Ancell
Withdrawn:
2022-03-21
Keywords:
Operating System
See also
SRFI 170: POSIX API
and
SRFI 198: Foreign Interface Status
This SRFI describes procedures for command-line and terminal interface programs to safely change and reset terminal modes, for example from cooked to raw and back, and for serial-line device manipulation for interfacing with embedded hardware and the like.
It is intended to provide all the
termios structure
functionality a modern Scheme programmer might desire by supplying a
stty
procedure, and simple abstractions on top of it.
204
Wright-Cartwright-Shinn Pattern Matcher
, by Felix Thibault
Withdrawn:
2022-02-02
Keywords:
Pattern Matching
See also
SRFI 200: Pattern Matching
SRFI 201: Syntactic Extensions to the Core Scheme Bindings
SRFI 204: Wright-Cartwright-Shinn Pattern Matcher
, and
SRFI 241: Match — Simple Pattern-Matching Syntax to Express Catamorphisms on Scheme Data
Pattern matching decomposes a compound data structure into parts and assigns those parts to variables. This SRFI describes a pattern-matching library already in use by several scheme implementations which can match many common compound data structures.
203
A Simple Picture Language in the Style of SICP
, by Vladimir Nikishkin
Final:
2020-09-17
Keywords:
SICP
See also
SRFI 216: SICP Prerequisites (Portable)
This SRFI proposes a simple library for programmatic drawing of pictures compatible with Section 2.2.4 of
Structure and Interpretation of Computer Programs
It aims to close the gap between the Scheme suggested for study in the book and portable Scheme.
202
Pattern-matching Variant of the and-let* Form that Supports Multiple Values
, by Panicz Maciej Godek
Final:
2020-11-28
Keywords:
Binding
Control Flow
Pattern Matching
See also
SRFI 2: AND-LET*: an AND with local bindings, a guarded LET* special form
and
SRFI 200: Pattern Matching
The SRFI-2 library introduced the
and-let*
form for short-circuited evaluation in the style of the
and
form, with the ability to capture the (non-
#f
) results in the style of the
let*
form. This document extends the
and-let*
form with the ability to pattern-match (or "destructurally bind") the values of evaluated expressions (where the match failure causes short-circuiting rather than raising an error) and the ability to handle multiple values (where only the falsehood of the first value causes short-circuiting).
201
Syntactic Extensions to the Core Scheme Bindings
, by Panicz Maciej Godek
Final:
2021-01-13
Keywords:
Binding
Pattern Matching
Syntax
See also
SRFI 8: receive: Binding to multiple values
SRFI 11: Syntax for receiving multiple values
SRFI 71: Extended LET-syntax for multiple values
SRFI 200: Pattern Matching
, and
SRFI 219: Define higher-order lambda
This document describes a handful of syntactic extensions to the core bindings of the Scheme programming language. In particular, it proposes to extend the binding forms
lambda
let
let*
with pattern matching capabilities, to extend the forms
let
and
or
with the ability to handle multiple values, and to extend the form
define
with the ability of defining "curried" functions.
200
Pattern Matching
, by Panicz Maciej Godek
Withdrawn:
2022-07-23
Keywords:
Pattern Matching
See also
SRFI 204: Wright-Cartwright-Shinn Pattern Matcher
SRFI 241: Match — Simple Pattern-Matching Syntax to Express Catamorphisms on Scheme Data
SRFI 257: Simple extendable pattern matcher with backtracking
, and
SRFI 262: Extensible pattern matcher
This SRFI discusses some of the existing pattern-matching libraries for the Scheme programming language — namely, the pattern matcher presented by Andrew K. Wright and Robert Cartwright in the paper "A Soft Type System for Scheme", the pattern matcher developed by Dan Friedman, Erik Hilsdale and Kent Dybvig, the
racket/match
module distributed with the Racket programming environment, as well as the Bigloo and Gerbil pattern matchers distributed with their respective implementations. It then extracts a pattern syntax which is compatible with three of those implementations and provides extrinsic rationale for that syntax. It also provides a simple implementation of a pattern matcher which conforms to the specification of a pattern language provided in this document.
199
POSIX errno manipulation
, by Harold Ancell
Withdrawn:
2020-07-19
Keywords:
Error Handling
Operating System
See also
SRFI 170: POSIX API
and
SRFI 198: Foreign Interface Status
The majority of P
OSIX
system and library calls
require accessing
errno
to discern the specific cause
of an error, and some require setting it to 0 before being called.
This SRFI specifies procedures to both retrieve its value, and to
set it.
198
Foreign Interface Status
, by John Cowan (editor and shepherd), Harold Ancell (implementer and editor), and Lassi Kortela (architect)
Withdrawn:
2020-09-12
Keywords:
Error Handling
Operating System
See also
SRFI 170: POSIX API
This SRFI provides means to construct, return or signal, and extract
information from Scheme interfaces with "foreign" systems such as the
OSIX
API, databases, and libraries.
197
Pipeline Operators
, by Adam Nelson
Final:
2020-09-12
Keywords:
Syntax
Many functional languages provide pipeline operators, like Clojure's
->
or OCaml's
|>
. Pipelines are a simple, terse, and readable way to write deeply-nested expressions. This SRFI defines a family of
chain
and
nest
pipeline operators, which can rewrite nested expressions like
(a b (c d (e f g)))
as a sequence of operations:
(chain g (e f _) (c d _) (a b _))
196
Range Objects
, by John Cowan (text) and Wolfgang Corcoran-Mathe (sample implementation)
Final:
2020-09-17
Keywords:
Data Structure
See also
SRFI 42: Eager Comprehensions
Ranges are collections somewhat similar to vectors, except that they are immutable and have algorithmic representations instead of the uniform per-element data structure of vectors. The storage required is usually less than the size of the same collection stored in a vector and the time needed to reference a particular element is typically less for a range than for the same collection stored in a list. This SRFI defines a large subset of the sequence operations defined on lists, vectors, strings, and other collections. If necessary, a range can be converted to a list, vector, or string of its elements or a generator that will lazily produce each element in the range.
195
Multiple-value boxes
, by Marc Nieper-Wißkirchen
Final:
2020-08-28
Keywords:
Data Structure
Multiple-Value Returns
See also
SRFI 111: Boxes
and
SRFI 189: Maybe and Either: optional container types
This SRFI extends the specification of the boxes of
SRFI 111
so that they are multiple-values aware. Whereas a SRFI 111 box is limited in that it can only box a single value, multiple values can be boxed with this SRFI.
194
Random data generators
, by Shiro Kawai (design), Arvydas Silanskas (implementation), John Cowan (editor and shepherd), and Linas Vepštas (implementation)
Final:
2020-08-26
Keywords:
Randomness
See also
SRFI 27: Sources of Random Bits
This SRFI defines a set of
SRFI 158
generators and generator makers that yield random data of specific ranges and distributions. It is intended to be implemented on top of
SRFI 27
, which provides the underlying source of random integers and floats.
193
Command line
, by Lassi Kortela
Final:
2020-09-10
Keywords:
Operating System
See also
SRFI 22: Running Scheme Scripts on Unix
RS and R
RS define a
command-line
procedure. While a useful baseline, the specification is not detailed enough to cover all practical situations. This SRFI clarifies the definition of
command-line
and adds a few related procedures. Scheme scripts, standalone executables, compilation and REPL use are accounted for. Option parsing is out of scope.
192
Port Positioning
, by John Cowan and Shiro Kawai (implementation; requires a hook)
Based on R6RS.
Final:
2020-07-31
Keywords:
I/O
See also
SRFI 181: Custom ports (including transcoded ports)
This is an extract from the R6RS that documents its support for
positioning ports. Binary ports can be positioned to read or write
at a specific byte; textual ports at a specific character,
although character positions can't be synthesized portably.
It has been lightly edited to fit R7RS style.
191
Procedure Arity Inspection
, by John Cowan
Based on SRFI 102.
Withdrawn:
2020-07-05
Keywords:
Introspection
See also
SRFI 102: Procedure Arity Inspection
and
SRFI 151: Bitwise Operations
Many Scheme systems provide mechanisms for inspecting the arity of a
procedural value, making it a common feature, however there is no
standard interface. As a result there is no portable way to observe
the arity of a procedure without actually applying it. This
SRFI proposes a simple interface that is consistent with existing
Scheme systems' facilities and prior proposals.
190
Coroutine Generators
, by Marc Nieper-Wißkirchen
Final:
2020-06-11
Keywords:
Syntax
See also
SRFI 121: Generators
SRFI 139: Syntax parameters
, and
SRFI 158: Generators and Accumulators
This SRFI defines syntax to create
SRFI
121
158
coroutine generators conveniently and in the flavor of Python
generator functions.
189
Maybe and Either: optional container types
, by John Cowan (text) and Wolfgang Corcoran-Mathe (sample implementation)
Final:
2020-07-14
Keywords:
Data Structure
Multiple-Value Returns
See also
SRFI 195: Multiple-value boxes
This SRFI defines two disjoint immutable container types known as Maybe and Either, both of which can contain objects collectively known as their payload. A Maybe object is either a Just object or the unique object Nothing (which has no payload); an Either object is either a Right object or a Left object. Maybe represents the concept of optional values; Either represents the concept of values which are either correct (Right) or errors (Left).
Note that the terms Maybe, Just, Nothing, Either, Right, and Left are capitalized in this SRFI so as not to be confused with their ordinary use as English words. Thus "returns Nothing" means "returns the unique Nothing object"; "returns nothing" could be interpreted as "returns no values" or "returns an unspecified value".
188
Splicing binding constructs for syntactic keywords
, by Marc Nieper-Wißkirchen
Final:
2020-06-03
Keywords:
Syntax
See also
SRFI 93: R6RS Syntax-Case Macros
and
SRFI 148: Eager syntax-rules
Splicing binding constructs for syntactic keywords are versions of
let-syntax
and
letrec-syntax
that can be used in a definition context in the same way as
begin
187
ALAMBDA and ADEFINE
, by Joo ChurlSoo
Based on SRFI 92.
Withdrawn:
2020-03-27
Keywords:
Miscellaneous
Type Checking
See also
SRFI 92: ALAMBDA and ALAMBDA*
and
SRFI 182: ADBMAL, ALET, and ALET*
This SRFI introduces alambda, which creates a procedure that checks its actual arguments, takes various types of required and optional variables.
This SRFI is based on
SRFI 92
as an extension of the optional arguments of
SRFI 182
186
Transcoders and transcoded ports
, by John Cowan
Based on R6RS.
Withdrawn:
2020-09-08
Keywords:
I/O
Superseded
See also
SRFI 80: Stream I/O
SRFI 81: Port I/O
, and
SRFI 181: Custom ports (including transcoded ports)
This is an extract from the R6RS that documents its support for transcoders and transcoded ports. These provide a hook into the Scheme port system from below, allowing the creation of textual ports that provide non-default encoding and decoding from arbitrary binary ports. It has been lightly edited to fit R7RS style.
185
Linear adjustable-length strings
, by John Cowan
Final:
2020-04-26
Keywords:
Data Structure
Text
See also
SRFI 13: String Libraries
SRFI 118: Simple adjustable-size strings
SRFI 130: Cursor-based string library
SRFI 140: Immutable Strings
, and
SRFI 152: String Library (reduced)
Scheme specifies mutable fixed-length strings.
SRFI 118
adds two procedures,
string-append!
and
string-replace!
, which allow the length of the string to change.
This SRFI provides two linear-update versions of these procedures:
that is, the implementation may change the string length or return a
new string instead.
In addition, two convenience macros are provided that make the
procedures somewhat easier to use.
184
define-record-lambda
, by Joo ChurlSoo
Withdrawn:
2020-03-27
Keywords:
Data Structure
Record Type
See also
SRFI 9: Defining Record Types
and
SRFI 100: define-lambda-object
This SRFI introduces a macro, DEFINE-RECORD-LAMBDA, that defines a set of procedures, that is, a group of constructors and a predicate. The constructors also make a group of procedures, namely record lambdas, that have no explicit field accessors and mutators. They can have various kinds of fields, such as common fields, required fields, optional fields, automatic fields, read-only fields, read-write fields, invisible fields, immutable fields, and virtual fields.
183
Another format procedure, Fox
, by Joo ChurlSoo
Withdrawn:
2020-03-27
Keywords:
I/O
See also
SRFI 54: Formatting
This SRFI introduces the formatting procedure Fox ("format of X"), which takes one required argument and a variable number of additional arguments and returns a formatted string.
182
ADBMAL, ALET, and ALET*
, by Joo ChurlSoo
Withdrawn:
2020-03-27
Keywords:
Data Structure
Multiple-Value Returns
See also
SRFI 2: AND-LET*: an AND with local bindings, a guarded LET* special form
SRFI 11: Syntax for receiving multiple values
SRFI 51: Handling rest list
SRFI 54: Formatting
SRFI 71: Extended LET-syntax for multiple values
, and
SRFI 86: MU and NU simulating VALUES & CALL-WITH-VALUES, and their related LET-syntax
Unlike the VALUES and CALL-WITH-VALUES mechanism of R5RS, this one uses an explicit representation for multiple return values as a single value, namely a procedure. Decomposition of multiple values is done by simple application. The macro, ADBMAL, evaluates to a procedure that takes one procedure argument. The ADBMAL macro can be compared with LAMBDA. While a LAMBDA expression that consists of and requires some actual arguments later when the evaluated LAMBDA expression is called, an ADBMAL expression that consists of s corresponding to actual arguments of LAMBDA requires and , that is, an evaluated LAMBDA expression, later when the evaluated ADBMAL expression is called.
This SRFI also introduces the new LET-syntax ALET and ALET*, which depend on ADBMAL to manipulate multiple values, and which are compatible with LET and LET* of R5RS in single-value bindings. They also have a binding form making use of VALUES and CALL-WITH-VALUES to handle multiple values, and new binding forms for list, cons, and other multiple values. In addition, they have several new binding forms for useful functions such as escape, iteration, optional arguments, etc.
181
Custom ports (including transcoded ports)
, by John Cowan
Based on R6RS.
Final:
2020-09-08
Keywords:
I/O
See also
SRFI 79: Primitive I/O
SRFI 81: Port I/O
SRFI 82: Stream Ports
SRFI 91: Extended ports
SRFI 186: Transcoders and transcoded ports
, and
SRFI 192: Port Positioning
This SRFI is derived from parts of
library section 8.2.4
library section 8.2.7
library section 8.2.10
, and
library section 8.2.13
of the R6RS. These sections are themselves based on parts of
SRFI 79
SRFI 80
and
SRFI 81
. These procedures provide a hook into the Scheme port system from below, allowing the creation of custom ports that behave as much as possible like the standard file, string, and bytevector ports, but that call a procedure to produce data to input ports or to consume data from output ports. Procedures for creating ports that transcode between bytes and characters are an important special case and are also documented in this SRFI.
180
JSON
, by Amirouche Boubekki
Final:
2020-07-01
Keywords:
I/O
This library describes a JavaScript Object Notation (JSON) parser and printer. It supports JSON that may be bigger than memory.
179
Nonempty Intervals and Generalized Arrays (Updated)
, by Bradley J. Lucier
Final:
2020-06-30
Keywords:
Data Structure
Numbers
See also
SRFI 122: Nonempty Intervals and Generalized Arrays
SRFI 164: Enhanced multi-dimensional Arrays
, and
SRFI 231: Intervals and Generalized Arrays
This SRFI specifies an array mechanism for Scheme. Arrays as defined here are quite general; at their most basic, an array is simply a mapping, or function, from multi-indices of exact integers $i_0,\ldots,i_{d-1}$ to Scheme values. The set of multi-indices $i_0,\ldots,i_{d-1}$ that are valid for a given array form the
domain
of the array. In this SRFI, each array's domain consists of the cross product of nonempty intervals of exact integers $[l_0,u_0)\times[l_1,u_1)\times\cdots\times[l_{d-1},u_{d-1})$ of $\mathbb Z^d$, $d$-tuples of integers. Thus, we introduce a data type called $d$-
intervals
, or more briefly
intervals
, that encapsulates this notion. (We borrow this terminology from, e.g., Elias Zakon's
Basic Concepts of Mathematics
.) Specialized variants of arrays are specified to provide portable programs with efficient representations for common use cases.
178
Bitvector library
, by John Cowan (text) and Wolfgang Corcoran-Mathe (implementation)
Final:
2020-08-25
Keywords:
Data Structure
See also
SRFI 151: Bitwise Operations
and
SRFI 160: Homogeneous numeric vector libraries
This SRFI describes a set of operations on homogeneous bitvectors. Operations analogous to those provided on the other homogeneous vector types described in
SRFI 160
are provided, along with operations analogous to the bitwise operations of
SRFI 151
177
Portable keyword arguments
, by Lassi Kortela
Withdrawn:
2020-07-31
Keywords:
Binding
See also
SRFI 88: Keyword objects
and
SRFI 89: Optional positional and named parameters
Many Scheme implementations have keyword arguments, but they have not been widely standardized. This SRFI defines the macros
lambda/kw
and
call/kw
. They can be used identically in every major implementation currently in use, making it safe to use keyword arguments in portable code. The macros expand to native keyword arguments in Schemes that have them, letting programmers mix portable code and implementation-specific code.
176
Version flag
, by Lassi Kortela
Final:
2020-02-24
Keywords:
Operating System
Library name: version
This SRFI defines a standard command-line flag to get version information from a Scheme implementation. The output is Line-oriented S-expressions which are easy to parse from Scheme, C, and shell scripts and can co-exist with non-S-expression output. A standard vocabulary is defined; extensions are easy to make.
175
ASCII character library
, by Lassi Kortela
Final:
2019-12-20
Keywords:
Data Structure
Library name: ascii
This SRFI defines ASCII-only equivalents to many of the character procedures in standard Scheme plus a few extra ones. Recent Scheme standards are based around Unicode but the significant syntactic elements in many file formats and network protocols are all ASCII. Such low-level code can run faster and its behavior can be easier to understand when it uses ASCII primitives.
174
POSIX Timespecs
, by John Cowan
Final:
2019-12-21
Keywords:
Data Structure
See also
SRFI 19: Time Data Types and Procedures
and
SRFI 170: POSIX API
This SRFI defines the trivial type
timespec
, which is used to represent the
struct timespec
defined by the
OSIX

header
173
Hooks
, by Amirouche Boubekki
Final:
2019-10-24
Keywords:
Miscellaneous
This library describes a mechanism known as hooks. Hooks are a certain kind of extension point in a program that allows interleaving the execution of arbitrary code with the execution of the program without introducing any coupling between the two.
172
Two Safer Subsets of R7RS
, by John Cowan
Final:
2019-11-10
Keywords:
Miscellaneous
This SRFI provides two libraries for use with R7RS that provide a way to sandbox the
eval
procedure to make it safer to use in evaluating Scheme expressions of doubtful provenance. The intention is to call
eval
, passing it an S-expression representing a Scheme procedure and the environment defined by one of these libraries. Since code evaluated by
eval
runs in a null lexical environment, the resulting procedure can then be invoked with less concern about possible side effects.
Use of these libraries does not provide any sort of safety guarantee. There are still many loopholes uncaught, including attempts to process circular structure and over-allocation of memory. The claim is only that the probability of such an attack is reduced, not that it is eliminated. However, using these libraries is a simple provision that is easy to implement and easy to use. For higher safety, it can readily be combined with other provisions.
171
Transducers
, by Linus Björnstam
Final:
2019-10-26
Keywords:
Data Structure
A library implementing transducers — composable algorithmic transformations. Scheme has many different ways of expressing transformations over different collection types, but they are all unique to whatever base type they work on. This SRFI proposes a new construct, the transducer, that is oblivious to the context in which it is being used.
170
POSIX API
, by Olin Shivers (original author), John Cowan (editor and shepherd), and Harold Ancell (implementer and editor)
Based on scsh by Olin Shivers.
Final:
2020-10-28
Keywords:
Operating System
See also
SRFI 198: Foreign Interface Status
The host environment is the set of resources, such as the filesystem, network and processes, that are managed by the operating system on top of which a Scheme program is executing. This SRFI specifies some of the ways the host environment can be accessed from within a Scheme program. It does so by leveraging widespread support for P
OSIX
, the Portable Operating System Interface standardized by the IEEE. Not all of the functions of this SRFI are available on all operating systems.
169
Underscores in numbers
, by Lassi Kortela
Final:
2019-07-26
Keywords:
Numbers
Reader Syntax
Many people find that large numbers are easier to read when the digits are broken into small groups. For example, the number
1582439
might be easier to read if written as
1 582 439
. This applies to source code as it does to other writing. We propose an extension of Scheme syntax to allow the underscore as a digit separator in numerical constants.
168
Generic Tuple Store Database
, by Amirouche Boubekki
Final:
2019-11-08
Keywords:
I/O
See also
SRFI 167: Ordered Key Value Store
and
SRFI 173: Hooks
This library is a generic approach to the database abstractions known as triplestore and quadstore. Generic Tuple Store Database implements n-tuple ordered sets and associated primitives for working with them in the context of data management.
167
Ordered Key Value Store
, by Amirouche Boubekki
Final:
2019-11-08
Keywords:
I/O
See also
SRFI 168: Generic Tuple Store Database
and
SRFI 173: Hooks
This library describes an interface for an ordered key-value store that is suitable for implementing a storage engine for the generic tuple-store SRFI. It maps cleanly to existing ordered key-value databases that may or may not provide transactions.
166
Monadic Formatting
, by Alex Shinn
Final:
2020-07-30
Keywords:
I/O
Text
See also
SRFI 13: String Libraries
SRFI 159: Combinator Formatting
, and
SRFI 165: The Environment Monad
A library of procedures for formatting Scheme objects to text in various ways, and for easily concatenating, composing and extending these formatters efficiently without resorting to capturing and manipulating intermediate strings.
This SRFI is an updated version of SRFI 159, primarily with the difference that state variables are hygienic.
Summary of differences from SRFI 159:
State variables are first class and hygienic
Added
written-shared
pretty-shared
Added
as-italic
as-color
as-true-color
on-
color
background variants, and
pretty-with-color
Added
ambiguous-is-wide?
state variable and
string-terminal-width/wide
utility
Added
substring/width
state var for width-aware substring operations, with
substring-terminal-width(/wide)
utilities
Added
substring/preserve
state var used in trimming, with
substring-terminal-preserve
utility
Added
pretty-environment
state variable
Renamed
as-unicode
to
terminal-aware
Restored non-uniform comma rules as needed in India
Restored
upcased
and
downcased
Several clarifications and more examples
165
The Environment Monad
, by Marc Nieper-Wißkirchen
Final:
2019-09-05
Keywords:
Miscellaneous
See also
SRFI 159: Combinator Formatting
and
SRFI 166: Monadic Formatting
Monads model computations. The environment monad models computations that depend on values from a shared environment. These computations can read values from the environment, pass values to subsequent computations, execute sub-computations in an extended environment, and modify the environment for future computations.
164
Enhanced multi-dimensional Arrays
, by Per Bothner
Final:
2019-08-08
Keywords:
Data Structure
See also
SRFI 4: Homogeneous numeric vector datatypes
SRFI 25: Multi-dimensional Array Primitives
SRFI 122: Nonempty Intervals and Generalized Arrays
, and
SRFI 163: Enhanced array literals
This SRFI describes the array data type (a generalization of vectors to multiple indexes or dimensions), along with a set of procedures for working on them.
This specification is an extension of
SRFI 25
, with additions from Racket’s
math.array
package and other sources. It has been implemented in the
Kawa dialect of Scheme
163
Enhanced array literals
, by Per Bothner
Final:
2019-01-18
Keywords:
Reader Syntax
See also
SRFI 4: Homogeneous numeric vector datatypes
SRFI 25: Multi-dimensional Array Primitives
SRFI 48: Intermediate Format Strings
SRFI 58: Array Notation
SRFI 58: Array Notation
SRFI 122: Nonempty Intervals and Generalized Arrays
SRFI 160: Homogeneous numeric vector libraries
SRFI 164: Enhanced multi-dimensional Arrays
, and
SRFI 268: Multidimensional Array Literals
This is a specification of a reader form (literals) for multi-dimensional arrays. It is an extension of the Common Lisp array reader syntax to handle non-zero lower bounds, optional explicit bounds, and optional uniform element types (compatible with
SRFI 4
). It can be used in conjunction with
SRFI 25
SRFI 122
, or
SRFI 164
. These extensions were implemented in Guile (except the handling of rank-0 arrays), and later in Kawa.
There are recommendations for output formatting and a suggested
format-array
procedure.
162
Comparators sublibrary
, by John Cowan
Final:
2019-08-27
Keywords:
Comparison
See also
SRFI 114: Comparators
and
SRFI 128: Comparators (reduced)
This SRFI provides a few extra procedures and comparators to go with SRFI 128, Comparators. Implementers are urged to add them to their SRFI 128 libraries, for which reason they are not packaged as a separate library.
161
Unifiable Boxes
, by Marc Nieper-Wißkirchen
Final:
2019-02-08
Keywords:
Data Structure
See also
SRFI 111: Boxes
Unifiable boxes are, like the boxes of
SRFI 111
, objects with a single mutable state. A constructor, predicate, accessor, and mutator are provided.
In addition to this, an equality predicate and union operations (link, union, unify) are provided. Applying a union operation to two unifiable boxes makes the two boxes equal (in the sense of the equality predicate). As a consequence, their state will also become identical. In the case of link and union, it will be the state of one of the two unioned boxes. In the case of unify, the state is determined by a supplied unification procedure.
Unifiable boxes are also known under the names
disjoint-set data structure
union–find data structure
or
merge–find set
160
Homogeneous numeric vector libraries
, by John Cowan and Shiro Kawai (contributed a major patch)
Based on SRFI 4 by Marc Feeley.
Final:
2019-08-27
Keywords:
Data Structure
R7RS Large
R7RS Large: Tangerine Edition
See also
SRFI 4: Homogeneous numeric vector datatypes
SRFI 74: Octet-Addressed Binary Blocks
SRFI 133: Vector Library (R7RS-compatible)
, and
SRFI 152: String Library (reduced)
This SRFI describes a set of operations on SRFI 4 homogeneous vector types (plus a few additional types) that are closely analogous to the vector operations library,
SRFI 133
. An external representation is specified which may be supported by the
read
and
write
procedures and by the program parser so that programs can contain references to literal homogeneous vectors.
159
Combinator Formatting
, by Alex Shinn
Withdrawn:
2020-07-31
Keywords:
I/O
R7RS Large
R7RS Large: Tangerine Edition
Superseded
Text
See also
SRFI 28: Basic Format Strings
SRFI 48: Intermediate Format Strings
, and
SRFI 166: Monadic Formatting
A library of procedures for formatting Scheme objects to text in various ways, and for easily concatenating, composing and extending these formatters efficiently without resorting to capturing and manipulating intermediate strings.
158
Generators and Accumulators
, by Shiro Kawai, John Cowan, and Thomas Gilray
Final:
2017-10-27
Keywords:
Data Structure
R7RS Large
R7RS Large: Tangerine Edition
Library name: generators-and-accumulators
See also
SRFI 121: Generators
This SRFI defines utility procedures that create, transform, and consume generators. A generator is simply a procedure with no arguments that works as a source of values. Every time it is called, it yields a value. Generators may be finite or infinite; a finite generator returns an end-of-file object to indicate that it is exhausted. For example,
read-char
read-line
, and
read
are generators that generate characters, lines, and objects from the current input port. Generators provide lightweight laziness.
This SRFI also defines procedures that return accumulators. An accumulator is the inverse of a generator: it is a procedure of one argument that works as a sink of values.
157
Continuation marks
, by Marc Nieper-Wißkirchen
Withdrawn:
2023-06-29
Keywords:
Continuations
Continuation marks are a programming language feature that allows one to attach information to and retrieve information from continuations, generalizing stack inspection. Conceptually, a continuation consists of a number of frames where each frame stands for an active procedure call that is not a tail call. A continuation mark is then a key-value pair associated with a frame, with keys compared using
eq?
. At most one mark for a given key can be attached to a single frame.
Besides stack inspection, continuation marks can be used to implement dynamic scope, delimited continuations, or delayed evaluation that is able to handle iterative lazy algorithms.
This SRFI proposes to add continuation marks to the Scheme programming language. The interface defined here is modelled after Racket's continuation marks. It does not include all forms and procedures provided by Racket but provides a compatible subset.
156
Syntactic combiners for binary predicates
, by Panicz Maciej Godek
Final:
2017-12-18
Keywords:
Syntax
Library name: predicate-combiners
See also
SRFI 26: Notation for Specializing Parameters without Currying
Recognizing binary predicates as a specific area in which the use of prefix operators is an impediment, we propose a thin layer of "syntactic stevia" for in-fixing such predicates. It can be implemented using regular Scheme macros. We suggest that the code
(is x < y)
should be transformed to
(< x y)
, and
(is x < y <= z)
-- to
(let ((y* y)) (and (< x y*) (<= y* z)))
. In addition, we suggest special meaning to the
symbol:
(is _ < y)
and
(is x < _)
should be transformed to
(lambda (_) (< _ y))
and
(lambda (_) (< x _))
, respectively. This SRFI document also describes some other uses of the
is
macro and its limitations.
155
Promises
, by Marc Nieper-Wißkirchen
Withdrawn:
2023-06-29
Keywords:
Data Structure
Lazy Evaluation
See also
SRFI 45: Primitives for Expressing Iterative Lazy Algorithms
Scheme, like ML, is a programming language with strict evaluation while others, like Haskell, use lazy evaluation. Scheme, however, possesses the primitives
delay
and
force
that make it possible to express lazy algorithms.
Lazy evaluation does not go well in conjunction with imperative, non-functional, side-effecting code. It should, however, be applicable in a purely functional setting. This is the case for the delayed evaluation model as described in the R7RS as long as no dynamically bound variables, also known as parameter objects, are present. It is the purpose of this SRFI to rework the specification in the R7RS so that lazy evaluation works with purely functional code that makes use of dynamic environments or, more generally, the dynamic extent. This is done by remembering the dynamic extent in effect when the
delay
expression is evaluated.
Another perceived misfeature of the R7RS model of delayed evaluation is the apparent need of the
delay-force
special form to express iterative lazy algorithms. It is shown that the
delay-force
special form is unneeded and that the implementation can (and should) handle iterative lazy algorithms without space leaks.
154
First-class dynamic extents
, by Marc Nieper-Wißkirchen
Withdrawn:
2023-06-29
Keywords:
Miscellaneous
See also
SRFI 157: Continuation marks
Scheme has the notion of the
dynamic extent
of a procedure call. A number of standard Scheme procedures and syntaxes like
dynamic-wind
call-with-current-continuation
, and
parameterize
deal with the dynamic extent indirectly. The same holds true for the procedures and syntaxes dealing with continuation marks as defined by
SRFI 157
This SRFI reifies the dynamic extent into a first-class value together with a well-defined procedural interface and a syntax to create procedures that remember not only their environment at creation time but also their dynamic extent, which includes their dynamic environment.
153
Ordered Sets
, by John Cowan
Final:
2023-05-01
Keywords:
Data Structure
See also
SRFI 128: Comparators (reduced)
and
SRFI 146: Mappings
Osets
are immutable collections that can contain any Scheme objects as long as a total order exists among the objects. Osets enforce the constraint that no two elements can be the same in the sense of the oset's associated
equality predicate
. The elements in an oset appear in a fixed order determined by the comparator used to create it.
152
String Library (reduced)
, by John Cowan
Final:
2017-10-04
Keywords:
Data Structure
Text
Library name: strings
See also
SRFI 130: Cursor-based string library
and
SRFI 135: Immutable Texts
Scheme has an impoverished set of string-processing utilities, which is a problem for authors of portable code. This SRFI proposes a coherent and comprehensive set of string-processing procedures. It is a reduced version of SRFI 13 that has been aligned with SRFI 135, Immutable Texts. Unlike SRFI 13, it has been made consistent with the R5RS, R6RS, and R7RS-small string procedures.
151
Bitwise Operations
, by John Cowan
Final:
2017-07-10
Keywords:
Data Structure
R7RS Large
R7RS Large: Tangerine Edition
Numbers
Library name: bitwise-operations
See also
SRFI 142: Bitwise Operations
This SRFI proposes a coherent and comprehensive set of procedures for performing bitwise logical operations on integers; it is accompanied by a reference implementation of the spec in terms of a set of seven core operators. The sample implementation is portable, as efficient as practical with pure Scheme arithmetic (it is much more efficient to replace the core operators with C or assembly language if possible), and open source.
The precise semantics of these operators is almost never an issue. A consistent, portable set of
names
and
parameter conventions
, however, is. Hence this SRFI, which is based mainly on
SRFI 33
, with some changes and additions from
Olin's late revisions to SRFI 33
(which were never consummated).
SRFI 60
(based on SLIB) is smaller but has a few procedures of its own; some of its procedures have both native (often Common Lisp) and SRFI 33 names. They have been incorporated into this SRFI.
R6RS
is a subset of SRFI 60, except that all procedure names begin with a
bitwise-
prefix. A few procedures have been added from the general vector
SRFI 133
Among the applications of bitwise operations are: hashing, Galois-field calculations of error-detecting and error-correcting codes, cryptography and ciphers, pseudo-random number generation, register-transfer-level modeling of digital logic designs, Fast-Fourier transforms, packing and unpacking numbers in persistent data structures, space-filling curves with applications to dimension reduction and sparse multi-dimensional database indexes, and generating approximate seed values for root-finders and transcendental function algorithms.
This SRFI differs from SRFI 142 in only two ways:
The
bitwise-if
function has the argument ordering of SLIB, SRFI 60, and R6RS rather than the ordering of SRFI 33.
The order in which bits are processed by the procedures listed in the "Bits conversion" section has been clarified and some of the procedures' names have been changed. See "Bit processing order" for details.
150
Hygienic ERR5RS Record Syntax (reduced)
, by Marc Nieper-Wißkirchen
Final:
2018-01-16
Keywords:
Data Structure
Record Type
See also
SRFI 9: Defining Record Types
SRFI 99: ERR5RS Records
SRFI 131: ERR5RS Record Syntax (reduced)
SRFI 136: Extensible record types
, and
SRFI 237: R6RS Records (refined)
This SRFI provides a specification and portable implementation of an extension of the ERR5RS record syntax of
SRFI 131
, where field names inserted by macro transformers are effectively renamed as if the macro transformer inserted a binding. This makes this SRFI compatible with the semantics of the record-type definitions of the
R7RS
as intended by its
authors
. In addition, field names may also be other types of Scheme datums, like numbers and strings, or
SRFI 88
keyword objects.
149
Basic Syntax-rules Template Extensions
, by Marc Nieper-Wißkirchen
Final:
2017-07-08
Keywords:
Syntax
The rules for valid