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 scheme.list - 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 srfi.5 - 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 srfi.7 - 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 gauche.record - 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 srfi.13 - 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 scheme.charset - 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 gauche.threads - 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 srfi.19 - 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 gauche.array - 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 srfi.27 - 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 srfi.29 - 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 srfi.37 - args-fold: 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 util.stream - Stream library.

SRFI-41, Streams

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

SRFI-42, Eager comprehensions

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

SRFI-43, Vector library

Supported by the module srfi.43. See srfi.43 - Vector library (legacy). Note that this srfi is superseded by R7RS scheme.vector library (formerly known as srfi.133). See scheme.vector - 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 srfi.55 - Requiring extensions.

SRFI-60, Integers as bits

Most procedures are built-in: See scheme.bitwise - R7RS bitwise operations. The complete support is in srfi.60 module: See srfi.60 - 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 srfi.64 - A Scheme API for test suites.

SRFI-66, Octet vectors

Supported by the module srfi.66 (see srfi.66 - 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 srfi.69 - Basic hash tables). Note that this srfi is superseded by R7RS scheme.hash-table library (formerly known as srfi.125). See scheme.hash-table - R7RS hash tables.

SRFI-74, Octet-addressed binary blocks

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

SRFI-78, Lightweight testing

Supported by the module srfi.78. It can work with gauche.test. See srfi.78 - 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 - SLIB interface, for the details.

SRFI-98, An interface to access environment variables

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

SRFI-99, ERR5RS Records

Supported by the module gauche.record. See gauche.record - 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 (see scheme.rlist - R7RS random-access lists).

SRFI-106, Basic socket interface

Supported by the module srfi.106. See srfi.106 - 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 srfi.112 - Environment inquiry.

SRFI-113, Sets and Bags

This has become a part of R7RS large. Supported by the module scheme.set. See scheme.set - 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 srfi.114 - Comparators).

SRFI-115, Scheme Regular Expressions

This has become a part of R7RS large. Supported by the module scheme.regex. See scheme.regex - 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 scheme.ilist - 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 scheme.list-queue - R7RS list queues)

SRFI-118, Simple adjustable-size strings

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

SRFI-120, Timer APIs

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

SRFI-121, Generators

This has become a part of R7RS large. Gauche’s gauche.generator is superset of srfi-121 (see gauche.generator - 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 scheme.ephemeron - R7RS ephemeron.

SRFI-125, Intermediate hash tables

This has become a part of R7RS large. Supported by scheme.hash-table (see scheme.hash-table - 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 scheme.lseq - 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 srfi.130 - 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 gauche.record - Record types.

SRFI-132, Sort libraries

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

SRFI-133, Vector library (R7RS-compatible)

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

SRFI-134, Immutable Deques

This has become a part of R7RS large. The module data.ideque is compatible to srfi-134. See data.ideque - 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 scheme.text - R7RS immutable texts.

SRFI-138, Compiling Scheme programs to executables

Supported, except honoring COMPILE_R7RS environment variable. See gauche-compile-r7rs - Compile scripts, for the details.

SRFI-139, Syntax parameters

Built-in. See Syntax parameters.

SRFI-141, Integer division

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

SRFI-143, Finxums

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

SRFI-144, Flonums

This has become a part of R7RS large. Supported by the module scheme.flonum. See scheme.flonum - 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 scheme.mapping - 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 scheme.bitwise - 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 srfi.152 - String library (reduced)).

SRFI-154, First-class dynamic extents

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

SRFI-158, Generators and accumulators

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

SRFI-159, Combinator Formatting

This has become a part of R7RS large. See scheme.show - 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 scheme.vector.@ - R7RS uniform vectors).

SRFI-162, Comparators sublibrary

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

SRFI-169, Underscores in numbers

Supported by the built-in reader. See Lexical structure.

SRFI-170, POSIX API

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

SRFI-172, Two safer subsets of R7RS

Supported by the modules srfi.172 and srfi.172.functional. See srfi.172 - Two safer subsets of R7RS.

SRFI-173, Hooks

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

SRFI-174, POSIX Timespecs

Supported by the module srfi.174 (see srfi.174 - 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 srfi.175 - 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 srfi.178 - Bitvector library.

SRFI-180, JSON

Supported by the module srfi.180 (see srfi.180 - 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 srfi.181 - Custom ports). Gauche has an original custom port mechanism (see gauche.vport - Virtual ports), and This srfi is built in top of it.

SRFI-185, Linear adjustable-length strings

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

SRFI-189, Maybe and Either: optional container types

Supported by the module srfi.189. See srfi.189 - Maybe and Either: optional container types.

SRFI-190, Coroutine generators

Supported by the module srfi.190. See srfi.190 - Coroutine generators.

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 srfi.192 - 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 srfi.193 - Command line).

SRFI-194, Random data generators

Supported by the module srfi.194 (see srfi.194 - Random data generators (SRFI)), which is based on data.random (see data.random - Random data generators).

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 data.range - Range).

SRFI-197, Pipeline operators

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

SRFI-207, String-notated bytevectors

Bytestring literals are supported by the core. Bytestring procedures are available in the module srfi.207 (see srfi.207 - String-notated bytevectors).

SRFI-209, Enums and enum sets

Supported by the module srfi.209 (see srfi.209 - Enums and enum sets).

SRFI-210, Procedures and syntax for multiple values

Supported by the module srfi.210 (see srfi.210 - Procedures and syntax for multiple values).

SRFI-215, Central log exchange

Supported by the module srfi.215 (see srfi.215 - Central log exchange).

SRFI-216, SICP Prerequisites

Supporetd by the module srfi.216 (see srfi.216 - SICP prerequisites).

SRFI-217, Integer sets

Supported by the module srfi.217 (see srfi.217 - 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 srfi.219 - Define higher-order lambda, for the details.

SRFI-221, Generator/accumulator sub-library

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

SRFI-222, Compound objects

Supported by the module srfi.222 (see srfi.222 - Compound objects).

SRFI-226, Control features

Partially supported as built-in and gauche.threads module. See srfi.226 - Control features for the details.

SRFI-227, Optional arguments

Supported by the module srfi.227 (see srfi.227 - Optional arguments).

SRFI-228, Composing comparators

Supported by the module srfi.228 (see srfi.228 - Composing comparators).

SRFI-229, Tagged procedures

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

SRFI-230, Atomic Operations

Supported by the module srfi.230 (see srfi.230 - Atomic operations).

SRFI-232, Flexible curried procedures

Supported by the module srfi.232 (see srfi.232 - Flexible curried procedures).

SRFI-234, Topological sorting

Supported by the module srfi.234 (see srfi.234 - Topological sorting).

SRFI-235, Combinators (SRFI)

Supported by the module srfi.235 (see srfi.235 - Combinators (SRFI)).

SRFI-236, Evaluating expressions in an unspecified order

Built-in. See Grouping.

SRFI-238, Codesets

Supported by the mdoule srfi.238 (see srfi.238 - Codesets).

SRFI-239, Destructuring lists

Supported by the module srfi.239 (see srfi.239 - Destructuring lists).

SRFI-244, Multiple-value definitions

Built-in. See Definitions.

SRFI-247, Syntactic monads

Supported by the module srfi.247 (see srfi.247 - Syntactic monads).

SRFI-252, Property testing

Supported by the module srfi.252 (see srfi.252 - Property testing.