R7RS Scheme specification:
I have often used (slib format)
for formatting text, which is borrowed from
Lisp. This library provides a schemelike way of formatting text. (Note:
the Tangerine Edition refers to SRFI 159, but that has been withdrawn in
favour of SRFI 166.)
R7RS Name

Documentation

Description

(scheme show)

(srfi 159)

Formatting text

I have used Dorai Sitaram's pregexp library
in the past, which uses a familiar stringbased representation of
regularexpressions. This library, like show
, provides a schemelike way of
describing regular expressions.
R7RS Name

Documentation

Description

(scheme regex)

(srfi 115)

Regular expressions

 Text
 This library introduces an immutable form of a string, called a
text
.
The rationale for this library is that more efficient operations can be
implemented for strings which are immutable, particularly if they are
unicodeencoded. Helpfully, many of the implemented operations work on
"textual" objects, which includes both the new immutable text
data type and
regular string
values.
R7RS Name

Documentation

Description

(scheme text)

(srfi 135)

Immutable strings

 Numbers
 These libraries provide additional functionality and potentially efficient implementations for working with numbers.
R7RS Name

Documentation

Description

(scheme division)

(srfi 141)

Provides six different ways of computing the quotient and remainder (q and r ) when dividing an integer n so that n = dq+r

(scheme bitwise)

(srfi 151)

Treats integers as twoscomplement numbers, and provides a complete set of operators for manipulating integers in bitwise form

(scheme fixnum)

(srfi 143)

Provides efficient implementations of operations on integers which are "small enough" to be treated within a single machine word

(scheme flonum)

(srfi 144)

Provides efficient implementations of operations on flonums, a subset of the full range of inexact real numbers

Data structures (collections) seem to have been a major focus of R7RSlarge
development. The small language has builtin the list and vector datatypes, a
specialisation of vector to bytevectors, and a simple mapping pattern in the
form of association lists.
 Setlike
 Designed to hold one or more values without any additional structure, such as order, imposed on them. Setlike structures may enforce unique values (sets) or permit multiple values (bags, or multisets).
R7RS Name

Documentation

Description

(scheme box)

(srfi 111)

Provides a singleitem container

(scheme set)

(srfi 113)

Provides both set and bag data structures, along with a widerange of supporting functions

(scheme charset)

(srfi 14)

Deals specifically with sets of characters, making available some predefined character sets, and operations to work with such sets

 Listlike
 Designed to hold one or more values in a specific order. Values can be duplicated within the data structure.
R7RS Name

Documentation

Description

(scheme list)

(srfi 1)

Provides a widerange of functions working with the builtin list datatype

(scheme ilist)

(srfi 116)

Provides an immutable version of the builtin list along with functions equivalent to those in the list library, where appropriate

(scheme rlist)

(srfi 101)

An alternative to the builtin list , but offers more efficient references (rlistref is O(log n)) and a functional interface. Note that, unlike the SRFI and implementation in Gauche, the R7RSlarge version prefixes identifiers with "r" to avoid nameclashes with list

(scheme ideque)

(srfi 134)

Provides an immutable deque data struture, a doubleended queue which supports efficient (O(1)) adding/removal of items from either end

(scheme listqueue)

(srfi 117)

A mutable deque data structure, which offers efficient adding/removal of items from the front and adding of items to the back

Vectors are a variant of lists, which both hold values in a specific order, but
also provide O(1) lookup time using a numeric index. The different types allow
for specialisation in terms of the particular contents.
R7RS Name

Documentation

Description

(scheme vector)

(srfi 133)

Provides a widerange of functions working with the builtin vector datatype

(scheme bytevector)

(rnrs bytevectors)

Taken from R6RS

(scheme vector @)

(srfi 160)

Provide homogeneous equivalents to the vector type and library for specific numeric types; these can potentially be implemented more efficiently than the general form

 Maplike
 Collections of keyvalue pairs, where a key is used to retrieve a value stored within the collection. They can be thought of as a generalisation of the vector, except that any type of value can be used as the index, not just a number.
R7RS Name

Documentation

Description

(scheme hashtable)

(srfi 125)

Provides a standard hash table data structure

(scheme mapping)

(srfi 146)

Provides a more general data structure than hashtable , supporting functional procedures

 Streamlike
 These data structures do not store existing values, but instead construct new values on demand.
R7RS Name

Documentation

Description

(scheme generator)

(srfi 158)

Provides both "generators" and "accumulators". A generator is a zeroargument procedure that acts as a source of values; an accumulator is a singleargument procedure that acts as a sink of values

(scheme lseq)

