2.1 Standard conformance

Gauche conforms “Revised^7 Report of Algorithmic Language Scheme,” (R7RS) including optional syntax and procedures. We cover R7RS small language (see R7RS small language), as well as part of R7RS large libraries (see R7RS large).

• Gauche has a special kind of symbols, called keywords. They’re symbols with its name beginning with a colon (e.g. :key), but behaves as if it is automatically bound to itself. See Keywords, for the details. Keywords are used extensively when passing so-called keyword arguments (see Making procedures).
• Continuations created in a certain situation (specifically, inside a Scheme code that is called from external C routine) have limited extent (See Continuations, for details).
• Full numeric tower (integer, rational, real and complex numbers) are supported, but rationals are only exact, and complex numbers are always inexact.

Note that, since Gauche predates R7RS, most existing Gauche source code doesn’t follow the R7RS program/library structure. Gauche can read both traditional Gauche modules/scripts and R7RS programs/libraries seamlessly. See Library modules - R7RS standard libraries, for the details of how R7RS is integrated into Gauche.

Gauche also supports the following SRFIs (Scheme Request for Implementation).

SRFI-0, Feature-based conditional expansion construct.

This has become a part of R7RS small. Gauche supports this as Built-in. See Feature conditional.

SRFI-1, List library (R7RS lists)

This has become a part of R7RS large. See R7RS lists. (Some of SRFI-1 procedures are built-in).

SRFI-2, AND-LET*: an AND with local bindings, a guarded LET* special form.

Supported natively. See Binding constructs.

SRFI-4, Homogeneous numeric vector datatypes.

The module gauche.uvector provides a superset of srfi-4 procedures, including arithmetic operations and generic interface on the SRFI-4 vectors. See Uniform vectors.

SRFI-5, A compatible let form with signatures and rest arguments

Supported by the module srfi-5. See A compatible let form with signatures and rest arguments.

SRFI-6, Basic String Ports.

This has become a part of R7RS small. Gauche supports this as built-in. See String ports.

SRFI-7, Feature-based program configuration language

Supported as an autoloaded macro. See Feature-based program configuration language.

SRFI-8, receive: Binding to multiple values.

Syntax receive is built-in. See Binding constructs.

SRFI-9, Defining record types.

Supported by the module gauche.record. See Record types.

SRFI-10, Sharp-comma external form.

Built-in. See Read-time constructor.

SRFI-11, Syntax for receiving multiple values.

This has become a part of R7RS small. Gauche supports it as built-in. See Binding constructs.

SRFI-13, String library

Supported by the module srfi-13. See String library. (Some of SRFI-13 procedures are built-in).

SRFI-14, Character-set library

This has become a part of R7RS large. Character-set object and a few procedures are built-in. See Character sets. Complete set of SRFI-14 is supported by the module scheme.charset. See R7RS character sets.

SRFI-16, Syntax for procedures of variable arity (case-lambda)

This has become a part of R7RS small. Built-in. See Making procedures.

SRFI-17, Generalized set!

Built-in. See Assignments.

SRFI-18, Multithreading support

Some SRFI-18 features are built-in, and the rest is in gauche.threads module. See Threads.

SRFI-19, Time Data Types and Procedures.

Time data type is Gauche built-in (see Time). Complete set of SRFI-19 is supported by the module srfi-19. See Time data types and procedures.

SRFI-22, Running Scheme scripts on Unix

Supported. See Writing Scheme scripts.

SRFI-23, Error reporting mechanism.

This has become a part of R7RS small. Built-in. See Signaling exceptions.

SRFI-25, Multi-dimensional array primitives.

Supported by the module gauche.array, which defines superset of SRFI-25. See Arrays.

SRFI-26, Notation for specializing parameters without currying.

Built-in. See Making procedures.

SRFI-27, Sources of Random Bits.

Supported by the module srfi-27. See Sources of random bits.

SRFI-28, Basic format strings.

Gauche’s built-in format procedure is a superset of SRFI-28 format. See Output.

SRFI-29, Localization

Supported by the module srfi-29. See Localization.

SRFI-30, Nested multi-line comments.

This has become a part of R7RS small. Supported by the native reader. See Lexical structure.

SRFI-31, A special form rec for recursive evaluation. Built-in.

See Binding constructs.

SRFI-34, Exception Handling for Programs

This has become a part of R7RS small. Built-in. See Exceptions.

SRFI-35, Conditions

Built-in. See Conditions.

SRFI-36, I/O Conditions

Partly supported. See Conditions.

SRFI-37, args-fold: a program argument processor

Supported by the module srfi-37. See A program argument processor.

SRFI-38, External Representation for Data With Shared Structure

Built-in. See Reading data and Output.

SRFI-39, Parameter objects

This has become a part of R7RS small. Built-in (see Parameters).

SRFI-40, A Library of Streams

Supported by the module util.stream. See Stream library.

SRFI-41, Streams

This has become a part of R7RS large. See R7RS stream. Most of stream procedures are also in util.stream (see Stream library).