(srfi 127)

A list where the "cdr" element is a generator; this is similar to stream except that the lists are odd, so the first element is eager evaluated

(scheme stream)

(srfi 41)

Provides lowlevel and higherlevel support for lazy lists; lists where each item is constructed on demand. These lists are even, so both elements are lazy evaluated

These libraries are used to support data structures.
R7RS Name

Documentation

Description

(scheme comparator)

(srfi 128)

Bundles together the equality, comparison and hash functions for different datatypes, so they can be used in the construction of a data structure for a specific type of data. This library is used in: hashtable , mapping , and set

(scheme ephemeron)

(srfi 124)

Can be used to implement data structures with weak references, which permit garbage collection

(scheme sort)

(srfi 132)

A collection of sort, merge and related functions, working on the builtin list and vector datatypes

This edition appears to have been
voted on, but there are not many details available yet, e.g. what the `(scheme
NAME)` names will be. Here is a list of what might be expected:
R6RS includes several libraries, which I've tabulated below for easy reference.
R7RSlarge has gradually included a number of approximately equivalent
libraries, so I've listed these to make it easy to link the two standards 
"equivalent" is meant loosely, as there are many variations and even
incompatibilities.
R6RS Name

Description

R7RS Equivalent

(rnrs unicode)

Unicode semantics when working with characters and strings.

Mostly covered in (scheme base) and (scheme char) , although full Unicode support is optional

(rnrs bytevectors)

Deals with blocks of binary data.

(scheme bytevector) included in R7RSlarge (Tangerine)

(rnrs lists)

Useful procedures that operate on lists.

Anything not in (scheme base) is in (scheme list) , included in R7RSlarge (Red)

(rnrs sorting)

Provides listsort and vectorsort .

(scheme sort) included in R7RSlarge (Red)

(rnrs control)

Useful control structures (e.g. when , do ).

Included in (scheme base)

(rnrs records *)

Record datatypes.

An alternative form of record is included in (scheme base)

(rnrs exceptions)

Exception handling and exceptionraising constructs.

Included in (scheme base)

(rnrs conditions)

For creating and inspecting condition types and values.



(rnrs io *)

For performing input and output.

Some support in (scheme base) and (scheme file)

(rnrs files)

Provides fileexists? and deletefile .

Included in (scheme file)

(rnrs programs)

Provides commandline and exit .

Included in (scheme processcontext)

(rnrs arithmetic fixnums)

Various operations on fixnums.

(scheme fixnum) included in R7RSlarge (Tangerine)

(rnrs arithmetic flonums)

Various operations on flonums.

(scheme flonum) included in R7RSlarge (Tangerine)

(rnrs arithmetic bitwise)

Generic operations on exact integer objects.

(scheme bitwise) included in R7RSlarge (Tangerine)

(rnrs syntaxcase)

Support for writing lowlevel macros in a highlevel style.

Included in R7RSlarge (Yellow)

(rnrs hashtables)

Operations for creating and using hashtables.

(scheme hashtable) included in R7RSlarge (Red)

(rnrs enums)

Enumerated values and enumerated sets.

 Although (srfi 209) is scheduled for vote in R7RSlarge (Orange).

Considering the levels of R7RSlarge support in the implementations I use:
 Gauche
 complete support.
 Kawa
 partial support with r7rslibs. Kawa's implementation of continuations  see internals/complications  means
(scheme generator)
and (scheme lseq)
cannot be supported.
 Sagittarius
 complete support.
 Gauche
 complete support.
 Kawa
 partial support with r7rslibs. Missing are
(scheme show)
(scheme regex)
(scheme fixnum)
(scheme flonum)
(scheme bytevector)
(scheme vector @)
(scheme mapping)
 Sagittarius
 complete support, except that
(scheme show)
is named (scheme format)
.
Library Name

Description

Gauche

Kawa

Sagittarius

syntaxcase

From R6RS





Y

identifiercase

From R6RS





Y

(srfi 139)

Syntax parameters





Y

(srfi 188)

Splicing binding constructs for syntactic keywords







(srfi 212)

Aliases



see definealias



(srfi 213

Identifier properties







(srfi 61)

A more general cond clause

builtin



Y

(srfi 8)

receive : Binding to multiple values

Y

Y

Y

(srfi 31)

A special form rec for recursive evaluation

Y

r7rslibs

Y

(srfi 26)

Notation for specializing parameters without currying

Y

Y

Y

(srfi 219)

Define higherorder lambda

Y



builtin

(srfi 210)

Procedures and syntax for multiple values

r7rslibs

r7rslibs

r7rslibs