SRFI-42, Eager comprehensions

Supported by the module srfi-42. See Eager comprehensions.

SRFI-43, Vector library

Supported by the module srfi-43. See Vector library (Legacy). Note that this srfi is superseded by R7RS scheme.vector library (formerly known as srfi-133). See R7RS vectors.

SRFI-45, Primitives for Expressing Iterative Lazy Algorithms

Built-in. See Lazy evaluation.

SRFI-46, Basic Syntax-rules Extensions

This has become a part of R7RS small. Built-in. See Hygienic macros.

SRFI-55, require-extension

Supported as an autoloaded macro. See Requiring extensions.

SRFI-60, Integers as bits

Most procedures are built-in: See R7RS bitwise operations. The complete support is in srfi-60 module: See Integers as bits.

SRFI-61, A more general cond clause

Supported natively. See Conditionals.

SRFI-62, S-expression comments

This has become a part of R7RS small. Supported by the native reader. See Lexical structure.

SRFI-64, A Scheme API for test suites

Supported by the module srfi-64. See A Scheme API for test suites.

SRFI-66, Octet vectors

Supported by the module srfi-66 (see Octet vectors). This is mostly a subset of gauche.uvector, but has one slight difference.

SRFI-69, Basic hash tables

Supported by the module srfi-69 (see Basic hash tables). Note that this srfi is superseded by R7RS scheme.hash-table library (formerly known as srfi-125). See R7RS hash tables.

SRFI-74, Octet-addressed binary blocks

Supported by the module srfi-74 (see Octet-addressed binary blocks).

SRFI-78, Lightweight testing

Supported by the module srfi-78. It can work with gauche.test. See Lightweight testing.

SRFI-87, => in case clauses

This has become a part of R7RS small. Supported natively. See Conditionals.

SRFI-95, Sorting and merging

Supported natively. See Sorting and merging.

SRFI-96, SLIB Prerequisites

This srfi is not exactly a library, but rather a description of features the platform should provide to support SLIB. In order to load this module, SLIB must be already installed. See SLIB, for the details.

SRFI-98, An interface to access environment variables

Supported by the module srfi-98. See Accessing environment variables.

SRFI-99, ERR5RS Records

Supported by the module gauche.record. See Record types.

SRFI-101, Purely functional random-access pairs and lists

This has become a part of R7RS large. Supported by the module scheme.rlist.

SRFI-106, Basic socket interface

Supported by the module srfi-106. See Basic socket interface.

SRFI-111, Boxes

This has become a part of R7RS large as scheme.box. Gauche has it as built-in. See Boxes.

SRFI-112, Environment inquiry

Supported by the module srfi-112. See Portable runtime environment inquiry.

SRFI-113, Sets and Bags

This has become a part of R7RS large. Supported by the module scheme.set. See R7RS sets.

SRFI-114, Comparators

Some of the features are built-in (see Basic comparators). Full srfi spec is supported by the module srfi-114 (see Comparators).

SRFI-115, Scheme Regular Expressions

This has become a part of R7RS large. Supported by the module scheme.regex. See R7RS regular expressions.

SRFI-116, Immutable List Library

This has become a part of R7RS large. Immutable pairs are supported natively (see Mutable and immutable pairs). Full set of APIs are available in the module scheme.ilist (see R7RS immutable lists).

SRFI-117, Queues based on lists.

This has become a part of R7RS large. Supported by the module scheme.list-queue, which is implemented on top of data.queue. (see R7RS list queues)

SRFI-118, Simple adjustable-size strings

Supported by the module srfi-118. (see Simple adjustable-size strings)

SRFI-120, Timer APIs

Supported by the module srfi-120 (see Timer APIs). It is a wrapper of control.scheduler (see Scheduler).

SRFI-121, Generators

This has become a part of R7RS large. Gauche’s gauche.generator is superset of srfi-121 (see Generators).

SRFI-124, Ephemerons

This has become a part of R7RS large. Supported by scheme.ephemeron. Note: Current Gauche’s implementation isn’t optimal. See R7RS ephemerons.

SRFI-125, Intermediate hash tables

This has become a part of R7RS large. Supported by scheme.hash-table (see R7RS hash tables). Note that Gauche’s native interface provides the same functionalities, but under slightly different names for the backward compatibility. See Hashtables.

SRFI-127, Lazy sequences

This has become a part of R7RS large. Supported by scheme.lseq (see R7RS lazy sequences).

SRFI-128, Comparators (reduced)

This has become a part of R7RS large. Built-in. See Basic comparators, for the details.

SRFI-129, Titlecase procedures

The procedures char-title-case? and char-titlecase are built-in, and string-titlecase is in gauche.unicode. For the compatibility, you can (use srfi-129) or (import (srfi 129)) to get these three procedures.

SRFI-130, Cursor-based string library

String cursors are supported natively (see String cursors). Most of built-in and srfi-13 string procedures accept cursors in addition to indexes. The module srfi-130 provides several procedures that has the same name as srfi-13 but returns a string cursor instead of an index (see Cursor-based string library).

SRFI-131, ERR5RS Record Syntax (reduced)

This srfi is a pure subset of srfi-99, and gauche.record’s define-record-type covers it. See Record types.

SRFI-132, Sort libraries

This has become a part of R7RS large. Supported by the module scheme.sort. See R7RS sort.

SRFI-133, Vector library (R7RS-compatible)

This has become a part of R7RS large. Supported by the module scheme.vector. See R7RS vectors.

SRFI-134, Immutable Deques

This has become a part of R7RS large. The module data.ideque is compatible to srfi-134. See Immutable deques.

SRFI-135, Immutable Texts

This has become a part of R7RS large. In Gauche, the text type is not disjoint from the string type. Instead, a text is simply an immutable and indexed string. See String indexing, for the detail of indexed string. The API is described in R7RS immutable texts.

SRFI-141, Integer division

This has become a part of R7RS large. Supported by the module scheme.division. See R7RS integer division.

SRFI-143, Finxums

This has become a part of R7RS large. Supported by the module scheme.fixnum. See R7RS fixnum.

SRFI-144, Flonums

This has become a part of R7RS large. Supported by the module scheme.flonum. See R7RS flonum.

SRFI-145, Assumptions

Built-in. See Conditionals.

SRFI-146, Mappings

This has become a part of R7RS large. Supported by the module scheme.mapping. See R7RS mappings.

SRFI-149, Basic syntax-rules template extensions

The built-in syntax-rules support srfi-149.

SRFI-151, Bitwise operations

Supported by the module srfi-151 (see R7RS bitwise operations). Note that many equivalent procedures are provided built-in (see Basic bitwise operations).

SRFI-152, String library (reduced)

Supported by the module srfi-152 (see String library (reduced)).

SRFI-154, First-class dynamic extents

Suppored by the module srfi-154. (see First-class dynamic extents).

SRFI-158, Generators and accumulators

This has become a part of R7RS large. Supported by the module scheme.generator (see R7RS generators). Note that most of generator procedures are supported by gauche.generator (see Generators).

SRFI-159, Combinator Formatting

This has become a part of R7RS large. See R7RS combinator formatting.

SRFI-160, Homogeneous numeric vector libraries

This has become a part of R7RS large, supported by the module scheme.vector.@ where @ is one of base, u8, s8, u16, s16, u32, s32, u64, s64, f32, f64, c64, or c128 (see R7RS uniform vectors).

SRFI-162, Comparators sublibrary

Supported by the module srfi-162. See Comparator sublibrary.

SRFI-170, POSIX API

Supported by the module srfi-170. See POSIX API.

SRFI-173, Hooks

Supported by the module srfi-173 (see Hooks (srfi)), which is a thin layer on top of gauche.hook (see Hooks)

SRFI-174, POSIX Timespecs

Supported by the module srfi-174 (see POSIX timespecs). In Gauche, the timespec type is the same as built-in <time> object, which is also the same as srfi-19 time.

SRFI-175, ASCII character library

Supported by the module srfi-175 (see ASCII character library).

SRFI-176, Version flag

Supported as a command-line flag of gosh. The version-alist procedure is built-in.

SRFI-178, Bitvector library

The basic support is built-in (see Bitvectors). Complete support is in the module srfi-178 (see Bitvector library.

SRFI-180, JSON

Supported by the module srfi-180 (see JSON). Note that Gauche also has rfc.json, and srfi-180 is implemented on top of it.

SRFI-181, Custom ports

Supported by the module srfi-181 (see Custom ports). Gauche has an original custom port mechanism (see Virtual ports), and This srfi is built in top of it.

SRFI-185, Linear adjustable-length strings

Supported by the module srfi-185. See Linear adjustable-length strings.

SRFI-189, Maybe and Either: optional container types

Supported by the module srfi-189.

SRFI-192, Port positioning

Gauche’s port already has positining mechanism, so main procedures are built-in (see Common port operations). A few additional procedures are provided by the module srfi-192 (see Port positioning).

SRFI-193, Command line

Two procedures, command-line and script-file, are built-in. Other APIs are provided by the module srfi-193 (see Command line).

SRFI-195, Multiple-value boxes

Built-in. See Boxes.

SRFI-196, Range objects

Suppored by the module srfi-196. Also the data.range module is the superset of this srfi (see Range).

SRFI-197, Pipeline operators

Supported by the module srfi-197 (see Pipeline operators).

SRFI-217, Integer sets

Supported by the module srfi-217 (see Integer sets).

SRFI-219, Define higher-order lambda

Gauche’s built-in define (both R7RS-compatible one and extended one) supports this feature. If you import srfi-219 explicitly, it imports null#define. See Define higher-order lambda, for the details.

SRFI-221, Generator/accumulator sub-library

Supported by the module srfi-221 (see Generator/accumulator sub-library).

SRFI-229, Tagged procedures

Supported by the module srfi-229 (see Tagged procedures).