For Gauche 0.9.14Search (procedure/syntax/module):

Next: , Previous: , Up: Top   [Contents][Index]

Appendix B Function and Syntax Index

Jump to:   !   $   %   &   (   *   +   -   .   /   :   <   =   >   ?   @   ^   ~  
A   B   C   D   E   F   G   H   I   J   K   L   M   N   O   P   Q   R   S   T   U   V   W   X   Z  
Index Entry  Section

!
!=: CiSE syntax

$
$: Making procedures
$->rope: PEG ropes
$->string: PEG ropes
$->symbol: PEG ropes
$.: PEG primitive parser builders
$any: PEG primitive parser builders
$assert: PEG choice
$between: PEG sequencing combinators
$bind: PEG sequencing combinators
$binding: PEG sequencing combinators
$chain-left: PEG repetition combinators
$chain-right: PEG repetition combinators
$char: PEG primitive parser builders
$char-ci: PEG primitive parser builders
$cut: PEG choice
$debug: PEG miscellaneous combinators
$end-by: PEG repetition combinators
$eos: PEG primitive parser builders
$expect: PEG choice
$fail: PEG primitive parser builders
$fold-parsers: PEG sequencing combinators
$fold-parsers-right: PEG sequencing combinators
$lazy: PEG miscellaneous combinators
$lbinding: PEG sequencing combinators
$let: PEG sequencing combinators
$let*: PEG sequencing combinators
$lift: PEG sequencing combinators
$lift*: PEG sequencing combinators
$list: PEG sequencing combinators
$list*: PEG sequencing combinators
$many: PEG repetition combinators
$many-till: PEG repetition combinators
$many-till_: PEG repetition combinators
$many1: PEG repetition combinators
$many1_: PEG repetition combinators
$many_: PEG repetition combinators
$match1: PEG primitive parser builders
$match1: PEG primitive parser builders
$match1: PEG primitive parser builders
$match1*: PEG primitive parser builders
$match1*: PEG primitive parser builders
$match1*: PEG primitive parser builders
$none-of: PEG primitive parser builders
$not: PEG choice
$one-of: PEG primitive parser builders
$one-of: PEG primitive parser builders
$optional: PEG choice
$or: PEG choice
$or: PEG choice
$parameterize: PEG miscellaneous combinators
$raise: PEG primitive parser builders
$repeat: PEG repetition combinators
$repeat_: PEG repetition combinators
$return: PEG primitive parser builders
$satisfy: PEG primitive parser builders
$sep-by: PEG repetition combinators
$sep-end-by: PEG repetition combinators
$seq: PEG sequencing combinators
$seq0: PEG sequencing combinators
$string: PEG primitive parser builders
$string-ci: PEG primitive parser builders
$try: PEG choice

%
%: CiSE syntax
%=: CiSE syntax
%acos: Backward-compatible real elementary functions
%asin: Backward-compatible real elementary functions
%atan: Backward-compatible real elementary functions
%cos: Backward-compatible real elementary functions
%cosh: Backward-compatible real elementary functions
%cospi: Backward-compatible real elementary functions
%exp: Backward-compatible real elementary functions
%expt: Backward-compatible real elementary functions
%log: Backward-compatible real elementary functions
%macroexpand: Expanding macros manually
%macroexpand-1: Expanding macros manually
%sin: Backward-compatible real elementary functions
%sinh: Backward-compatible real elementary functions
%sinpi: Backward-compatible real elementary functions
%sqrt: Backward-compatible real elementary functions
%tan: Backward-compatible real elementary functions
%tanh: Backward-compatible real elementary functions
%tanpi: Backward-compatible real elementary functions

&
&: CiSE syntax

(
(setter cgi-test-environment-ref): CGI testing
(setter dict-get): Generic functions for dictionaries
(setter object-apply): Applicable objects
(setter port-buffering): Common port operations
(setter ref): Hashtables
(setter ref): Universal accessor
(setter ref): Accessing instance
(setter ref): Fundamental sequence accessors
(setter subseq): Slicing sequence
(setter subseq): Slicing sequence
(setter ~): Universal accessor

*
*: Arithmetics
*: CiSE syntax
*: CiSE syntax
*.: Arithmetics
*=: CiSE syntax

+
+: Arithmetics
+: CiSE syntax
+.: Arithmetics
+=: CiSE syntax

-
-: Arithmetics
-: CiSE syntax
-.: Arithmetics
-=: CiSE syntax
->: CiSE syntax
->char-set: Character-set constructors

.
.$: Combinators
.array: CiSE syntax
.cond: CiSE syntax
.define: CiSE syntax
.define: Stub generation
.function: CiSE syntax
.if: CiSE syntax
.if: Stub generation
.include: CiSE syntax
.include: Stub generation
.raw-c-code: CiSE syntax
.static-decls: CiSE syntax
.struct: CiSE syntax
.type: CiSE syntax
.undef: CiSE syntax
.undef: Stub generation
.union: CiSE syntax
.unless: CiSE syntax
.unless: Stub generation
.when: CiSE syntax
.when: Stub generation

/
/: Arithmetics
/: CiSE syntax
/.: Arithmetics
/=: CiSE syntax

:
:: Eager comprehensions
:char-range: Eager comprehensions
:collection: Eager comprehensions
:dispatched: Eager comprehensions
:do: Eager comprehensions
:do: Eager comprehensions
:generator: Eager comprehensions
:integers: Eager comprehensions
:let: Eager comprehensions
:list: Eager comprehensions
:parallel: Eager comprehensions
:port: Eager comprehensions
:port: Eager comprehensions
:range: Eager comprehensions
:range: Eager comprehensions
:range: Eager comprehensions
:range: Eager comprehensions
:real-range: Eager comprehensions
:real-range: Eager comprehensions
:real-range: Eager comprehensions
:string: Eager comprehensions
:until: Eager comprehensions
:uvector: Eager comprehensions
:vector: Eager comprehensions
:while: Eager comprehensions

<
<: Numerical comparison
<: CiSE syntax
<<: CiSE syntax
<<=: CiSE syntax
<=: Numerical comparison
<=: CiSE syntax
<=?: Comparator predicates and accessors
<?: Comparator predicates and accessors
<gauche-package-description>: Package metainformation

=
=: Numerical comparison
=: CiSE syntax
==: CiSE syntax
=?: Comparator predicates and accessors

>
>: Numerical comparison
>: CiSE syntax
>=: Numerical comparison
>=: CiSE syntax
>=?: Comparator predicates and accessors
>>: CiSE syntax
>>=: CiSE syntax
>?: Comparator predicates and accessors

?
?:: CiSE syntax

@
@?: Uvector basic operations
@vector: Uvector basic operations
@vector->list: Uvector conversion operations
@vector->vector: Uvector conversion operations
@vector-add: Uvector numeric operations
@vector-add!: Uvector numeric operations
@vector-and: Uvector numeric operations
@vector-and!: Uvector numeric operations
@vector-any: Uvector basic operations
@vector-append: Uvector basic operations
@vector-append-subvectors: Uvector basic operations
@vector-clamp: Uvector numeric operations
@vector-clamp!: Uvector numeric operations
@vector-compare: Uvector basic operations
@vector-concatenate: Uvector basic operations
@vector-copy: Uvector basic operations
@vector-copy!: Uvector basic operations
@vector-count: Uvector basic operations
@vector-cumulate: Uvector basic operations
@vector-div: Uvector numeric operations
@vector-div!: Uvector numeric operations
@vector-dot: Uvector numeric operations
@vector-drop: Uvector basic operations
@vector-drop-right: Uvector basic operations
@vector-drop-while: Uvector basic operations
@vector-drop-while-right: Uvector basic operations
@vector-empty?: Uvector basic operations
@vector-every: Uvector basic operations
@vector-fill!: Uvector basic operations
@vector-filter: Uvector basic operations
@vector-fold: Uvector basic operations
@vector-fold-right: Uvector basic operations
@vector-for-each: Uvector basic operations
@vector-index: Uvector basic operations
@vector-index-right: Uvector basic operations
@vector-ior: Uvector numeric operations
@vector-ior!: Uvector numeric operations
@vector-length: Uvector basic operations
@vector-map: Uvector basic operations
@vector-map!: Uvector basic operations
@vector-mul: Uvector numeric operations
@vector-mul!: Uvector numeric operations
@vector-multi-copy!: Uvector basic operations
@vector-partition: Uvector basic operations
@vector-range-check: Uvector numeric operations
@vector-ref: Uniform vectors
@vector-remove: Uvector basic operations
@vector-reverse!: Uvector basic operations
@vector-reverse-copy: Uvector basic operations
@vector-reverse-copy!: Uvector basic operations
@vector-segment: Uvector basic operations
@vector-set!: Uniform vectors
@vector-skip: Uvector basic operations
@vector-skip-right: Uvector basic operations
@vector-sub: Uvector numeric operations
@vector-sub!: Uvector numeric operations
@vector-swap!: Uvector basic operations
@vector-take: Uvector basic operations
@vector-take-right: Uvector basic operations
@vector-take-while: Uvector basic operations
@vector-take-while-right: Uvector basic operations
@vector-unfold: Uvector basic operations
@vector-unfold!: Uvector basic operations
@vector-unfold!: Uvector basic operations
@vector-unfold-right: Uvector basic operations
@vector-unfold-right!: Uvector basic operations
@vector-unfold-right!: Uvector basic operations
@vector-xor: Uvector numeric operations
@vector-xor!: Uvector numeric operations
@vector=: Uvector basic operations
@vector=?: Uvector basic operations
@vector?: Uniform vectors

^
^: Making procedures
^a: Making procedures
^b: Making procedures
^c: Making procedures
^d: Making procedures
^e: Making procedures
^f: Making procedures
^g: Making procedures
^h: Making procedures
^i: Making procedures
^j: Making procedures
^k: Making procedures
^l: Making procedures
^m: Making procedures
^n: Making procedures
^o: Making procedures
^p: Making procedures
^q: Making procedures
^r: Making procedures
^s: Making procedures
^t: Making procedures
^u: Making procedures
^v: Making procedures
^w: Making procedures
^x: Making procedures
^y: Making procedures
^z: Making procedures
^_: Making procedures

~
~: Universal accessor

A
abandoned-mutex-exception?: Thread exceptions
abort-current-continuation: Continuation prompts
abs: Arithmetics
absolute-path?: Pathname utilities
absolute-time: Time
accumulate-generated-values: Generator/accumulator sub-library
acons: Association lists
acos: Arithmetics
acosh: Arithmetics
add-duration: SRFI-19 Time procedures
add-duration!: SRFI-19 Time procedures
add-hook!: Hooks
add-inlet-input-port!: Plumbing ports
add-job!: Thread pools
add-load-path: Loading Scheme file
add-outlet-output-port!: Plumbing ports
address-family: Basic socket interface
address-info: Basic socket interface
adler32: Zlib compression library
alist->bag: R7RS sets
alist->hash-table: Hashtables
alist->hash-table: R7RS hash tables
alist->hash-table: R7RS hash tables
alist->hash-table: Basic hash tables
alist->hashmap: Hashmaps
alist->hashmap!: Hashmaps
alist->imap: Immutable map
alist->imap: Immutable map
alist->imap: Immutable map
alist->mapping: Mappings
alist->mapping!: Mappings
alist->mapping/ordered: Mappings
alist->mapping/ordered!: Mappings
alist->priority-map: Priority map
alist->rbtree: Obsolete and superseded modules
alist->tree-map: Treemaps
alist->tree-map: Treemaps
alist-cons: R7RS lists
alist-copy: Association lists
alist-delete: Association lists
alist-delete!: Association lists
all-modules: Module introspection
all-of: Combinators (SRFI)
allocate-instance: Creating instance
allocate-instance: Creating instance
always: Combinators (SRFI)
and: Conditionals
and: CiSE syntax
and: Eager comprehensions
and-let*: Binding constructs
and-let1: Binding constructs
and-procedure: Combinators (SRFI)
angle: Numerical conversions
any: Walking over lists
any$: Combinators
any-bit-set?: R7RS bitwise operations
any-bits-set?: Integers as bits
any-in-queue: Queue
any-of: Combinators (SRFI)
any-pred: Combinators
any?-ec: Eager comprehensions
append: Other list procedures
append!: Other list procedures
append-ec: Eager comprehensions
append-map: Walking over lists
append-map!: Walking over lists
append-reverse: Other list procedures
append-reverse!: Other list procedures
applicable?: Procedure class and applicability
apply: Procedure class and applicability
apply$: Combinators
apply-chain: Combinators (SRFI)
apply-generic: Customizing method application
apply-method: Customizing method application
apply-methods: Customizing method application
apply/mv: Procedures and syntax for multiple values
approx=?: Numerical comparison
apropos: Interactive session
aref: CiSE syntax
args-fold: A program argument processor
arguments-drop: Combinators (SRFI)
arguments-drop-right: Combinators (SRFI)
arguments-take: Combinators (SRFI)
arguments-take-right: Combinators (SRFI)
arithmetic-shift: R7RS bitwise operations
arity: Procedure arity
arity-at-least-value: Procedure arity
arity-at-least?: Procedure arity
array: Arrays
array->list: Arrays
array->vector: Arrays
array-add-elements: Arrays
array-add-elements!: Arrays
array-concatenate: Arrays
array-copy: Arrays
array-div-elements: Arrays
array-div-elements!: Arrays
array-div-left: Arrays
array-div-right: Arrays
array-end: Arrays
array-expt: Arrays
array-flip: Arrays
array-flip!: Arrays
array-for-each-index: Arrays
array-inverse: Arrays
array-length: Arrays
array-map: Arrays
array-map: Arrays
array-map!: Arrays
array-map!: Arrays
array-mul: Arrays
array-mul-elements: Arrays
array-mul-elements!: Arrays
array-negate-elements: Arrays
array-negate-elements!: Arrays
array-rank: Arrays
array-reciprocate-elements: Arrays
array-reciprocate-elements!: Arrays
array-ref: Arrays
array-ref: Arrays
array-retabulate!: Arrays
array-retabulate!: Arrays
array-rotate-90: Arrays
array-set!: Arrays
array-set!: Arrays
array-shape: Arrays
array-size: Arrays
array-start: Arrays
array-sub-elements: Arrays
array-sub-elements!: Arrays
array-transpose: Arrays
array?: Arrays
as-black: R7RS combinator formatting
as-blue: R7RS combinator formatting
as-bold: R7RS combinator formatting
as-cyan: R7RS combinator formatting
as-green: R7RS combinator formatting
as-magenta: R7RS combinator formatting
as-nodeset: SXPath basic converters and applicators
as-red: R7RS combinator formatting
as-underline: R7RS combinator formatting
as-unicode: R7RS combinator formatting
as-white: R7RS combinator formatting
as-yellow: R7RS combinator formatting
ascii-alphabetic?: ASCII character library
ascii-alphanumeric?: ASCII character library
ascii-bytevecotr?: ASCII character library
ascii-char?: ASCII character library
ascii-ci<=?: ASCII character library
ascii-ci<?: ASCII character library
ascii-ci=?: ASCII character library
ascii-ci>=?: ASCII character library
ascii-ci>?: ASCII character library
ascii-codepoint?: ASCII character library
ascii-control->graphic: ASCII character library
ascii-control?: ASCII character library
ascii-digit-value: ASCII character library
ascii-downcase: ASCII character library
ascii-graphic->control: ASCII character library
ascii-lower-case-value: ASCII character library
ascii-lower-case?: ASCII character library
ascii-mirror-bracket: ASCII character library
ascii-non-control?: ASCII character library
ascii-nth-digit: ASCII character library
ascii-nth-lower-case: ASCII character library
ascii-nth-upper-case: ASCII character library
ascii-numeric?: ASCII character library
ascii-other-graphic?: ASCII character library
ascii-space-or-tab?: ASCII character library
ascii-string-ci<=?: ASCII character library
ascii-string-ci<?: ASCII character library
ascii-string-ci=?: ASCII character library
ascii-string-ci>=?: ASCII character library
ascii-string-ci>?: ASCII character library
ascii-string?: ASCII character library
ascii-upcase: ASCII character library
ascii-upper-case-value: ASCII character library
ascii-upper-case?: ASCII character library
ascii-whitespace?: ASCII character library
ash: Basic bitwise operations
asin: Arithmetics
asinh: Arithmetics
assert-curr-char: Parsing input stream
assoc: Association lists
assoc$: Combinators
assoc-adjoin: Association lists
assoc-ref: Association lists
assoc-set!: Association lists
assoc-update-in: Association lists
assq: Association lists
assq-ref: Association lists
assq-set!: Association lists
assume: Conditionals
assume-type: Conditionals
assv: Association lists
assv-ref: Association lists
assv-set!: Association lists
atan: Arithmetics
atan: Arithmetics
atanh: Arithmetics
atom: Atom
atom-ref: Atom
atom?: Atom
atomic: Atom
atomic-update!: Atom
attlist->alist: SSAX data types
attlist-add: SSAX data types
attlist-fold: SSAX data types
attlist-null?: SSAX data types
attlist-remove-top: SSAX data types
autoload: Autoload

B
bag: R7RS sets
bag->alist: R7RS sets
bag->list: R7RS sets
bag->set: R7RS sets
bag-adjoin: R7RS sets
bag-adjoin!: R7RS sets
bag-any?: R7RS sets
bag-contains?: R7RS sets
bag-copy: R7RS sets
bag-count: R7RS sets
bag-decrement!: R7RS sets
bag-delete: R7RS sets
bag-delete!: R7RS sets
bag-delete-all: R7RS sets
bag-delete-all!: R7RS sets
bag-difference: R7RS sets
bag-difference!: R7RS sets
bag-disjoint?: R7RS sets
bag-element-comparator: R7RS sets
bag-element-count: R7RS sets
bag-empty?: R7RS sets
bag-every?: R7RS sets
bag-filter: R7RS sets
bag-filter!: R7RS sets
bag-find: R7RS sets
bag-fold: R7RS sets
bag-fold-unique: R7RS sets
bag-for-each: R7RS sets
bag-for-each-unique: R7RS sets
bag-increment!: R7RS sets
bag-intersection: R7RS sets
bag-intersection!: R7RS sets
bag-map: R7RS sets
bag-member: R7RS sets
bag-partition: R7RS sets
bag-partition!: R7RS sets
bag-product: R7RS sets
bag-product!: R7RS sets
bag-remove: R7RS sets
bag-remove!: R7RS sets
bag-replace: R7RS sets
bag-replace!: R7RS sets
bag-search!: R7RS sets
bag-size: R7RS sets
bag-sum: R7RS sets
bag-sum!: R7RS sets
bag-unfold: R7RS sets
bag-union: R7RS sets
bag-union!: R7RS sets
bag-unique-size: R7RS sets
bag-xor: R7RS sets
bag-xor!: R7RS sets
bag<=?: R7RS sets
bag<?: R7RS sets
bag=?: R7RS sets
bag>=?: R7RS sets
bag>?: R7RS sets
balanced-quotient: R7RS integer division
balanced-remainder: R7RS integer division
balanced/: R7RS integer division
barrier-await: Barrier
barrier-broken?: Barrier
barrier-reset!: Barrier
barrier?: Barrier
base16-decode: Base64 encoding/decoding
base16-decode-string-to: Base64 encoding/decoding
base16-encode: Base64 encoding/decoding
base16-encode-message: Base64 encoding/decoding
base32-decode: Base64 encoding/decoding
base32-decode-string-to: Base64 encoding/decoding
base32-encode: Base64 encoding/decoding
base32-encode-message: Base64 encoding/decoding
base32hex-decode: Base64 encoding/decoding
base32hex-decode-string-to: Base64 encoding/decoding
base32hex-encode: Base64 encoding/decoding
base32hex-encode-message: Base64 encoding/decoding
base64->bytevector: String-notated bytevectors
base64-decode: Base64 encoding/decoding
base64-decode-bytevector: Base64 encoding/decoding
base64-decode-string: Base64 encoding/decoding
base64-decode-string-to: Base64 encoding/decoding
base64-encode: Base64 encoding/decoding
base64-encode-bytevector: Base64 encoding/decoding
base64-encode-message: Base64 encoding/decoding
base64-encode-string: Base64 encoding/decoding
bcrypt-gensalt: Password hashing
bcrypt-hashpw: Password hashing
beep: Text terminal control
begin: Grouping
begin: CiSE syntax
begin: Stub generation
begin: Eager comprehensions
begin-procedure: Combinators (SRFI)
begin0: Grouping
bignum?: Numerical predicates
bimap-left: Generic dictionaries
bimap-left-delete!: Generic dictionaries
bimap-left-exists?: Generic dictionaries
bimap-left-get: Generic dictionaries
bimap-put!: Generic dictionaries
bimap-right: Generic dictionaries
bimap-right-delete!: Generic dictionaries
bimap-right-exists?: Generic dictionaries
bimap-right-get: Generic dictionaries
binary-heap-clear!: Heap
binary-heap-copy: Heap
binary-heap-delete!: Heap
binary-heap-empty?: Heap
binary-heap-find: Heap
binary-heap-find-max: Heap
binary-heap-find-min: Heap
binary-heap-num-entries: Heap
binary-heap-pop-max!: Heap
binary-heap-pop-min!: Heap
binary-heap-push!: Heap
binary-heap-remove!: Heap
binary-heap-swap-max!: Heap
binary-heap-swap-min!: Heap
binary-port?: R7RS base library
bind: Procedures and syntax for multiple values
bind/box: Procedures and syntax for multiple values
bind/list: Procedures and syntax for multiple values
bind/mv: Procedures and syntax for multiple values
bindtextdomain: Localized messages
bit->boolean: Bitvectors
bit->integer: Bitvectors
bit-count: R7RS bitwise operations
bit-field: Basic bitwise operations
bit-field-any?: R7RS bitwise operations
bit-field-clear: R7RS bitwise operations
bit-field-every?: R7RS bitwise operations
bit-field-replace: R7RS bitwise operations
bit-field-replace-same: R7RS bitwise operations
bit-field-reverse: R7RS bitwise operations
bit-field-rotate: R7RS bitwise operations
bit-field-set: R7RS bitwise operations
bit-set?: R7RS bitwise operations
bit-swap: R7RS bitwise operations
bits: R7RS bitwise operations
bits->generator: Generator constructors
bits->list: R7RS bitwise operations
bits->vector: R7RS bitwise operations
bitvector: Bitvectors
bitvector->bool-generator: Bitvector utilities
bitvector->index-generator: Bitvector utilities
bitvector->int-generator: Bitvector utilities
bitvector->integer: Bitvector utilities
bitvector->list/bool: Bitvector utilities
bitvector->list/int: Bitvector utilities
bitvector->string: Bitvectors
bitvector->vector/bool: Bitvector utilities
bitvector->vector/int: Bitvector utilities
bitvector-and: Bitvector utilities
bitvector-and!: Bitvector utilities
bitvector-andc1: Bitvector utilities
bitvector-andc1!: Bitvector utilities
bitvector-andc2: Bitvector utilities
bitvector-andc2!: Bitvector utilities
bitvector-any-value?: Bitvectors
bitvector-append: Bitvector utilities
bitvector-append-subbitvectors: Bitvector utilities
bitvector-concatenate: Bitvector utilities
bitvector-copy: Bitvectors
bitvector-copy!: Bitvectors
bitvector-count: Bitvector utilities
bitvector-count-run: Bitvector utilities
bitvector-drop: Bitvector utilities
bitvector-drop-right: Bitvector utilities
bitvector-emtpy?: Bitvector utilities
bitvector-eqv: Bitvector utilities
bitvector-eqv!: Bitvector utilities
bitvector-every-value?: Bitvectors
bitvector-field-any?: Bitvector utilities
bitvector-field-clear: Bitvector utilities
bitvector-field-clear!: Bitvector utilities
bitvector-field-every?: Bitvector utilities
bitvector-field-flip: Bitvector utilities
bitvector-field-flip!: Bitvector utilities
bitvector-field-replace: Bitvector utilities
bitvector-field-replace!: Bitvector utilities
bitvector-field-replace-same: Bitvector utilities
bitvector-field-replace-same!: Bitvector utilities
bitvector-field-rotate: Bitvector utilities
bitvector-field-set: Bitvector utilities
bitvector-field-set!: Bitvector utilities
bitvector-first-bit: Bitvector utilities
bitvector-fold-right/bool: Bitvector utilities
bitvector-fold-right/int: Bitvector utilities
bitvector-fold/bool: Bitvector utilities
bitvector-fold/int: Bitvector utilities
bitvector-for-each/bool: Bitvector utilities
bitvector-for-each/int: Bitvector utilities
bitvector-if: Bitvector utilities
bitvector-ior: Bitvector utilities
bitvector-ior!: Bitvector utilities
bitvector-logical-shift: Bitvector utilities
bitvector-map!/bool: Bitvector utilities
bitvector-map!/int: Bitvector utilities
bitvector-map->list/bool: Bitvector utilities
bitvector-map->list/int: Bitvector utilities
bitvector-map/bool: Bitvector utilities
bitvector-map/int: Bitvector utilities
bitvector-nand: Bitvector utilities
bitvector-nand!: Bitvector utilities
bitvector-nor: Bitvector utilities
bitvector-nor!: Bitvector utilities
bitvector-not: Bitvector utilities
bitvector-not!: Bitvector utilities
bitvector-orc1: Bitvector utilities
bitvector-orc1!: Bitvector utilities
bitvector-orc2: Bitvector utilities
bitvector-orc2!: Bitvector utilities
bitvector-pad: Bitvector utilities
bitvector-pad-right: Bitvector utilities
bitvector-prefix-length: Bitvector utilities
bitvector-prefix?: Bitvector utilities
bitvector-ref/bool: Bitvectors
bitvector-ref/int: Bitvectors
bitvector-reverse!: Bitvector utilities
bitvector-reverse-copy: Bitvector utilities
bitvector-reverse-copy!: Bitvector utilities
bitvector-segment: Bitvector utilities
bitvector-set!: Bitvectors
bitvector-suffix-length: Bitvector utilities
bitvector-suffix?: Bitvector utilities
bitvector-swap!: Bitvector utilities
bitvector-take: Bitvector utilities
bitvector-take-right: Bitvector utilities
bitvector-trim: Bitvector utilities
bitvector-trim-both: Bitvector utilities
bitvector-trim-right: Bitvector utilities
bitvector-unfold: Bitvector utilities
bitvector-unfold-right: Bitvector utilities
bitvector-value-for-each-index: Bitvector utilities
bitvector-value-map-index->list: Bitvector utilities
bitvector-xor: Bitvector utilities
bitvector-xor!: Bitvector utilities
bitvector/bool-range: Range
bitvector/int-range: Range
bitvector=?: Bitvector utilities
bitvector?: Bitvectors
bitwise-and: R7RS bitwise operations
bitwise-andc1: R7RS bitwise operations
bitwise-andc2: R7RS bitwise operations
bitwise-eqv: R7RS bitwise operations
bitwise-fold: R7RS bitwise operations
bitwise-for-each: R7RS bitwise operations
bitwise-if: R7RS bitwise operations
bitwise-ior: R7RS bitwise operations
bitwise-merge: Integers as bits
bitwise-nand: R7RS bitwise operations
bitwise-nor: R7RS bitwise operations
bitwise-not: R7RS bitwise operations
bitwise-orc1: R7RS bitwise operations
bitwise-orc2: R7RS bitwise operations
bitwise-unfold: R7RS bitwise operations
bitwise-xor: R7RS bitwise operations
blob->sint-list: Octet-addressed binary blocks
blob->u8-list: Octet-addressed binary blocks
blob->uint-list: Octet-addressed binary blocks
blob-copy: Octet-addressed binary blocks
blob-copy!: Octet-addressed binary blocks
blob-length: Octet-addressed binary blocks
blob-s16-native-ref: Octet-addressed binary blocks
blob-s16-native-set!: Octet-addressed binary blocks
blob-s16-ref: Octet-addressed binary blocks
blob-s16-set!: Octet-addressed binary blocks
blob-s32-native-ref: Octet-addressed binary blocks
blob-s32-native-set!: Octet-addressed binary blocks
blob-s32-ref: Octet-addressed binary blocks
blob-s32-set!: Octet-addressed binary blocks
blob-s64-native-ref: Octet-addressed binary blocks
blob-s64-native-set!: Octet-addressed binary blocks
blob-s64-ref: Octet-addressed binary blocks
blob-s64-set!: Octet-addressed binary blocks
blob-s8-ref: Octet-addressed binary blocks
blob-s8-set!: Octet-addressed binary blocks
blob-sint-ref: Octet-addressed binary blocks
blob-sint-set!: Octet-addressed binary blocks
blob-u16-native-ref: Octet-addressed binary blocks
blob-u16-native-set!: Octet-addressed binary blocks
blob-u16-ref: Octet-addressed binary blocks
blob-u16-set!: Octet-addressed binary blocks
blob-u32-native-ref: Octet-addressed binary blocks
blob-u32-native-set!: Octet-addressed binary blocks
blob-u32-ref: Octet-addressed binary blocks
blob-u32-set!: Octet-addressed binary blocks
blob-u64-native-ref: Octet-addressed binary blocks
blob-u64-native-set!: Octet-addressed binary blocks
blob-u64-ref: Octet-addressed binary blocks
blob-u64-set!: Octet-addressed binary blocks
blob-u8-ref: Octet-addressed binary blocks
blob-u8-set!: Octet-addressed binary blocks
blob-uint-ref: Octet-addressed binary blocks
blob-uint-set!: Octet-addressed binary blocks
blob=?: Octet-addressed binary blocks
blob?: Octet-addressed binary blocks
boolean: Booleans
boolean-hash: Hashing
boolean=?: Booleans
boolean?: Booleans
booleans: Random data generators
booleans$: Random data generators
booleans->integer: Integers as bits
box: Boxes
box-arity: Boxes
box-values: Procedures and syntax for multiple values
box/mv: Procedures and syntax for multiple values
box?: Boxes
bpsw-prime?: Prime numbers
break: CiSE syntax
break: R7RS lists
break!: R7RS lists
break-list-by-sequence: Other operations over sequences
break-list-by-sequence!: Other operations over sequences
build-binary-heap: Heap
build-path: Pathname utilities
build-transliterator: Transliterate characters
byte-ready?: Reading data
bytestring: String-notated bytevectors
bytestring->list: String-notated bytevectors
bytestring-break: String-notated bytevectors
bytestring-error?: String-notated bytevectors
bytestring-index: String-notated bytevectors
bytestring-index-right: String-notated bytevectors
bytestring-join: String-notated bytevectors
bytestring-pad: String-notated bytevectors
bytestring-pad-right: String-notated bytevectors
bytestring-span: String-notated bytevectors
bytestring-split: String-notated bytevectors
bytestring-trim: String-notated bytevectors
bytestring-trim-both: String-notated bytevectors
bytestring-trim-right: String-notated bytevectors
bytestring<=?: String-notated bytevectors
bytestring<?: String-notated bytevectors
bytestring>=?: String-notated bytevectors
bytestring>?: String-notated bytevectors
bytevector: Bytevector compatibility
bytevector->base64: String-notated bytevectors
bytevector->generator: Generator constructors
bytevector->hex-string: String-notated bytevectors
bytevector->sint-list: R7RS bytevectors
bytevector->string: Transcoded ports
bytevector->u8-list: Bytevector compatibility
bytevector->uint-list: R7RS bytevectors
bytevector->ulid: Universally unique lexicographically sortable identifier
bytevector-accumulator: R7RS generators
bytevector-accumulator!: R7RS generators
bytevector-append: Bytevector compatibility
bytevector-copy: Bytevector compatibility
bytevector-copy!: Bytevector compatibility
bytevector-copy!-r6: Bytevector compatibility
bytevector-ieee-double-native-ref: R7RS bytevectors
bytevector-ieee-double-native-set!: R7RS bytevectors
bytevector-ieee-double-ref: R7RS bytevectors
bytevector-ieee-double-set!: R7RS bytevectors
bytevector-ieee-single-native-ref: R7RS bytevectors
bytevector-ieee-single-native-set!: R7RS bytevectors
bytevector-ieee-single-ref: R7RS bytevectors
bytevector-ieee-single-set!: R7RS bytevectors
bytevector-length: Bytevector compatibility
bytevector-s16-native-ref: R7RS bytevectors
bytevector-s16-native-set!: R7RS bytevectors
bytevector-s16-ref: R7RS bytevectors
bytevector-s16-set!: R7RS bytevectors
bytevector-s32-native-ref: R7RS bytevectors
bytevector-s32-native-set!: R7RS bytevectors
bytevector-s32-ref: R7RS bytevectors
bytevector-s32-set!: R7RS bytevectors
bytevector-s64-native-ref: R7RS bytevectors
bytevector-s64-native-set!: R7RS bytevectors
bytevector-s64-ref: R7RS bytevectors
bytevector-s64-set!: R7RS bytevectors
bytevector-s8-ref: Bytevector compatibility
bytevector-s8-set!: Bytevector compatibility
bytevector-sint-ref: R7RS bytevectors
bytevector-sint-set!: R7RS bytevectors
bytevector-u16-native-ref: R7RS bytevectors
bytevector-u16-native-set!: R7RS bytevectors
bytevector-u16-ref: R7RS bytevectors
bytevector-u16-set!: R7RS bytevectors
bytevector-u32-native-ref: R7RS bytevectors
bytevector-u32-native-set!: R7RS bytevectors
bytevector-u32-ref: R7RS bytevectors
bytevector-u32-set!: R7RS bytevectors
bytevector-u64-native-ref: R7RS bytevectors
bytevector-u64-native-set!: R7RS bytevectors
bytevector-u64-ref: R7RS bytevectors
bytevector-u64-set!: R7RS bytevectors
bytevector-u8-ref: Bytevector compatibility
bytevector-u8-set!: Bytevector compatibility
bytevector-uint-ref: R7RS bytevectors
bytevector-uint-set!: R7RS bytevectors
bytevector=?: Bytevector compatibility
bytevector?: Bytevector compatibility
bytrestring-replace: String-notated bytevectors

C
c128?: Uvector basic operations
c128ite-u8vector: Uvector block I/O
c128ke-u8vector-generator: Uvector basic operations
c128vector: Uvector basic operations
c128vector->list: Uvector conversion operations
c128vector->vector: Uvector conversion operations
c128vector-add: Uvector numeric operations
c128vector-add!: Uvector numeric operations
c128vector-any: Uvector basic operations
c128vector-append: Uvector basic operations
c128vector-append-subvectors: Uvector basic operations
c128vector-compare: Uvector basic operations
c128vector-concatenate: Uvector basic operations
c128vector-copy: Uvector basic operations
c128vector-copy!: Uvector basic operations
c128vector-count: Uvector basic operations
c128vector-cumulate: Uvector basic operations
c128vector-div: Uvector numeric operations
c128vector-div!: Uvector numeric operations
c128vector-dot: Uvector numeric operations
c128vector-drop: Uvector basic operations
c128vector-drop-right: Uvector basic operations
c128vector-drop-while: Uvector basic operations
c128vector-drop-while-right: Uvector basic operations
c128vector-empty?: Uvector basic operations
c128vector-every: Uvector basic operations
c128vector-fill!: Uvector basic operations
c128vector-filter: Uvector basic operations
c128vector-fold: Uvector basic operations
c128vector-for-each: Uvector basic operations
c128vector-index: Uvector basic operations
c128vector-index-right: Uvector basic operations
c128vector-length: Uvector basic operations
c128vector-map: Uvector basic operations
c128vector-map!: Uvector basic operations
c128vector-mul: Uvector numeric operations
c128vector-mul!: Uvector numeric operations
c128vector-multi-copy!: Uvector basic operations
c128vector-partition: Uvector basic operations
c128vector-ref: Uniform vectors
c128vector-remove: Uvector basic operations
c128vector-reverse!: Uvector basic operations
c128vector-reverse-copy: Uvector basic operations
c128vector-reverse-copy!: Uvector basic operations
c128vector-segment: Uvector basic operations
c128vector-set!: Uniform vectors
c128vector-skip: Uvector basic operations
c128vector-skip-right: Uvector basic operations
c128vector-sub: Uvector numeric operations
c128vector-sub!: Uvector numeric operations
c128vector-swap!: Uvector basic operations
c128vector-take: Uvector basic operations
c128vector-take-right: Uvector basic operations
c128vector-take-while: Uvector basic operations
c128vector-take-while-right: Uvector basic operations
c128vector-unfod-right!: Uvector basic operations
c128vector-unfold: Uvector basic operations
c128vector-unfold: Uvector basic operations
c128vector-unfold!: Uvector basic operations
c128vector-unfold!: Uvector basic operations
c128vector-unfold-right: Uvector basic operations
c128vector-unfold-right!: Uvector basic operations
c128vector=: Uvector basic operations
c128vector=?: Uvector basic operations
c128vector?: Uniform vectors
c32?: Uvector basic operations
c32ite-u8vector: Uvector block I/O
c32ke-u8vector-generator: Uvector basic operations
c32vector: Uvector basic operations
c32vector->list: Uvector conversion operations
c32vector->vector: Uvector conversion operations
c32vector-add: Uvector numeric operations
c32vector-add!: Uvector numeric operations
c32vector-any: Uvector basic operations
c32vector-append: Uvector basic operations
c32vector-append-subvectors: Uvector basic operations
c32vector-compare: Uvector basic operations
c32vector-concatenate: Uvector basic operations
c32vector-copy: Uvector basic operations
c32vector-copy!: Uvector basic operations
c32vector-count: Uvector basic operations
c32vector-cumulate: Uvector basic operations
c32vector-div: Uvector numeric operations
c32vector-div!: Uvector numeric operations
c32vector-dot: Uvector numeric operations
c32vector-drop: Uvector basic operations
c32vector-drop-right: Uvector basic operations
c32vector-drop-while: Uvector basic operations
c32vector-drop-while-right: Uvector basic operations
c32vector-empty?: Uvector basic operations
c32vector-every: Uvector basic operations
c32vector-fill!: Uvector basic operations
c32vector-filter: Uvector basic operations
c32vector-fold: Uvector basic operations
c32vector-for-each: Uvector basic operations
c32vector-index: Uvector basic operations
c32vector-index-right: Uvector basic operations
c32vector-length: Uvector basic operations
c32vector-map: Uvector basic operations
c32vector-map!: Uvector basic operations
c32vector-mul: Uvector numeric operations
c32vector-mul!: Uvector numeric operations
c32vector-multi-copy!: Uvector basic operations
c32vector-partition: Uvector basic operations
c32vector-ref: Uniform vectors
c32vector-remove: Uvector basic operations
c32vector-reverse!: Uvector basic operations
c32vector-reverse-copy: Uvector basic operations
c32vector-reverse-copy!: Uvector basic operations
c32vector-segment: Uvector basic operations
c32vector-set!: Uniform vectors
c32vector-skip: Uvector basic operations
c32vector-skip-right: Uvector basic operations
c32vector-sub: Uvector numeric operations
c32vector-sub!: Uvector numeric operations
c32vector-swap!: Uvector basic operations
c32vector-take: Uvector basic operations
c32vector-take-right: Uvector basic operations
c32vector-take-while: Uvector basic operations
c32vector-take-while-right: Uvector basic operations
c32vector-unfod-right!: Uvector basic operations
c32vector-unfold: Uvector basic operations
c32vector-unfold: Uvector basic operations
c32vector-unfold!: Uvector basic operations
c32vector-unfold!: Uvector basic operations
c32vector-unfold-right: Uvector basic operations
c32vector-unfold-right!: Uvector basic operations
c32vector=: Uvector basic operations
c32vector=?: Uvector basic operations
c32vector?: Uniform vectors
c64?: Uvector basic operations
c64ite-u8vector: Uvector block I/O
c64ke-u8vector-generator: Uvector basic operations
c64vector: Uvector basic operations
c64vector->list: Uvector conversion operations
c64vector->vector: Uvector conversion operations
c64vector-add: Uvector numeric operations
c64vector-add!: Uvector numeric operations
c64vector-any: Uvector basic operations
c64vector-append: Uvector basic operations
c64vector-append-subvectors: Uvector basic operations
c64vector-compare: Uvector basic operations
c64vector-concatenate: Uvector basic operations
c64vector-copy: Uvector basic operations
c64vector-copy!: Uvector basic operations
c64vector-count: Uvector basic operations
c64vector-cumulate: Uvector basic operations
c64vector-div: Uvector numeric operations
c64vector-div!: Uvector numeric operations
c64vector-dot: Uvector numeric operations
c64vector-drop: Uvector basic operations
c64vector-drop-right: Uvector basic operations
c64vector-drop-while: Uvector basic operations
c64vector-drop-while-right: Uvector basic operations
c64vector-empty?: Uvector basic operations
c64vector-every: Uvector basic operations
c64vector-fill!: Uvector basic operations
c64vector-filter: Uvector basic operations
c64vector-fold: Uvector basic operations
c64vector-for-each: Uvector basic operations
c64vector-index: Uvector basic operations
c64vector-index-right: Uvector basic operations
c64vector-length: Uvector basic operations
c64vector-map: Uvector basic operations
c64vector-map!: Uvector basic operations
c64vector-mul: Uvector numeric operations
c64vector-mul!: Uvector numeric operations
c64vector-multi-copy!: Uvector basic operations
c64vector-partition: Uvector basic operations
c64vector-ref: Uniform vectors
c64vector-remove: Uvector basic operations
c64vector-reverse!: Uvector basic operations
c64vector-reverse-copy: Uvector basic operations
c64vector-reverse-copy!: Uvector basic operations
c64vector-segment: Uvector basic operations
c64vector-set!: Uniform vectors
c64vector-skip: Uvector basic operations
c64vector-skip-right: Uvector basic operations
c64vector-sub: Uvector numeric operations
c64vector-sub!: Uvector numeric operations
c64vector-swap!: Uvector basic operations
c64vector-take: Uvector basic operations
c64vector-take-right: Uvector basic operations
c64vector-take-while: Uvector basic operations
c64vector-take-while-right: Uvector basic operations
c64vector-unfod-right!: Uvector basic operations
c64vector-unfold: Uvector basic operations
c64vector-unfold: Uvector basic operations
c64vector-unfold!: Uvector basic operations
c64vector-unfold!: Uvector basic operations
c64vector-unfold-right: Uvector basic operations
c64vector-unfold-right!: Uvector basic operations
c64vector=: Uvector basic operations
c64vector=?: Uvector basic operations
c64vector?: Uniform vectors
caaaar: List accessors and modifiers
caaadr: List accessors and modifiers
caaar: List accessors and modifiers
caadar: List accessors and modifiers
caaddr: List accessors and modifiers
caadr: List accessors and modifiers
caar: List accessors and modifiers
cache-check!: Cache
cache-clear!: Cache
cache-compact-queue!: Cache
cache-comparator: Cache
cache-evict!: Cache
cache-lookup!: Cache
cache-populate-queue!: Cache
cache-register!: Cache
cache-renumber-entries!: Cache
cache-storage: Cache
cache-through!: Cache
cache-write!: Cache
cadaar: List accessors and modifiers
cadadr: List accessors and modifiers
cadar: List accessors and modifiers
caddar: List accessors and modifiers
cadddr: List accessors and modifiers
caddr: List accessors and modifiers
cadr: List accessors and modifiers
calculate-dominators: Calculate dominator tree
call-with-builder: Fundamental iterator creators
call-with-cgi-script: CGI testing
call-with-client-socket: High-level network functions
call-with-console: Text terminal control
call-with-continuation-prompt: Continuation prompts
call-with-current-continuation: Continuations
call-with-ftp-connection: FTP
call-with-immediate-continuation-mark: Continuation marks
call-with-input-conversion: Conversion ports
call-with-input-file: Opening file ports
call-with-input-process: Process ports
call-with-input-string: String ports
call-with-iterator: Fundamental iterator creators
call-with-iterators: Fundamental iterator creators
call-with-output: R7RS combinator formatting
call-with-output-conversion: Conversion ports
call-with-output-file: Opening file ports
call-with-output-process: Process ports
call-with-output-string: String ports
call-with-parameterization: Parameters
call-with-port: Common port operations
call-with-process-io: Process ports
call-with-string-io: String ports
call-with-temporary-directory: Temporary files and directories
call-with-temporary-file: Temporary files and directories
call-with-temporary-filename: POSIX API
call-with-values: Multiple values
call/cc: Continuations
call/mv: Procedures and syntax for multiple values
call/pc: Partial continuations
car: List accessors and modifiers
car+cdr: R7RS lists
car-sxpath: SXPath query language
cartesian-product: Combination library
cartesian-product-right: Combination library
case: Conditionals
case: CiSE syntax
case-lambda: Making procedures
case-lambda/tag: Tagged procedures
case-procedure: Combinators (SRFI)
case-receive: Procedures and syntax for multiple values
case/fallthrough: CiSE syntax
cast: CiSE syntax
cdaaar: List accessors and modifiers
cdaadr: List accessors and modifiers
cdaar: List accessors and modifiers
cdadar: List accessors and modifiers
cdaddr: List accessors and modifiers
cdadr: List accessors and modifiers
cdar: List accessors and modifiers
cddaar: List accessors and modifiers
cddadr: List accessors and modifiers
cddar: List accessors and modifiers
cdddar: List accessors and modifiers
cddddr: List accessors and modifiers
cdddr: List accessors and modifiers
cddr: List accessors and modifiers
cdr: List accessors and modifiers
ceiling: Arithmetics
ceiling->exact: Arithmetics
ceiling-quotient: R7RS integer division
ceiling-remainder: R7RS integer division
ceiling/: R7RS integer division
ces-conversion-supported?: Supported character encoding schemes
ces-convert: Conversion ports
ces-convert-to: Conversion ports
ces-equivalent?: Supported character encoding schemes
ces-guess-from-string: Autodetecting the encoding scheme
ces-upper-compatible?: Supported character encoding schemes
cf$: Configure API
cf-arg-enable: Configure API
cf-arg-var: Configure API
cf-arg-with: Configure API
cf-check-decl: Configure API
cf-check-decls: Configure API
cf-check-func: Configure API
cf-check-funcs: Configure API
cf-check-header: Configure API
cf-check-headers: Configure API
cf-check-lib: Configure API
cf-check-member: Configure API
cf-check-members: Configure API
cf-check-prog: Configure API
cf-check-type: Configure API
cf-check-types: Configure API
cf-config-headers: Configure API
cf-decl-available?: Configure API
cf-define: Configure API
cf-defined?: Configure API
cf-echo: Configure API
cf-feature-ref: Configure API
cf-func-available?: Configure API
cf-have-subst?: Configure API
cf-header-available?: Configure API
cf-help-string: Configure API
cf-includes-default: Configure API
cf-init: Configure API
cf-init-gauche-extension: Configure API
cf-lang: Configure API
cf-lang-call: Configure API
cf-lang-io-program: Configure API
cf-lang-program: Configure API
cf-lib-available?: Configure API
cf-make-gpd: Configure API
cf-member-available?: Configure API
cf-msg-checking: Configure API
cf-msg-error: Configure API
cf-msg-notice: Configure API
cf-msg-result: Configure API
cf-msg-warn: Configure API
cf-output: Configure API
cf-output-default: Configure API
cf-package-ref: Configure API
cf-path-prog: Configure API
cf-prog-cxx: Configure API
cf-ref: Configure API
cf-search-libs: Configure API
cf-show-substs: Configure API
cf-subst: Configure API
cf-subst-append: Configure API
cf-subst-prepend: Configure API
cf-try-compile: Configure API
cf-try-compile-and-link: Configure API
cf-type-available?: Configure API
cgen-add!: Generating C source files
cgen-body: Generating C source files
cgen-box-expr: Conversions between Scheme and C
cgen-cexpr: Generating Scheme literals
cgen-current-unit: Generating C source files
cgen-decl: Generating C source files
cgen-emit-body: Generating C source files
cgen-emit-c: Generating C source files
cgen-emit-decl: Generating C source files
cgen-emit-h: Generating C source files
cgen-emit-init: Generating C source files
cgen-emit-xtrn: Generating C source files
cgen-extern: Generating C source files
cgen-init: Generating C source files
cgen-literal: Generating Scheme literals
cgen-pred-expr: Conversions between Scheme and C
cgen-safe-comment: Generating C source files
cgen-safe-name: Generating C source files
cgen-safe-name-friendly: Generating C source files
cgen-safe-string: Generating C source files
cgen-type-from-name: Conversions between Scheme and C
cgen-unbox-expr: Conversions between Scheme and C
cgen-unit-c-file: Generating C source files
cgen-unit-h-file: Generating C source files
cgen-unit-init-name: Generating C source files
cgen-with-cpp-condition: Generating C source files
cgi-add-temporary-file: CGI utility
cgi-get-metavariable: CGI utility
cgi-get-parameter: CGI utility
cgi-header: CGI utility
cgi-main: CGI utility
cgi-metavariables: CGI utility
cgi-output-character-encoding: CGI utility
cgi-parse-parameters: CGI utility
cgi-temporary-files: CGI utility
cgi-test-environment-ref: CGI testing
chain: Pipeline operators
chain-and: Pipeline operators
chain-lambda: Pipeline operators
chain-when: Pipeline operators
change-class: Changing classes
change-class: Changing classes
change-object-class: Changing classes
char->integer: Characters
char->ucs: Characters
char-alphabetic?: Characters
char-ci-hash: Hashing
char-ci<=?: Characters
char-ci<?: Characters
char-ci=?: Characters
char-ci>=?: Characters
char-ci>?: Characters
char-downcase: Characters
char-east-asian-width: East asian width property
char-foldcase: Characters
char-general-category: Characters
char-hash: Hashing
char-lower-case?: Characters
char-numeric?: Characters
char-ready?: Reading data
char-set: Character set operations
char-set: Character set operations
char-set->list: Character-set query
char-set->sre: R7RS regular expressions
char-set->string: Character-set query
char-set-adjoin: Character-set algebra
char-set-adjoin!: Character-set algebra
char-set-any: Character-set query
char-set-complement: Character set operations
char-set-complement!: Character set operations
char-set-contains?: Character set operations
char-set-copy: Character set operations
char-set-count: Character-set query
char-set-cursor: Character-set iteration
char-set-cursor-next: Character-set iteration
char-set-delete: Character-set algebra
char-set-delete!: Character-set algebra
char-set-diff+intersection: Character-set algebra
char-set-diff+intersection!: Character-set algebra
char-set-difference: Character-set algebra
char-set-difference!: Character-set algebra
char-set-every: Character-set query
char-set-filter: Character-set constructors
char-set-filter!: Character-set constructors
char-set-fold: Character-set iteration
char-set-for-each: Character-set iteration
char-set-hash: Character-set comparison
char-set-immutable?: Character set operations
char-set-intersection: Character-set algebra
char-set-intersection!: Character-set algebra
char-set-map: Character-set iteration
char-set-ref: Character-set iteration
char-set-size: Character set operations
char-set-unfold: Character-set iteration
char-set-unfold!: Character-set iteration
char-set-union: Character-set algebra
char-set-union!: Character-set algebra
char-set-xor: Character-set algebra
char-set-xor!: Character-set algebra
char-set<=: Character-set comparison
char-set=: Character-set comparison
char-set?: Character set operations
char-title-case?: Characters
char-titlecase: Characters
char-upcase: Characters
char-upper-case?: Characters
char-whitespace?: Characters
char-word-constituent?: Characters
char<=?: Characters
char<?: Characters
char=?: Characters
char>=?: Characters
char>?: Characters
char?: Characters
chars$: Random data generators
check: Lightweight testing
check: Lightweight testing
check-directory-tree: Directory utilities
check-ec: Lightweight testing
check-ec: Lightweight testing
check-ec: Lightweight testing
check-ec: Lightweight testing
check-passed?: Lightweight testing
check-report: Lightweight testing
check-reset!: Lightweight testing
check-set-mode!: Lightweight testing
check-substring-spec: SRFI-13 Low-level string procedures
chibi-test: Running Chibi-scheme test suite
chready?: Text terminal control
circular-generator: Generator constructors
circular-list: R7RS lists
circular-list?: List predicates
cise-ambient-copy: CiSE procedures
cise-ambient-decl-strings: CiSE procedures
cise-default-ambient: CiSE procedures
cise-lookup-macro: CiSE procedures
cise-register-macro!: CiSE procedures
cise-render: CiSE procedures
cise-render-rec: CiSE procedures
cise-render-to-string: CiSE procedures
cise-translate: CiSE procedures
clamp: Arithmetics
clamp-real-number: Random data generators (SRFI)
class-direct-methods: Class object
class-direct-slots: Class object
class-direct-subclasses: Class object
class-direct-supers: Class object
class-name: Class object
class-of: Predefined classes
class-post-initialize: Class instantiation
class-precedence-list: Class object
class-redefinition: Customizing class redefinition
class-slot-accessor: Class object
class-slot-bound?: Accessing instance
class-slot-definition: Class object
class-slot-ref: Accessing instance
class-slot-set!: Accessing instance
class-slots: Class object
clear-screen: Text terminal control
clear-to-eol: Text terminal control
clear-to-eos: Text terminal control
close-directory: POSIX API
close-input-port: Common port operations
close-output-port: Common port operations
close-port: Common port operations
coarity: Procedures and syntax for multiple values
code: Feature-based program configuration language
codepoints->grapheme-clusters: Unicode text segmentation
codepoints->words: Unicode text segmentation
codepoints-downcase: Full string case conversion
codepoints-foldcase: Full string case conversion
codepoints-titlecase: Full string case conversion
codepoints-upcase: Full string case conversion
coerce-to: Miscellaneous operations on collection
columnar: R7RS combinator formatting
combinations: Combination library
combinations*: Combination library
combinations*-for-each: Combination library
combinations-for-each: Combination library
combinations-of: Random data generators
combine-hash-value: Hashing
command-args: Command line
command-line: Command-line arguments
command-name: Command line
common-prefix: Other operations over sequences
common-prefix-to: Other operations over sequences
comparator-check-type: Comparator predicates and accessors
comparator-compare: Comparator predicates and accessors
comparator-comparison-procedure: Comparator predicates and accessors
comparator-comparison-procedure?: Comparators
comparator-equal?: Comparators
comparator-equality-predicate: Comparator predicates and accessors
comparator-flavor: Comparator predicates and accessors
comparator-hash: Comparator predicates and accessors
comparator-hash-function: Comparator predicates and accessors
comparator-hash-function?: Comparators
comparator-hashable?: Comparator predicates and accessors
comparator-max: Comparator sublibrary
comparator-min: Comparator sublibrary
comparator-min-in-list: Comparator sublibrary
comparator-min-in-list: Comparator sublibrary
comparator-ordered?: Comparator predicates and accessors
comparator-ordering-predicate: Comparator predicates and accessors
comparator-register-default!: Predefined comparators
comparator-test-type: Comparator predicates and accessors
comparator-type-test-procedure: Comparator predicates and accessors
comparator-type-test-procedure: Comparators
comparator?: Comparator predicates and accessors
compare: Comparison
complement: Combinators
complete-sexp?: Listener
complex?: Numerical predicates
complexes-polar$: Random data generators
complexes-rectangular$: Random data generators
compose: Combinators
compose-left: Procedures and syntax for multiple values
compose-right: Procedures and syntax for multiple values
compound-access: Compound objects
compound-filter: Compound objects
compound-length: Compound objects
compound-map: Compound objects
compound-map->list: Compound objects
compound-predicate: Compound objects
compound-ref: Compound objects
compound-subobjects: Compound objects
compound?: Compound objects
compute-cpl: Class instantiation
compute-get-n-set: Customizing slot access
compute-get-n-set: Customizing slot access
compute-slot-accessor: Customizing slot access
compute-slot-accessor: Customizing slot access
compute-slots: Customizing slot access
compute-slots: Customizing slot access
concatenate: Other list procedures
concatenate!: Other list procedures
concurrent-modification-violation?: Thread exceptions
cond: Conditionals
cond: CiSE syntax
cond-expand: Feature conditional
cond-list: List constructors
condition: Conditions
condition-has-type?: Conditions
condition-message: Conditions
condition-ref: Conditions
condition-type?: Conditions
condition-variable-broadcast!: Condition variable
condition-variable-name: Condition variable
condition-variable-signal!: Condition variable
condition-variable-specific: Condition variable
condition-variable-specific-set!: Condition variable
condition-variable?: Condition variable
condition?: Conditions
conjoin: Combinators (SRFI)
connection-address-name: Connection framework
connection-close: Connection framework
connection-input-port: Connection framework
connection-output-port: Connection framework
connection-peer-address: Connection framework
connection-self-address: Connection framework
connection-shutdown: Connection framework
cons: List constructors
cons*: List constructors
cons-stream: SICP prerequisites
console-device: Pathname utilities
constantly: Combinators
construct-cookie-string: HTTP cookie handling
construct-css: CSS parsing and construction
construct-edn: EDN parsing and construction
construct-edn-string: EDN parsing and construction
construct-json: JSON parsing and construction
construct-json-string: JSON parsing and construction
consume-trailing-whitespaces: Reading data
continuation-mark-key?: Continuation marks
continuation-mark-set->list: Continuation marks
continuation-mark-set-first: Continuation marks
continuation-mark-set?: Continuation marks
continuation-marks: Continuation marks
continuation-prompt-tag?: Continuation prompts
continuation-violation-prompt-tag: Conditions
continuation-violation?: Conditions
continue: CiSE syntax
continued-fraction: Arithmetics
copy-bit: Basic bitwise operations
copy-bit-field: Basic bitwise operations
copy-directory*: Directory utilities
copy-file: File operations
copy-port: Common port operations
copy-queue: Queue
copy-time: SRFI-19 Time procedures
coroutine->cseq: Concurrent sequences
coroutine->lseq: Lazy sequence constructors
cos: Arithmetics
cosh: Arithmetics
count: Walking over lists
count$: Combinators
count-accumulator: R7RS generators
cpu-architecture: Portable runtime environment inquiry
crc32: Zlib compression library
create-directory: POSIX API
create-directory*: Directory utilities
create-directory-tree: Directory utilities
create-fifo: POSIX API
create-hard-link: POSIX API
create-symlink: POSIX API
create-temp-file: POSIX API
csv-rows->tuples: CSV tables
current-class-of: Accessing instance
current-continuation-marks: Continuation marks
current-country: Localization
current-date: SRFI-19 Time queries
current-directory: Directory utilities
current-dynamic-extent: First-class dynamic extents
current-error-port: Common port operations
current-exception-handler: Low-level exception handling mechanism
current-input-port: Common port operations
current-jiffy: R7RS time
current-julian-day: SRFI-19 Time queries
current-language: Localization
current-load-history: Loading Scheme file
current-load-next: Loading Scheme file
current-load-path: Loading Scheme file
current-load-port: Loading Scheme file
current-locale-details: Localization
current-modified-julian-day: SRFI-19 Time queries
current-module: Defining and selecting modules
current-output-port: Common port operations
current-parameterization: Parameters
current-second: R7RS time
current-thread: Thread procedures
current-time: Time
current-time: SRFI-19 Time queries
current-trace-port: Common port operations
curried: Flexible curried procedures
cursor-down/scroll-up: Text terminal control
cursor-up/scroll-down: Text terminal control
cut: Making procedures
cute: Making procedures

D
d: Interactive session
date->julian-day: SRFI-19 Date
date->modified-julian-day: SRFI-19 Date
date->rfc822-date: RFC822 message parsing
date->string: SRFI-19 Date reader and writer
date->time-monotonic: SRFI-19 Date
date->time-tai: SRFI-19 Date
date->time-utc: SRFI-19 Date
date-day: SRFI-19 Date
date-hour: SRFI-19 Date
date-minute: SRFI-19 Date
date-month: SRFI-19 Date
date-nanosecond: SRFI-19 Date
date-second: SRFI-19 Date
date-week-day: SRFI-19 Date
date-week-number: SRFI-19 Date
date-year: SRFI-19 Date
date-year-day: SRFI-19 Date
date-zone-offset: SRFI-19 Date
date?: SRFI-19 Date
dbi-close: DBI user API
dbi-close: DBI user API
dbi-close: DBI user API
dbi-close: Writing drivers for DBI
dbi-close: Writing drivers for DBI
dbi-close: Writing drivers for DBI
dbi-connect: DBI user API
dbi-do: DBI user API
dbi-do: Writing drivers for DBI
dbi-escape-sql: DBI user API
dbi-escape-sql: Writing drivers for DBI
dbi-execute: DBI user API
dbi-execute-using-connection: Writing drivers for DBI
dbi-list-drivers: DBI user API
dbi-make-connection: Writing drivers for DBI
dbi-make-driver: DBI user API
dbi-open?: DBI user API
dbi-open?: DBI user API
dbi-open?: DBI user API
dbi-open?: Writing drivers for DBI
dbi-open?: Writing drivers for DBI
dbi-open?: Writing drivers for DBI
dbi-parse-dsn: Writing drivers for DBI
dbi-prepare: DBI user API
dbi-prepare: Writing drivers for DBI
dbi-prepare-sql: Writing drivers for DBI
dbm-close: Opening and closing a dbm database
dbm-closed?: Opening and closing a dbm database
dbm-db-copy: Managing dbm database instance
dbm-db-exists?: Managing dbm database instance
dbm-db-move: Managing dbm database instance
dbm-db-remove: Managing dbm database instance
dbm-delete!: Accessing a dbm database
dbm-exists?: Accessing a dbm database
dbm-fold: Iterating on a database
dbm-for-each: Iterating on a database
dbm-get: Accessing a dbm database
dbm-map: Iterating on a database
dbm-open: Opening and closing a dbm database
dbm-open: Opening and closing a dbm database
dbm-put!: Accessing a dbm database
dbm-type->class: Opening and closing a dbm database
dcgettext: Localized messages
debug-funcall: Debugging aid
debug-funcall-conditionally: Debugging aid
debug-label: Debugging aid
debug-print: Debugging aid
debug-print-conditionally: Debugging aid
debug-print-width: Debugging aid
debug-source-info: Debugging aid
dec!: Assignments
declare-bundle!: Localization
declare-cfn: CiSE syntax
declare-cfn: Stub generation
declare-cvar: CiSE syntax
declare-cvar: Stub generation
declcode: Stub generation
decode-float: Numerical conversions
decompose-path: Pathname utilities
default-continuation-prompt-tag: Continuation prompts
default-endian: Endianness
default-file-encoding: Character encoding of file I/O
default-hash: Hashing
default-mapper: Parallel map
default-sizer: Random data generators
default-tls-class: Transport layer security
define: Definitions
define: Definitions
define: Definitions
define-cclass: Stub generation
define-cfn: CiSE syntax
define-cfn: Stub generation
define-cgeneric: Stub generation
define-cise-expr: CiSE procedures
define-cise-expr: Stub generation
define-cise-macro: CiSE procedures
define-cise-macro: CiSE procedures
define-cise-stmt: CiSE procedures
define-cise-stmt: Stub generation
define-cise-toplevel: CiSE procedures
define-class: Defining class
define-cmethod: Stub generation
define-condition-type: Conditions
define-constant: Definitions
define-constant: Definitions
define-constant: Stub generation
define-cproc: Stub generation
define-cptr: Stub generation
define-ctype: CiSE syntax
define-ctype: Stub generation
define-curried: Flexible curried procedures
define-cvar: CiSE syntax
define-cvar: Stub generation
define-dict-interface: Generic functions for dictionaries
define-enum: Stub generation
define-enum: Enums and enum sets
define-enum-conditionally: Stub generation
define-enumeration: Enums and enum sets
define-gauche-package: Package metainformation
define-generic: Generic function and method
define-hybrid-syntax: Hybrid macros
define-in-module: Definitions
define-in-module: Definitions
define-inline: Definitions
define-inline: Definitions
define-library: R7RS library form
define-macro: Traditional macros
define-macro: Traditional macros
define-method: Generic function and method
define-module: Defining and selecting modules
define-optionals: Optional arguments
define-optionals*: Optional arguments
define-reader-ctor: Read-time constructor
define-record-type: Record types syntactic layer
define-stream: Stream binding
define-symbol: Stub generation
define-syntax: Hygienic macros
define-type: Stub generation
define-values: Definitions
define-values: Definitions
define-values: Definitions
define-variable: Stub generation
deflate-string: Zlib compression library
deflating-port-full-flush: Zlib compression library
degrees->radians: Arithmetics
delay: Delay force and lazy
delay-force: R7RS lazy evaluation
delete: Walking over lists
delete!: Walking over lists
delete$: Combinators
delete-directory: POSIX API
delete-directory*: Directory utilities
delete-duplicates: Walking over lists
delete-duplicates!: Walking over lists
delete-environment-variable!: POSIX API
delete-file: File operations
delete-files: File operations
delete-hook!: Hooks
delete-keyword: Keywords
delete-keyword!: Keywords
delete-keywords: Keywords
delete-keywords!: Keywords
delete-neighbor-dups: Other operations over sequences
delete-neighbor-dups!: Other operations over sequences
delete-neighbor-dups-squeeze!: Other operations over sequences
denominator: Arithmetics
dequeue!: Queue
dequeue-all!: Queue
dequeue/wait!: Queue
describe: Interactive session
determinant: Arrays
determinant!: Arrays
dgettext: Localized messages
dict->alist: Generic functions for dictionaries
dict->priority-map: Priority map
dict-clear!: Generic functions for dictionaries
dict-comparator: Generic functions for dictionaries
dict-delete!: Generic functions for dictionaries
dict-exists?: Generic functions for dictionaries
dict-fold: Generic functions for dictionaries
dict-fold-right: Generic functions for dictionaries
dict-for-each: Generic functions for dictionaries
dict-get: Generic functions for dictionaries
dict-keys: Generic functions for dictionaries
dict-map: Generic functions for dictionaries
dict-pop!: Generic functions for dictionaries
dict-push!: Generic functions for dictionaries
dict-put!: Generic functions for dictionaries
dict-update!: Generic functions for dictionaries
dict-values: Generic functions for dictionaries
diff: Calculate difference of text streams
diff-report: Calculate difference of text streams
diff-report/context: Calculate difference of text streams
diff-report/unified: Calculate difference of text streams
digest: Message digester framework
digest-final!: Message digester framework
digest-hexify: Message digester framework
digest-message-to: Message digester framework
digest-string: Message digester framework
digest-to: Message digester framework
digest-update!: Message digester framework
digit->integer: Characters
digit-value: R7RS char library
directory-files: POSIX API
directory-fold: Directory utilities
directory-list: Directory utilities
directory-list2: Directory utilities
disasm: Debugging aid
disjoin: Combinators (SRFI)
display: Object output
display-multicolumn: Multicolumn formatting
display/pager: Display with pager
displayed: R7RS combinator formatting
div: Arithmetics
div-and-mod: Arithmetics
div0: Arithmetics
div0-and-mod0: Arithmetics
dl-distance: Levenshtein edit distance
dl-distances: Levenshtein edit distance
do: Iteration
do-ec: Eager comprehensions
do-generator: Generator consumers
do-pipeline: Running process pipeline
do-process: Running subprocess
do-process!: Running subprocess
dolist: Iteration
dolist: CiSE syntax
dopairs: CiSE syntax
dotimes: Iteration
dotimes: CiSE syntax
dotted-ilist?: R7RS immutable lists
dotted-list?: List predicates
drop: List accessors and modifiers
drop*: List accessors and modifiers
drop-right: List accessors and modifiers
drop-right!: List accessors and modifiers
drop-right*: List accessors and modifiers
drop-while: R7RS lists
dynamic-extent?: First-class dynamic extents
dynamic-lambda: First-class dynamic extents
dynamic-load: Loading dynamic library
dynamic-wind: Continuations

E
each: R7RS combinator formatting
each-in-list: R7RS combinator formatting
each-of: Combinators (SRFI)
eager: Delay force and lazy
eager-and-procedure: Combinators (SRFI)
eager-or-procedure: Combinators (SRFI)
ecase: Conditionals
ed: Interactive session
ed: Running external editor
ed-pick-file: Running external editor
ed-string: Running external editor
edn-equal?: EDN parsing and construction
edn-map: EDN parsing and construction
edn-object-handler: EDN parsing and construction
edn-object-payload: EDN parsing and construction
edn-object-tag: EDN parsing and construction
edn-object?: EDN parsing and construction
edn-set: EDN parsing and construction
edn-symbol-basename: EDN parsing and construction
edn-symbol-prefix: EDN parsing and construction
edn-valid-symbol-name?: EDN parsing and construction
edn-write: EDN parsing and construction
eighth: R7RS lists
either->generation: Maybe and Either protocol converters
either->list: Maybe and Either protocol converters
either->list-truth: Maybe and Either protocol converters
either->maybe: Maybe and Either constructors
either->truth: Maybe and Either protocol converters
either->values: Maybe and Either protocol converters
either-and: Maybe and Either syntactic utilities
either-bind: Maybe and Either accessors
either-compose: Maybe and Either accessors
either-filter: Maybe and Either sequence operations
either-fold: Maybe and Either sequence operations
either-for-each: Maybe and Either sequence operations
either-guard: Maybe and Either syntactic utilities
either-join: Maybe and Either accessors
either-length: Maybe and Either sequence operations
either-let*: Maybe and Either syntactic utilities
either-let*-values: Maybe and Either syntactic utilities
either-map: Maybe and Either sequence operations
either-or: Maybe and Either syntactic utilities
either-ref: Maybe and Either accessors
either-ref/default: Maybe and Either accessors
either-remove: Maybe and Either sequence operations
either-sequence: Maybe and Either sequence operations
either-swap: Maybe and Either constructors
either-unfold: Maybe and Either sequence operations
either=: Maybe and Either types and predicates
either?: Maybe and Either types and predicates
emergency-exit: R7RS process context
encode-float: Numerical conversions
end-of-char-set?: Character-set iteration
endianness: R7RS bytevectors
endianness: Octet-addressed binary blocks
enqueue!: Queue
enqueue-unique!: Queue
enqueue/wait!: Queue
enum-empty-set: Enums and enum sets
enum-max: Enums and enum sets
enum-min: Enums and enum sets
enum-name: Enums and enum sets
enum-name->enum: Enums and enum sets
enum-name->ordinal: Enums and enum sets
enum-name->value: Enums and enum sets
enum-next: Enums and enum sets
enum-ordinal: Enums and enum sets
enum-ordinal->enum: Enums and enum sets
enum-ordinal->name: Enums and enum sets
enum-ordinal->value: Enums and enum sets
enum-prev: Enums and enum sets
enum-set: Enums and enum sets
enum-set->enum-list: Enums and enum sets
enum-set->list: Enums and enum sets
enum-set-adjoin: Enums and enum sets
enum-set-adjoin!: Enums and enum sets
enum-set-any?: Enums and enum sets
enum-set-complement: Enums and enum sets
enum-set-complement!: Enums and enum sets
enum-set-contains?: Enums and enum sets
enum-set-copy: Enums and enum sets
enum-set-costructor: Enums and enum sets
enum-set-count: Enums and enum sets
enum-set-delete: Enums and enum sets
enum-set-delete!: Enums and enum sets
enum-set-delete-all: Enums and enum sets
enum-set-delete-all!: Enums and enum sets
enum-set-difference: Enums and enum sets
enum-set-difference!: Enums and enum sets
enum-set-disjoint?: Enums and enum sets
enum-set-empty?: Enums and enum sets
enum-set-every?: Enums and enum sets
enum-set-filter: Enums and enum sets
enum-set-fold: Enums and enum sets
enum-set-for-each: Enums and enum sets
enum-set-indexer: Enums and enum sets
enum-set-intersection: Enums and enum sets
enum-set-intersection!: Enums and enum sets
enum-set-map->list: Enums and enum sets
enum-set-member?: Enums and enum sets
enum-set-projection: Enums and enum sets
enum-set-remove: Enums and enum sets
enum-set-size: Enums and enum sets
enum-set-subset?: Enums and enum sets
enum-set-type: Enums and enum sets
enum-set-union: Enums and enum sets
enum-set-union!: Enums and enum sets
enum-set-universe: Enums and enum sets
enum-set-xor: Enums and enum sets
enum-set-xor!: Enums and enum sets
enum-set<=?: Enums and enum sets
enum-set<?: Enums and enum sets
enum-set=?: Enums and enum sets
enum-set>=?: Enums and enum sets
enum-set>?: Enums and enum sets
enum-set?: Enums and enum sets
enum-type: Enums and enum sets
enum-type->enum-set: Enums and enum sets
enum-type-contains?: Enums and enum sets
enum-type-enums: Enums and enum sets
enum-type-names: Enums and enum sets
enum-type-size: Enums and enum sets
enum-type-values: Enums and enum sets
enum-type?: Enums and enum sets
enum-value: Enums and enum sets
enum<=?: Enums and enum sets
enum<?: Enums and enum sets
enum=?: Enums and enum sets
enum>=?: Enums and enum sets
enum>?: Enums and enum sets
enum?: Enums and enum sets
environment: R7RS eval
eof-object: Reading data
eof-object?: Reading data
ephemeron-broken?: R7RS ephemerons
ephemeron-datum: R7RS ephemerons
ephemeron-key: R7RS ephemerons
ephemeron?: R7RS ephemerons
eq-compare: Comparison
eq-hash: Hashing
eq?: Equality
equal?: Equality
eqv-hash: Hashing
eqv?: Equality
er-macro-transformer: Explicit-renaming macro transformer
error: Signaling exceptions
error: Signaling exceptions
error-object-irritants: R7RS base library
error-object-message: R7RS base library
error-object?: R7RS base library
error?: Conditions
errorf: Signaling exceptions
errorf: Signaling exceptions
escaped: R7RS combinator formatting
etypecase: Conditionals
euclidean-quotient: R7RS integer division
euclidean-remainder: R7RS integer division
euclidean/: R7RS integer division
eval: Eval and repl
even?: Numerical predicates
every: Walking over lists
every$: Combinators
every-bit-set?: R7RS bitwise operations
every-in-queue: Queue
every-pred: Combinators
every?-ec: Eager comprehensions
exact: Numerical conversions
exact->inexact: Numerical conversions
exact-integer-sqrt: Arithmetics
exact-integer?: Numerical predicates
exact?: Numerical predicates
exception->either: Maybe and Either protocol converters
exception-handler-stack: Low-level exception handling mechanism
exit: Program termination
exit-handler: Program termination
exp: Arithmetics
expand-path: Pathname utilities
expand-template-file: Simple template expander
expand-template-string: Simple template expander
export: Using modules
export-all: Using modules
expt: Arithmetics
expt-mod: Arithmetics
extend: Module inheritance
extended-cons: Extended pairs and pair attributes
extended-list: Extended pairs and pair attributes
extended-pair?: Extended pairs and pair attributes
external-conversion-library: Supported character encoding schemes
extract-condition: Conditions

F
f16?: Uvector basic operations
f16array: Arrays
f16ite-u8vector: Uvector block I/O
f16ke-u8vector-generator: Uvector basic operations
f16vector: Uvector basic operations
f16vector->list: Uvector conversion operations
f16vector->vector: Uvector conversion operations
f16vector-add: Uvector numeric operations
f16vector-add!: Uvector numeric operations
f16vector-any: Uvector basic operations
f16vector-append: Uvector basic operations
f16vector-append-subvectors: Uvector basic operations
f16vector-clamp!: Uvector numeric operations
f16vector-compare: Uvector basic operations
f16vector-concatenate: Uvector basic operations
f16vector-copy: Uvector basic operations
f16vector-copy!: Uvector basic operations
f16vector-count: Uvector basic operations
f16vector-cumulate: Uvector basic operations
f16vector-div: Uvector numeric operations
f16vector-div!: Uvector numeric operations
f16vector-dot: Uvector numeric operations
f16vector-drop: Uvector basic operations
f16vector-drop-right: Uvector basic operations
f16vector-drop-while: Uvector basic operations
f16vector-drop-while-right: Uvector basic operations
f16vector-empty?: Uvector basic operations
f16vector-every: Uvector basic operations
f16vector-fill!: Uvector basic operations
f16vector-filter: Uvector basic operations
f16vector-fold: Uvector basic operations
f16vector-for-each: Uvector basic operations
f16vector-index: Uvector basic operations
f16vector-index-right: Uvector basic operations
f16vector-length: Uvector basic operations
f16vector-map: Uvector basic operations
f16vector-map!: Uvector basic operations
f16vector-mul: Uvector numeric operations
f16vector-mul!: Uvector numeric operations
f16vector-multi-copy!: Uvector basic operations
f16vector-partition: Uvector basic operations
f16vector-range-check: Uvector numeric operations
f16vector-ref: Uniform vectors
f16vector-remove: Uvector basic operations
f16vector-reverse!: Uvector basic operations
f16vector-reverse-copy: Uvector basic operations
f16vector-reverse-copy!: Uvector basic operations
f16vector-segment: Uvector basic operations
f16vector-set!: Uniform vectors
f16vector-skip: Uvector basic operations
f16vector-skip-right: Uvector basic operations
f16vector-sub: Uvector numeric operations
f16vector-sub!: Uvector numeric operations
f16vector-swap!: Uvector basic operations
f16vector-take: Uvector basic operations
f16vector-take-right: Uvector basic operations
f16vector-take-while: Uvector basic operations
f16vector-take-while-right: Uvector basic operations
f16vector-unfod-right!: Uvector basic operations
f16vector-unfold: Uvector basic operations
f16vector-unfold: Uvector basic operations
f16vector-unfold!: Uvector basic operations
f16vector-unfold!: Uvector basic operations
f16vector-unfold-right: Uvector basic operations
f16vector-unfold-right!: Uvector basic operations
f16vector=: Uvector basic operations
f16vector=?: Uvector basic operations
f16vector?: Uniform vectors
f32?: Uvector basic operations
f32array: Arrays
f32ite-u8vector: Uvector block I/O
f32ke-u8vector-generator: Uvector basic operations
f32vector: Uvector basic operations
f32vector->list: Uvector conversion operations
f32vector->vector: Uvector conversion operations
f32vector-add: Uvector numeric operations
f32vector-add!: Uvector numeric operations
f32vector-any: Uvector basic operations
f32vector-append: Uvector basic operations
f32vector-append-subvectors: Uvector basic operations
f32vector-clamp: Uvector numeric operations
f32vector-clamp!: Uvector numeric operations
f32vector-compare: Uvector basic operations
f32vector-concatenate: Uvector basic operations
f32vector-copy: Uvector basic operations
f32vector-copy!: Uvector basic operations
f32vector-count: Uvector basic operations
f32vector-cumulate: Uvector basic operations
f32vector-div: Uvector numeric operations
f32vector-div!: Uvector numeric operations
f32vector-dot: Uvector numeric operations
f32vector-drop: Uvector basic operations
f32vector-drop-right: Uvector basic operations
f32vector-drop-while: Uvector basic operations
f32vector-drop-while-right: Uvector basic operations
f32vector-empty?: Uvector basic operations
f32vector-every: Uvector basic operations
f32vector-fill!: Uvector basic operations
f32vector-filter: Uvector basic operations
f32vector-fold: Uvector basic operations
f32vector-for-each: Uvector basic operations
f32vector-index: Uvector basic operations
f32vector-index-right: Uvector basic operations
f32vector-length: Uvector basic operations
f32vector-map: Uvector basic operations
f32vector-map!: Uvector basic operations
f32vector-mul: Uvector numeric operations
f32vector-mul!: Uvector numeric operations
f32vector-multi-copy!: Uvector basic operations
f32vector-partition: Uvector basic operations
f32vector-range-check: Uvector numeric operations
f32vector-ref: Uniform vectors
f32vector-remove: Uvector basic operations
f32vector-reverse!: Uvector basic operations
f32vector-reverse-copy: Uvector basic operations
f32vector-reverse-copy!: Uvector basic operations
f32vector-segment: Uvector basic operations
f32vector-set!: Uniform vectors
f32vector-skip: Uvector basic operations
f32vector-skip-right: Uvector basic operations
f32vector-sub: Uvector numeric operations
f32vector-sub!: Uvector numeric operations
f32vector-swap!: Uvector basic operations
f32vector-take: Uvector basic operations
f32vector-take-right: Uvector basic operations
f32vector-take-while: Uvector basic operations
f32vector-take-while-right: Uvector basic operations
f32vector-unfod-right!: Uvector basic operations
f32vector-unfold: Uvector basic operations
f32vector-unfold: Uvector basic operations
f32vector-unfold!: Uvector basic operations
f32vector-unfold!: Uvector basic operations
f32vector-unfold-right: Uvector basic operations
f32vector-unfold-right!: Uvector basic operations
f32vector=: Uvector basic operations
f32vector=?: Uvector basic operations
f32vector?: Uniform vectors
f64?: Uvector basic operations
f64array: Arrays
f64ite-u8vector: Uvector block I/O
f64ke-u8vector-generator: Uvector basic operations
f64vector: Uvector basic operations
f64vector->list: Uvector conversion operations
f64vector->vector: Uvector conversion operations
f64vector-add: Uvector numeric operations
f64vector-add!: Uvector numeric operations
f64vector-any: Uvector basic operations
f64vector-append: Uvector basic operations
f64vector-append-subvectors: Uvector basic operations
f64vector-clamp: Uvector numeric operations
f64vector-clamp!: Uvector numeric operations
f64vector-compare: Uvector basic operations
f64vector-concatenate: Uvector basic operations
f64vector-copy: Uvector basic operations
f64vector-copy!: Uvector basic operations
f64vector-count: Uvector basic operations
f64vector-cumulate: Uvector basic operations
f64vector-div: Uvector numeric operations
f64vector-div!: Uvector numeric operations
f64vector-dot: Uvector numeric operations
f64vector-drop: Uvector basic operations
f64vector-drop-right: Uvector basic operations
f64vector-drop-while: Uvector basic operations
f64vector-drop-while-right: Uvector basic operations
f64vector-empty?: Uvector basic operations
f64vector-every: Uvector basic operations
f64vector-fill!: Uvector basic operations
f64vector-filter: Uvector basic operations
f64vector-fold: Uvector basic operations
f64vector-for-each: Uvector basic operations
f64vector-index: Uvector basic operations
f64vector-index-right: Uvector basic operations
f64vector-length: Uvector basic operations
f64vector-map: Uvector basic operations
f64vector-map!: Uvector basic operations
f64vector-mul: Uvector numeric operations
f64vector-mul!: Uvector numeric operations
f64vector-multi-copy!: Uvector basic operations
f64vector-partition: Uvector basic operations
f64vector-range-check: Uvector numeric operations
f64vector-ref: Uniform vectors
f64vector-remove: Uvector basic operations
f64vector-reverse!: Uvector basic operations
f64vector-reverse-copy: Uvector basic operations
f64vector-reverse-copy!: Uvector basic operations
f64vector-segment: Uvector basic operations
f64vector-set!: Uniform vectors
f64vector-skip: Uvector basic operations
f64vector-skip-right: Uvector basic operations
f64vector-sub: Uvector numeric operations
f64vector-sub!: Uvector numeric operations
f64vector-swap!: Uvector basic operations
f64vector-take: Uvector basic operations
f64vector-take-right: Uvector basic operations
f64vector-take-while: Uvector basic operations
f64vector-take-while-right: Uvector basic operations
f64vector-unfod-right!: Uvector basic operations
f64vector-unfold: Uvector basic operations
f64vector-unfold: Uvector basic operations
f64vector-unfold!: Uvector basic operations
f64vector-unfold!: Uvector basic operations
f64vector-unfold-right: Uvector basic operations
f64vector-unfold-right!: Uvector basic operations
f64vector=: Uvector basic operations
f64vector=?: Uvector basic operations
f64vector?: Uniform vectors
fd->port: POSIX API
feature-cond: Feature-based program configuration language
features: R7RS base library
fifth: R7RS lists
file->byte-generator: Generator constructors
file->char-generator: Generator constructors
file->generator: Generator constructors
file->line-generator: Generator constructors
file->list: File operations
file->sexp-generator: Generator constructors
file->sexp-list: File operations
file->string: File operations
file->string-list: File operations
file-atime: File attribute utilities
file-atime<=?: File attribute utilities
file-atime<?: File attribute utilities
file-atime=?: File attribute utilities
file-atime>=?: File attribute utilities
file-atime>?: File attribute utilities
file-ctime: File attribute utilities
file-ctime<=?: File attribute utilities
file-ctime<?: File attribute utilities
file-ctime=?: File attribute utilities
file-ctime>=?: File attribute utilities
file-ctime>?: File attribute utilities
file-dev: File attribute utilities
file-eq?: File attribute utilities
file-equal?: File attribute utilities
file-eqv?: File attribute utilities
file-error?: R7RS base library
file-exists?: File stats
file-filter: Filtering file content
file-filter-fold: Filtering file content
file-filter-for-each: Filtering file content
file-filter-map: Filtering file content
file-gid: File attribute utilities
file-info: POSIX API
file-info-device?: POSIX API
file-info-directory?: POSIX API
file-info-fifo?: POSIX API
file-info-regular?: POSIX API
file-info-socket?: POSIX API
file-info-symlink?: POSIX API
file-info:atime: POSIX API
file-info:blksize: POSIX API
file-info:blocks: POSIX API
file-info:ctime: POSIX API
file-info:device: POSIX API
file-info:gid: POSIX API
file-info:inode: POSIX API
file-info:mode: POSIX API
file-info:mtime: POSIX API
file-info:nlinks: POSIX API
file-info:rdev: POSIX API
file-info:size: POSIX API
file-info:uid: POSIX API
file-info?: POSIX API
file-ino: File attribute utilities
file-is-directory?: File stats
file-is-executable?: File attribute utilities
file-is-readable?: File attribute utilities
file-is-regular?: File stats
file-is-symlink?: File attribute utilities
file-is-writable?: File attribute utilities
file-mode: File attribute utilities
file-mtime: File attribute utilities
file-mtime<=?: File attribute utilities
file-mtime<?: File attribute utilities
file-mtime=?: File attribute utilities
file-mtime>=?: File attribute utilities
file-mtime>?: File attribute utilities
file-nlink: File attribute utilities
file-perm: File attribute utilities
file-rdev: File attribute utilities
file-size: File attribute utilities
file-space: POSIX API
file-type: File attribute utilities
file-uid: File attribute utilities
files: Feature-based program configuration language
filter: Walking over lists
filter: Selection and searching in collection
filter!: Walking over lists
filter$: Combinators
filter-map: Walking over lists
filter-to: Selection and searching in collection
find: Walking over lists
find: Selection and searching in collection
find$: Combinators
find-file-in-paths: Pathname utilities
find-gauche-package-description: Package metainformation
find-in-queue: Queue
find-index: Mapping over sequences
find-max: Selection and searching in collection
find-min: Selection and searching in collection
find-min&max: Selection and searching in collection
find-module: Module introspection
find-string-from-port?: Parsing input stream
find-tail: Walking over lists
find-tail$: Combinators
find-with-index: Mapping over sequences
finite?: Numerical predicates
first: R7RS lists
first-ec: Eager comprehensions
first-set-bit: R7RS bitwise operations
fitted: R7RS combinator formatting
fitted/both: R7RS combinator formatting
fitted/right: R7RS combinator formatting
fixnum-width: Arithmetics
fixnum?: Numerical predicates
fixnums: Random data generators
fixnums$: Random data generators
fl*: R7RS flonum
fl+: R7RS flonum
fl+*: R7RS flonum
fl-: R7RS flonum
fl-: R7RS flonum
fl<=?: R7RS flonum
fl<?: R7RS flonum
fl=?: R7RS flonum
fl>=?: R7RS flonum
fl>?: R7RS flonum
flabs: R7RS flonum
flabsdiff: R7RS flonum
flacos: R7RS flonum
flacosh: R7RS flonum
fladjacent: R7RS flonum
flasin: R7RS flonum
flasinh: R7RS flonum
flatan: R7RS flonum
flatan: R7RS flonum
flatanh: R7RS flonum
flcbrt: R7RS flonum
flceiling: R7RS flonum
flcopysign: R7RS flonum
flcos: R7RS flonum
flcosh: R7RS flonum
fldenominator: R7RS flonum
fldenormalized?: R7RS flonum
flerf: R7RS flonum
flerfc: R7RS flonum
fleven?: R7RS flonum
flexp: R7RS flonum
flexp-1: R7RS flonum
flexp2: R7RS flonum
flexponent: R7RS flonum
flexpt: R7RS flonum
flfinite?: R7RS flonum
flfirst-bessel: R7RS flonum
flfloor: R7RS flonum
flgamma: R7RS flonum
flhypot: R7RS flonum
flinfinite?: R7RS flonum
flinteger-exponent: R7RS flonum
flinteger-fraction: R7RS flonum
flinteger?: R7RS flonum
flip: Combinators
fllog: R7RS flonum
fllog1+: R7RS flonum
fllog10: R7RS flonum
fllog2: R7RS flonum
flloggamma: R7RS flonum
flmax: R7RS flonum
flmin: R7RS flonum
flnan?: R7RS flonum
flnevative?: R7RS flonum
flnormalized-fraction-exponent: R7RS flonum
flnormalized?: R7RS flonum
flnumerator: R7RS flonum
flodd?: R7RS flonum
flonum: R7RS flonum
flonum-epsilon: Numerical comparison
flonum-min-denormalized: Numerical comparison
flonum-min-normalized: Numerical comparison
flonum?: Numerical predicates
floor: Arithmetics
floor->exact: Arithmetics
floor-quotient: Arithmetics
floor-remainder: Arithmetics
floor/: Arithmetics
flposdiff: R7RS flonum
flpositive?: R7RS flonum
flquotient: R7RS flonum
flremainder: R7RS flonum
flremquo: R7RS flonum
flround: R7RS flonum
flsecond-bessel: R7RS flonum
flsgn: R7RS flonum
flsign-bit: R7RS flonum
flsin: R7RS flonum
flsinh: R7RS flonum
flsqrt: R7RS flonum
flsquare: R7RS flonum
fltan: R7RS flonum
fltanh: R7RS flonum
fltruncate: R7RS flonum
fluid-let: Binding constructs
flunordered?: R7RS flonum
flush: Low-level output
flush-all-ports: Low-level output
flush-output-port: R7RS base library
flzero?: R7RS flonum
fmod: Numerical conversions
fn: R7RS combinator formatting
fold: Walking over lists
fold: Mapping over collection
fold$: Combinators
fold$: Mapping over collection
fold$: Mapping over collection
fold-ec: Eager comprehensions
fold-left: Walking over lists
fold-right: Walking over lists
fold-right: Mapping over sequences
fold-right$: Combinators
fold-with-index: Mapping over sequences
fold2: Mapping over collection
fold3: Mapping over collection
fold3-ec: Eager comprehensions
for: CiSE syntax
for: CiSE syntax
for-each: Walking over lists
for-each: CiSE syntax
for-each: Mapping over collection
for-each$: Combinators
for-each$: Mapping over collection
for-each-with-index: Mapping over sequences
force: Delay force and lazy
forked: R7RS combinator formatting
format: Formatting output
format: Localization
fourth: R7RS lists
free-identifier=?: Identifiers
fresh-line: Object output
frexp: Numerical conversions
from-file: R7RS combinator formatting
ftp-chdir: FTP
ftp-current-directory: FTP
ftp-get: FTP
ftp-help: FTP
ftp-list: FTP
ftp-login: FTP
ftp-ls: FTP
ftp-mdtm: FTP
ftp-mkdir: FTP
ftp-mtime: FTP
ftp-name-list: FTP
ftp-noop: FTP
ftp-passive?: FTP
ftp-put: FTP
ftp-put-unique: FTP
ftp-quit: FTP
ftp-remove: FTP
ftp-rename: FTP
ftp-rmdir: FTP
ftp-site: FTP
ftp-size: FTP
ftp-stat: FTP
ftp-system: FTP
ftp-transfer-type: FTP
funcall-procedure: Combinators (SRFI)
future: Futures
future-done?: Futures
future-get: Futures
future?: Futures
fx*: R7RS fixnum
fx*/carry: R7RS fixnum
fx+: R7RS fixnum
fx+/carry: R7RS fixnum
fx-: R7RS fixnum
fx-/carry: R7RS fixnum
fx<=?: R7RS fixnum
fx<?: R7RS fixnum
fx=?: R7RS fixnum
fx>=?: R7RS fixnum
fx>?: R7RS fixnum
fxabs: R7RS fixnum
fxand: R7RS fixnum
fxarithmetic-shift: R7RS fixnum
fxbit-count: R7RS fixnum
fxbit-field: R7RS fixnum
fxbit-field-rotate: R7RS fixnum
fxbit-field-rotate: R7RS fixnum
fxbit-set?: R7RS fixnum
fxcopy-bit: R7RS fixnum
fxeven?: R7RS fixnum
fxfirst-set-bit: R7RS fixnum
fxif: R7RS fixnum
fxior: R7RS fixnum
fxlength: R7RS fixnum
fxmax: R7RS fixnum
fxmin: R7RS fixnum
fxneg: R7RS fixnum
fxnegative?: R7RS fixnum
fxnot: R7RS fixnum
fxodd?: R7RS fixnum
fxpositive?: R7RS fixnum
fxquotient: R7RS fixnum
fxremainder: R7RS fixnum
fxsqrt: R7RS fixnum
fxsquare: R7RS fixnum
fxxor: R7RS fixnum
fxzero?: R7RS fixnum

G
gamma: Arithmetics
gap-buffer->generator: Gap buffer
gap-buffer->string: Gap buffer
gap-buffer-capacity: Gap buffer
gap-buffer-clear!: Gap buffer
gap-buffer-contains: Gap buffer
gap-buffer-content-length: Gap buffer
gap-buffer-copy: Gap buffer
gap-buffer-delete!: Gap buffer
gap-buffer-edit!: Gap buffer
gap-buffer-gap-at?: Gap buffer
gap-buffer-insert!: Gap buffer
gap-buffer-looking-at?: Gap buffer
gap-buffer-move!: Gap buffer
gap-buffer-pos: Gap buffer
gap-buffer-pos-at-end?: Gap buffer
gap-buffer-ref: Gap buffer
gap-buffer-replace!: Gap buffer
gap-buffer-set!: Gap buffer
gap-buffer?: Gap buffer
gappend: Generator operations
gauche-architecture: Environment inquiry
gauche-architecture-directory: Environment inquiry
gauche-character-encoding: Characters
gauche-config: Configuration parameters
gauche-library-directory: Environment inquiry
gauche-package-description-paths: Package metainformation
gauche-site-architecture-directory: Environment inquiry
gauche-site-library-directory: Environment inquiry
gauche-thread-type: Threads
gauche-version: Environment inquiry
gbuffer-filter: Generator operations
gc: Garbage collection
gc-stat: Garbage collection
gcd: Arithmetics
gchoice: Generator/accumulator sub-library
gcombine: Generator operations
gcompose-left: Generator/accumulator sub-library
gcompose-right: Generator/accumulator sub-library
gconcatenate: Generator operations
gcons*: Generator operations
gdbm-close: GDBM interface
gdbm-closed?: GDBM interface
gdbm-delete: GDBM interface
gdbm-errno: GDBM interface
gdbm-exists?: GDBM interface
gdbm-fetch: GDBM interface
gdbm-firstkey: GDBM interface
gdbm-nextkey: GDBM interface
gdbm-open: GDBM interface
gdbm-reorganize: GDBM interface
gdbm-setopt: GDBM interface
gdbm-store: GDBM interface
gdbm-strerror: GDBM interface
gdbm-sync: GDBM interface
gdbm-version: GDBM interface
gdelete: Generator operations
gdelete-neighbor-dups: Generator operations
gdrop: Generator operations
gdrop-while: Generator operations
generate: Generator constructors
generation->either: Maybe and Either protocol converters
generation->maybe: Maybe and Either protocol converters
generator: Generator constructors
generator->bytevector: Generator consumers
generator->bytevector!: Generator consumers
generator->cseq: Concurrent sequences
generator->ideque: R7RS immutable deques
generator->list: Generator consumers
generator->lseq: Lazy sequences
generator->lseq: Lazy sequences
generator->lseq/position: Lazy sequence with positions
generator->reverse-list: Generator consumers
generator->stream: Generator/accumulator sub-library
generator->stream: Stream constructors
generator->string: Generator consumers
generator->uvector: Generator consumers
generator->uvector!: Generator consumers
generator->vector: Generator consumers
generator->vector!: Generator consumers
generator-any: Generator consumers
generator-count: Generator consumers
generator-every: Generator consumers
generator-find: Folding generated values
generator-fold: Folding generated values
generator-fold-right: Folding generated values
generator-for-each: Folding generated values
generator-map: Folding generated values
generator-map->list: Generator consumers
generator-unfold: Generator consumers
gensym: Symbols
genumerate: Generator/accumulator sub-library
get-environment-variable: Accessing environment variables
get-environment-variables: Accessing environment variables
get-f16: Binary I/O
get-f16be: Binary I/O
get-f16le: Binary I/O
get-f32: Binary I/O
get-f32be: Binary I/O
get-f32le: Binary I/O
get-f64: Binary I/O
get-f64be: Binary I/O
get-f64le: Binary I/O
get-keyword: Keywords
get-keyword*: Keywords
get-optional: Optional argument parsing
get-output-bytevector: Virtual ports
get-output-string: String ports
get-output-uvector: Virtual ports
get-remaining-input-generator: Virtual ports
get-remaining-input-list: Virtual ports
get-remaining-input-string: String ports
get-s16: Binary I/O
get-s16be: Binary I/O
get-s16le: Binary I/O
get-s32: Binary I/O
get-s32be: Binary I/O
get-s32le: Binary I/O
get-s64: Binary I/O
get-s64be: Binary I/O
get-s64le: Binary I/O
get-s8: Binary I/O
get-signal-handler: Handling signals
get-signal-handler-mask: Handling signals
get-signal-handlers: Handling signals
get-signal-pending-limit: Handling signals
get-sint: Binary I/O
get-u16: Binary I/O
get-u16be: Binary I/O
get-u16le: Binary I/O
get-u32: Binary I/O
get-u32be: Binary I/O
get-u32le: Binary I/O
get-u64: Binary I/O
get-u64be: Binary I/O
get-u64le: Binary I/O
get-u8: Binary I/O
get-uint: Binary I/O
getch: Text terminal control
getter-with-setter: Assignments
gettext: Localized messages
gfilter: Generator operations
gfilter-map: Generator operations
gflatten: Generator operations
ggroup: Generator operations
gindex: Generator operations
giota: Generator constructors
giterate: Generator constructors
giterate1: Generator constructors
glet*: Generator consumers
glet1: Generator consumers
glob: Directories
glob-fold: Directories
global-variable-bound?: Module introspection
global-variable-ref: Module introspection
gmap: Generator operations
gmap-accum: Generator operations
gmerge: Generator operations
goto: CiSE syntax
grange: Generator constructors
greatest-fixnum: Arithmetics
gremove: Generator operations
group-by: Combinators (SRFI)
group-collection: Selection and searching in collection
group-contiguous-sequence: Other operations over sequences
group-info: POSIX API
group-info:gid: POSIX API
group-info:name: POSIX API
group-info?: POSIX API
group-sequence: Other operations over sequences
grxmatch: Generator operations
gsampling: Random data generators (SRFI)
gselect: Generator operations
gslices: Generator operations
gstate-filter: Generator operations
gtake: Generator operations
gtake*: Generator operations
gtake-while: Generator operations
guard: High-level exception handling mechanism
gunfold: Generator constructors
gzip-decode-string: Zlib compression library
gzip-encode-string: Zlib compression library

H
has-setter?: Assignments
has-windows-console?: Common high-level terminal control
hash: Hashing
hash: R7RS hash tables
hash: Basic hash tables
hash-bound: Hashing
hash-by-identity: R7RS hash tables
hash-by-identity: Basic hash tables
hash-salt: Hashing
hash-table: Hashtables
hash-table: R7RS hash tables
hash-table->alist: Hashtables
hash-table-clear!: Hashtables
hash-table-comparator: Hashtables
hash-table-compare-as-sets: Hashtables
hash-table-contains?: Hashtables
hash-table-copy: Hashtables
hash-table-count: R7RS hash tables
hash-table-delete!: Hashtables
hash-table-delete!: R7RS hash tables
hash-table-delete!-r7: Hashtables
hash-table-difference!: Hashtables
hash-table-empty-copy: Hashtables
hash-table-equivalence-function: R7RS hash tables
hash-table-equivalence-function: Basic hash tables
hash-table-exists?: Hashtables
hash-table-find: Hashtables
hash-table-find: R7RS hash tables
hash-table-fold: Hashtables
hash-table-fold: R7RS hash tables
hash-table-fold: R7RS hash tables
hash-table-for-each: Hashtables
hash-table-for-each: R7RS hash tables
hash-table-for-each: R7RS hash tables
hash-table-from-pairs: Hashtables
hash-table-get: Hashtables
hash-table-hash-function: R7RS hash tables
hash-table-hash-function: Basic hash tables
hash-table-intern!: R7RS hash tables
hash-table-intern!-r7: Hashtables
hash-table-intersection!: Hashtables
hash-table-keys: Hashtables
hash-table-map: Hashtables
hash-table-map: R7RS hash tables
hash-table-map!: R7RS hash tables
hash-table-map->list: R7RS hash tables
hash-table-merge!: R7RS hash tables
hash-table-merge!: Basic hash tables
hash-table-mutable?: Hashtables
hash-table-num-entries: Hashtables
hash-table-pop!: Hashtables
hash-table-pop!: R7RS hash tables
hash-table-pop!-r7: Hashtables
hash-table-prune!: R7RS hash tables
hash-table-push!: Hashtables
hash-table-put!: Hashtables
hash-table-r7: Hashtables
hash-table-ref: Hashtables
hash-table-ref: Basic hash tables
hash-table-ref/default: Hashtables
hash-table-ref/default: Basic hash tables
hash-table-set!: Hashtables
hash-table-set!: Basic hash tables
hash-table-size: Hashtables
hash-table-size: Basic hash tables
hash-table-type: Hashtables
hash-table-unfold: Hashtables
hash-table-unfold: R7RS hash tables
hash-table-union!: Hashtables
hash-table-update!: Hashtables
hash-table-update!: R7RS hash tables
hash-table-update!: Basic hash tables
hash-table-update!-r7: Hashtables
hash-table-update!/default: Hashtables
hash-table-update!/default: Basic hash tables
hash-table-values: Hashtables
hash-table-walk: Basic hash tables
hash-table-xor!: Hashtables
hash-table=?: Hashtables
hash-table?: Hashtables
hashmap: Hashmaps
hashmap->alist: Hashmaps
hashmap-adjoin: Hashmaps
hashmap-adjoin!: Hashmaps
hashmap-any?: Hashmaps
hashmap-contains?: Hashmaps
hashmap-copy: Hashmaps
hashmap-count: Hashmaps
hashmap-delete: Hashmaps
hashmap-delete!: Hashmaps
hashmap-delete-all: Hashmaps
hashmap-delete-all!: Hashmaps
hashmap-difference: Hashmaps
hashmap-difference!: Hashmaps
hashmap-disjoint?: Hashmaps
hashmap-empty?: Hashmaps
hashmap-entries: Hashmaps
hashmap-every?: Hashmaps
hashmap-filter: Hashmaps
hashmap-filter!: Hashmaps
hashmap-find: Hashmaps
hashmap-fold: Hashmaps
hashmap-for-each: Hashmaps
hashmap-intern: Hashmaps
hashmap-intern!: Hashmaps
hashmap-intersection: Hashmaps
hashmap-intersection!: Hashmaps
hashmap-key-comparator: Hashmaps
hashmap-keys: Hashmaps
hashmap-map: Hashmaps
hashmap-map->list: Hashmaps
hashmap-partition: Hashmaps
hashmap-partition!: Hashmaps
hashmap-pop: Hashmaps
hashmap-pop!: Hashmaps
hashmap-ref: Hashmaps
hashmap-ref/default: Hashmaps
hashmap-remove: Hashmaps
hashmap-remove!: Hashmaps
hashmap-replace: Hashmaps
hashmap-replace!: Hashmaps
hashmap-search: Hashmaps
hashmap-search!: Hashmaps
hashmap-set: Hashmaps
hashmap-set!: Hashmaps
hashmap-size: Hashmaps
hashmap-unfold: Hashmaps
hashmap-union: Hashmaps
hashmap-union!: Hashmaps
hashmap-update: Hashmaps
hashmap-update!: Hashmaps
hashmap-update!/default: Hashmaps
hashmap-update/default: Hashmaps
hashmap-values: Hashmaps
hashmap-xor: Hashmaps
hashmap-xor!: Hashmaps
hashmap<=?: Hashmaps
hashmap<?: Hashmaps
hashmap=?: Hashmaps
hashmap>=?: Hashmaps
hashmap>?: Hashmaps
hashmap?: Hashmaps
hex-string->bytevector: String-notated bytevectors
hide-cursor: Text terminal control
hmac-digest: HMAC keyed-hashing
hmac-digest-string: HMAC keyed-hashing
hmac-final!: HMAC keyed-hashing
hmac-message: HMAC keyed-hashing
hmac-message-to: HMAC keyed-hashing
hmac-to: HMAC keyed-hashing
hmac-update!: HMAC keyed-hashing
hmac-verify: HMAC keyed-hashing
home-directory: Directory utilities
hook->list: Hooks
hook-add!: Hooks (srfi)
hook-delete!: Hooks (srfi)
hook-empty?: Hooks
hook-reset!: Hooks (srfi)
hook-run: Hooks (srfi)
hook?: Hooks
html-doctype: Simple HTML document construction
html-escape: Simple HTML document construction
html-escape-string: Simple HTML document construction
html:a: Simple HTML document construction
html:abbr: Simple HTML document construction
html:acronym: Simple HTML document construction
html:address: Simple HTML document construction
html:area: Simple HTML document construction
html:b: Simple HTML document construction
html:base: Simple HTML document construction
html:bdo: Simple HTML document construction
html:big: Simple HTML document construction
html:blockquote: Simple HTML document construction
html:body: Simple HTML document construction
html:br: Simple HTML document construction
html:button: Simple HTML document construction
html:caption: Simple HTML document construction
html:cite: Simple HTML document construction
html:code: Simple HTML document construction
html:col: Simple HTML document construction
html:colgroup: Simple HTML document construction
html:dd: Simple HTML document construction
html:del: Simple HTML document construction
html:dfn: Simple HTML document construction
html:div: Simple HTML document construction
html:dl: Simple HTML document construction
html:dt: Simple HTML document construction
html:em: Simple HTML document construction
html:fieldset: Simple HTML document construction
html:form: Simple HTML document construction
html:frame: Simple HTML document construction
html:frameset: Simple HTML document construction
html:h1: Simple HTML document construction
html:h2: Simple HTML document construction
html:h3: Simple HTML document construction
html:h4: Simple HTML document construction
html:h5: Simple HTML document construction
html:h6: Simple HTML document construction
html:head: Simple HTML document construction
html:hr: Simple HTML document construction
html:html: Simple HTML document construction
html:i: Simple HTML document construction
html:iframe: Simple HTML document construction
html:img: Simple HTML document construction
html:input: Simple HTML document construction
html:ins: Simple HTML document construction
html:kbd: Simple HTML document construction
html:label: Simple HTML document construction
html:legend: Simple HTML document construction
html:li: Simple HTML document construction
html:link: Simple HTML document construction
html:map: Simple HTML document construction
html:meta: Simple HTML document construction
html:noframes: Simple HTML document construction
html:noscript: Simple HTML document construction
html:object: Simple HTML document construction
html:ol: Simple HTML document construction
html:optgroup: Simple HTML document construction
html:option: Simple HTML document construction
html:p: Simple HTML document construction
html:param: Simple HTML document construction
html:pre: Simple HTML document construction
html:q: Simple HTML document construction
html:samp: Simple HTML document construction
html:script: Simple HTML document construction
html:select: Simple HTML document construction
html:small: Simple HTML document construction
html:span: Simple HTML document construction
html:strong: Simple HTML document construction
html:style: Simple HTML document construction
html:sub: Simple HTML document construction
html:sup: Simple HTML document construction
html:table: Simple HTML document construction
html:tbody: Simple HTML document construction
html:td: Simple HTML document construction
html:textarea: Simple HTML document construction
html:tfoot: Simple HTML document construction
html:th: Simple HTML document construction
html:thead: Simple HTML document construction
html:title: Simple HTML document construction
html:tr: Simple HTML document construction
html:tt: Simple HTML document construction
html:ul: Simple HTML document construction
html:var: Simple HTML document construction
http-compose-form-data: Http client utilities
http-compose-query: Http client utilities
http-default-redirect-handler: Http client utilities
http-delete: Http client mid-level API
http-get: Http client mid-level API
http-head: Http client mid-level API
http-post: Http client mid-level API
http-proxy: Http client utilities
http-put: Http client mid-level API
http-secure-connection-available?: Secure http connection
http-status-code->description: Http client utilities
http-user-agent: Http client utilities

I
i/o-decoding-error?: Transcoded ports
i/o-encoding-error-char: Transcoded ports
i/o-encoding-error?: Transcoded ports
i/o-invalid-position-error?: Port positioning
iany: R7RS immutable lists
iapply: R7RS immutable lists
iassoc: R7RS immutable lists
iassq: R7RS immutable lists
iassv: R7RS immutable lists
icaaaar: R7RS immutable lists
icaaadr: R7RS immutable lists
icaaar: R7RS immutable lists
icaadar: R7RS immutable lists
icaaddr: R7RS immutable lists
icaadr: R7RS immutable lists
icaar: R7RS immutable lists
icadaar: R7RS immutable lists
icadadr: R7RS immutable lists
icadar: R7RS immutable lists
icaddar: R7RS immutable lists
icadddr: R7RS immutable lists
icaddr: R7RS immutable lists
icadr: R7RS immutable lists
icar: R7RS immutable lists
icar+icdr: R7RS immutable lists
icdaaar: R7RS immutable lists
icdaadr: R7RS immutable lists
icdaar: R7RS immutable lists
icdadar: R7RS immutable lists
icdaddr: R7RS immutable lists
icdadr: R7RS immutable lists
icdar: R7RS immutable lists
icddaar: R7RS immutable lists
icddadr: R7RS immutable lists
icddar: R7RS immutable lists
icdddar: R7RS immutable lists
icddddr: R7RS immutable lists
icdddr: R7RS immutable lists
icddr: R7RS immutable lists
icdr: R7RS immutable lists
icmp-packet-code: ICMP packets
icmp-packet-ident: ICMP packets
icmp-packet-sequence: ICMP packets
icmp-packet-type: ICMP packets
icmp4-describe-packet: ICMP packets
icmp4-exceeded-code->string: ICMP packets
icmp4-fill-checksum!: ICMP packets
icmp4-fill-echo!: ICMP packets
icmp4-message-type->string: ICMP packets
icmp4-parameter-code->string: ICMP packets
icmp4-redirect-code->string: ICMP packets
icmp4-router-code->string: ICMP packets
icmp4-security-code->string: ICMP packets
icmp4-unreach-code->string: ICMP packets
icmp6-describe-packet: ICMP packets
icmp6-exceeded-code->string: ICMP packets
icmp6-fill-echo!: ICMP packets
icmp6-message-type->string: ICMP packets
icmp6-parameter-code->string: ICMP packets
icmp6-unreach-code->string: ICMP packets
icount: R7RS immutable lists
identifier->symbol: Identifiers
identifier?: Identifiers
identity: Combinators
identity: Procedures and syntax for multiple values
identity-array: Arrays
ideque: R7RS immutable deques
ideque->generator: R7RS immutable deques
ideque->list: R7RS immutable deques
ideque-add-back: R7RS immutable deques
ideque-add-front: R7RS immutable deques
ideque-any: R7RS immutable deques
ideque-append: R7RS immutable deques
ideque-append-map: R7RS immutable deques
ideque-back: R7RS immutable deques
ideque-break: R7RS immutable deques
ideque-drop: R7RS immutable deques
ideque-drop-right: R7RS immutable deques
ideque-drop-while: R7RS immutable deques
ideque-drop-while-right: R7RS immutable deques
ideque-empty?: R7RS immutable deques
ideque-every: R7RS immutable deques
ideque-filter: R7RS immutable deques
ideque-filter-map: R7RS immutable deques
ideque-find: R7RS immutable deques
ideque-find-right: R7RS immutable deques
ideque-fold: R7RS immutable deques
ideque-fold-right: R7RS immutable deques
ideque-for-each: R7RS immutable deques
ideque-for-each-right: R7RS immutable deques
ideque-front: R7RS immutable deques
ideque-length: R7RS immutable deques
ideque-map: R7RS immutable deques
ideque-partition: R7RS immutable deques
ideque-ref: R7RS immutable deques
ideque-remove: R7RS immutable deques
ideque-remove-back: R7RS immutable deques
ideque-remove-front: R7RS immutable deques
ideque-reverse: R7RS immutable deques
ideque-span: R7RS immutable deques
ideque-split-at: R7RS immutable deques
ideque-tabulate: R7RS immutable deques
ideque-take: R7RS immutable deques
ideque-take-right: R7RS immutable deques
ideque-take-while: R7RS immutable deques
ideque-take-while-right: R7RS immutable deques
ideque-unfold: R7RS immutable deques
ideque-unfold-right: R7RS immutable deques
ideque-zip: R7RS immutable deques
ideque=: R7RS immutable deques
ideque?: R7RS immutable deques
idrop: R7RS immutable lists
idrop-while: R7RS immutable lists
ieighth: R7RS immutable lists
ievery: R7RS immutable lists
if: Conditionals
if: Conditionals
if: CiSE syntax
if: Stub generation
if: Eager comprehensions
if-car-sxpath: SXPath query language
if-let1: Binding constructs
if-let1: Binding constructs
if-not=?: Comparators
if-procedure: Combinators (SRFI)
if-sxpath: SXPath query language
if3: Comparators
if<=?: Comparators
if<?: Comparators
if=?: Comparators
if>=?: Comparators
if>?: Comparators
ififth: R7RS immutable lists
ifind-tail: R7RS immutable lists
ifirst: R7RS immutable lists
ifold: R7RS immutable lists
ifold-right: R7RS immutable lists
ifor-each: R7RS immutable lists
ifourth: R7RS immutable lists
ilast: R7RS immutable lists
ilength: R7RS immutable lists
ilist: List constructors
ilist-index: R7RS immutable lists
ilist-ref: R7RS immutable lists
ilist-tail: R7RS immutable lists
ilist=: R7RS immutable lists
ilist?: R7RS immutable lists
imag-part: Numerical conversions
imap-delete: Immutable map
imap-empty?: Immutable map
imap-exists?: Immutable map
imap-get: Immutable map
imap-max: Immutable map
imap-min: Immutable map
imap-put: Immutable map
imap?: Immutable map
imember: R7RS immutable lists
imemq: R7RS immutable lists
imemv: R7RS immutable lists
implementation-name: Portable runtime environment inquiry
implementation-version: Portable runtime environment inquiry
import: Using modules
import: Three forms of import
in-closed-interval?: Comparators
in-closed-open-interval?: Comparators
in-open-closed-interval?: Comparators
in-open-interval?: Comparators
inc!: Assignments
include: Inclusions
include: Stub generation
include-ci: Inclusions
independently: Grouping
inet-address->string: Socket address
inet-checksum: Low-level socket interface
inet-string->address: Socket address
inet-string->address!: Socket address
inexact: Numerical conversions
inexact->exact: Numerical conversions
inexact->timespec: POSIX timespecs
inexact?: Numerical predicates
infinite?: Numerical predicates
inflate-string: Zlib compression library
inflate-sync: Zlib compression library
info: Interactive session
info-extract-definition: Accessing info document
info-get-node: Accessing info document
info-index->alist: Accessing info document
info-index-add!: Accessing info document
info-index-keys: Accessing info document
info-index-ref: Accessing info document
info-parse-menu: Accessing info document
info-search: Interactive session
ininth: R7RS immutable lists
initcode: Stub generation
initialize: Creating instance
initialize: Creating instance
initialize: Class instantiation
input-port-open?: R7RS base library
input-port?: Common port operations
instance-of: Singleton
instance-pool->list: Instance pools
instance-pool-find: Instance pools
instance-pool-fold: Instance pools
instance-pool-for-each: Instance pools
instance-pool-map: Instance pools
instance-pool-remove!: Instance pools
int16s: Random data generators
int16s$: Random data generators
int32s: Random data generators
int32s$: Random data generators
int64s: Random data generators
int64s$: Random data generators
int8s: Random data generators
int8s$: Random data generators
integer->bitvector: Bitvector utilities
integer->char: Characters
integer->digit: Characters
integer->list: Integers as bits
integer->ulid: Universally unique lexicographically sortable identifier
integer-length: Basic bitwise operations
integer-range->char-set: Character-set constructors
integer-range->char-set!: Character-set constructors
integer-valued?: Numerical predicates
integer?: Numerical predicates
integers$: Random data generators
integers-between$: Random data generators
integers-geometric$: Random data generators
integers-poisson$: Random data generators
interaction-environment: Eval and repl
intersperse: List accessors and modifiers
inverse: Temporal relation
iota: List constructors
iota-range: Range
ip-destination-address: IP packets
ip-header-length: IP packets
ip-protocol: Basic socket interface
ip-protocol: IP packets
ip-source-address: IP packets
ip-version: IP packets
ipair: List constructors
ipair-fold: R7RS immutable lists
ipair-fold-right: R7RS immutable lists
ipair-for-each: R7RS immutable lists
ipair?: List predicates
ireduce: R7RS immutable lists
ireduce-right: R7RS immutable lists
is-a?: Generic type predicates
isecond: R7RS immutable lists
iset: Integer sets
iset->list: Integer sets
iset-adjoin: Integer sets
iset-adjoin!: Integer sets
iset-any?: Integer sets
iset-closed-interval: Integer sets
iset-closed-open-interval: Integer sets
iset-contains?: Integer sets
iset-copy: Integer sets
iset-count: Integer sets
iset-delete: Integer sets
iset-delete!: Integer sets
iset-delete-all: Integer sets
iset-delete-all!: Integer sets
iset-delete-max: Integer sets
iset-delete-max!: Integer sets
iset-delete-min: Integer sets
iset-delete-min!: Integer sets
iset-difference: Integer sets
iset-difference!: Integer sets
iset-disjoint?: Integer sets
iset-empty?: Integer sets
iset-every?: Integer sets
iset-filter: Integer sets
iset-filter!: Integer sets
iset-find: Integer sets
iset-fold: Integer sets
iset-fold-right: Integer sets
iset-for-each: Integer sets
iset-intersection: Integer sets
iset-intersection!: Integer sets
iset-map: Integer sets
iset-max: Integer sets
iset-member: Integer sets
iset-min: Integer sets
iset-open-closed-interval: Integer sets
iset-open-interval: Integer sets
iset-partition: Integer sets
iset-partition!: Integer sets
iset-remove: Integer sets
iset-remove!: Integer sets
iset-search: Integer sets
iset-search!: Integer sets
iset-size: Integer sets
iset-unfold: Integer sets
iset-union: Integer sets
iset-union!: Integer sets
iset-xor: Integer sets
iset-xor!: Integer sets
iset<=?: Integer sets
iset<?: Integer sets
iset=?: Integer sets
iset>=?: Integer sets
iset>?: Integer sets
iset?: Integer sets
iseventh: R7RS immutable lists
isixth: R7RS immutable lists
isomorphic?: Determine isomorphism
isubset<: Integer sets
isubset<=: Integer sets
isubset=: Integer sets
isubset>: Integer sets
isubset>=: Integer sets
itake-right: R7RS immutable lists
itenth: R7RS immutable lists
iterator->stream: Stream constructors
ithird: R7RS immutable lists

J
jacobi: Prime numbers
jiffies-per-second: R7RS time
job-acknowledge-time: A common job descriptor for control modules
job-finish-time: A common job descriptor for control modules
job-result: A common job descriptor for control modules
job-start-time: A common job descriptor for control modules
job-status: A common job descriptor for control modules
job-wait: A common job descriptor for control modules
job?: A common job descriptor for control modules
join-timeout-exception?: Thread exceptions
joined: R7RS combinator formatting
joined/dot: R7RS combinator formatting
joined/last: R7RS combinator formatting
joined/prefix: R7RS combinator formatting
joined/range: R7RS combinator formatting
joined/suffix: R7RS combinator formatting
json-accumulator: JSON
json-array-handler: JSON parsing and construction
json-error-reason: JSON
json-error?: JSON
json-fold: JSON
json-generator: JSON
json-lines-read: JSON
json-nesting-depth-limit: JSON parsing and construction
json-null?: JSON
json-number-of-character-limit: JSON
json-object-handler: JSON parsing and construction
json-read: JSON
json-sequence-read: JSON
json-special-handler: JSON parsing and construction
json-write: JSON
julian-day->date: SRFI-19 Date
julian-day->time-monotonic: SRFI-19 Date
julian-day->time-tai: SRFI-19 Date
julian-day->time-utc: SRFI-19 Date
just: Maybe and Either constructors
just?: Maybe and Either types and predicates
justified: R7RS combinator formatting

K
keyword->string: Keywords
keyword?: Keywords
kmp-step: SRFI-13 Low-level string procedures

L
l-distance: Levenshtein edit distance
l-distances: Levenshtein edit distance
label: CiSE syntax
lambda: Making procedures
lambda/tag: Tagged procedures
lappend: Lazy sequence operations
lappend-map: Lazy sequence operations
last: List accessors and modifiers
last-ec: Eager comprehensions
last-ipair: R7RS immutable lists
last-pair: List accessors and modifiers
latch-await: Latch
latch-clear!: Latch
latch-dec!: Latch
latch?: Latch
latin-1-codec: Transcoded ports
layout-multicolumn: Multicolumn formatting
lazy: Delay force and lazy
lazy-size-of: Miscellaneous operations on collection
lcm: Arithmetics
lconcatenate: Lazy sequence operations
lcons: Lazy sequences
lcons*: Lazy sequences
lcs: The longest common subsequence
lcs-edit-list: The longest common subsequence
lcs-edit-list/context: The longest common subsequence
lcs-edit-list/unified: The longest common subsequence
lcs-fold: The longest common subsequence
lcs-with-positions: The longest common subsequence
ldexp: Numerical conversions
least-fixnum: Arithmetics
left: Maybe and Either constructors
left-section: Combinators (SRFI)
left?: Maybe and Either types and predicates
legacy-hash: Hashing
length: List accessors and modifiers
length+: List accessors and modifiers
length<=?: List accessors and modifiers
length<?: List accessors and modifiers
length=?: List accessors and modifiers
length>=?: List accessors and modifiers
length>?: List accessors and modifiers
let: Binding constructs
let: Iteration
let: A compatible let form with signatures and rest arguments
let: A compatible let form with signatures and rest arguments
let: A compatible let form with signatures and rest arguments
let*: Binding constructs
let*: CiSE syntax
let*-values: Binding constructs
let-args: Parsing command-line options
let-keywords: Optional argument parsing
let-keywords: Optional argument parsing
let-keywords*: Optional argument parsing
let-keywords*: Optional argument parsing
let-optionals: Optional arguments
let-optionals*: Optional argument parsing
let-optionals*: Optional argument parsing
let-optionals*: Optional arguments
let-string-start+end: SRFI-13 Low-level string procedures
let-syntax: Hygienic macros
let-values: Binding constructs
let/cc: Continuations
let1: Binding constructs
letrec: Binding constructs
letrec*: Binding constructs
letrec-syntax: Hygienic macros
lfilter: Lazy sequence operations
lfilter-map: Lazy sequence operations
lgamma: Arithmetics
library-exists?: Operations on libraries
library-fold: Operations on libraries
library-for-each: Operations on libraries
library-has-module?: Operations on libraries
library-map: Operations on libraries
line-numbers: R7RS combinator formatting
linear-access-list->random-access-list: R7RS random-access lists
linterweave: Lazy sequence operations
liota: Lazy sequences
list: List constructors
list*: List constructors
list*->skew-list: Skew binary random-access lists
list->@vector: Uvector conversion operations
list->bag: R7RS sets
list->bag!: R7RS sets
list->bits: R7RS bitwise operations
list->bitvector: Bitvectors
list->c128vector: Uvector conversion operations
list->c32vector: Uvector conversion operations
list->c64vector: Uvector conversion operations
list->char-set: Character-set constructors
list->char-set!: Character-set constructors
list->either: Maybe and Either protocol converters
list->enum-set: Enums and enum sets
list->f16vector: Uvector conversion operations
list->f32vector: Uvector conversion operations
list->f64vector: Uvector conversion operations
list->file: File operations
list->generator: Generator constructors
list->hook: Hooks (srfi)
list->hook!: Hooks (srfi)
list->ideque: R7RS immutable deques
list->integer: Integers as bits
list->iset: Integer sets
list->iset!: Integer sets
list->just: Maybe and Either constructors
list->left: Maybe and Either constructors
list->maybe: Maybe and Either protocol converters
list->queue: Queue
list->right: Maybe and Either constructors
list->s16vector: Uvector conversion operations
list->s32vector: Uvector conversion operations
list->s64vector: Uvector conversion operations
list->s8vector: Uvector conversion operations
list->set: R7RS sets
list->set!: R7RS sets
list->skew-list: Skew binary random-access lists
list->stream: Stream constructors
list->string: String utilities
list->sys-fdset: I/O multiplexing
list->text: R7RS immutable texts
list->u16vector: Uvector conversion operations
list->u32vector: Uvector conversion operations
list->u64vector: Uvector conversion operations
list->u8vector: Uvector conversion operations
list->vector: Vectors
list-accumulator: R7RS generators
list-case: Destructuring lists
list-copy: List constructors
list-delete-neighbor-dups: R7RS sort
list-delete-neighbor-dups!: R7RS sort
list-ec: Eager comprehensions
list-index: R7RS lists
list-merge: R7RS sort
list-merge!: R7RS sort
list-queue: R7RS list queues
list-queue-add-back!: R7RS list queues
list-queue-add-front!: R7RS list queues
list-queue-append: R7RS list queues
list-queue-append!: R7RS list queues
list-queue-back: R7RS list queues
list-queue-concatenate: R7RS list queues
list-queue-copy: R7RS list queues
list-queue-empty?: R7RS list queues
list-queue-fist-last: R7RS list queues
list-queue-for-each: R7RS list queues
list-queue-front: R7RS list queues
list-queue-list: R7RS list queues
list-queue-map: R7RS list queues
list-queue-map!: R7RS list queues
list-queue-remove-all!: R7RS list queues
list-queue-remove-back!: R7RS list queues
list-queue-remove-front!: R7RS list queues
list-queue-set-list!: R7RS list queues
list-queue-unfold: R7RS list queues
list-queue-unfold-right: R7RS list queues
list-queue?: R7RS list queues
list-ref: List accessors and modifiers
list-ref/update: R7RS random-access lists
list-set: R7RS random-access lists
list-set!: List accessors and modifiers
list-sort: R7RS sort
list-sort!: R7RS sort
list-sorted?: R7RS sort
list-stable-sort: R7RS sort
list-stable-sort!: R7RS sort
list-tabulate: R7RS lists
list-tail: List accessors and modifiers
list-truth->either: Maybe and Either protocol converters
list-truth->maybe: Maybe and Either protocol converters
list-values: Procedures and syntax for multiple values
list/mv: Procedures and syntax for multiple values
list=: R7RS lists
list?: List predicates
listener-read-handler: Listener
listener-show-prompt: Listener
lists-of: Random data generators
lists-of: Random data generators
literate: Lazy sequence constructors
llist*: Lazy sequences
lmap: Lazy sequence operations
lmap-accum: Lazy sequence operations
load: Loading Scheme file
load: R7RS load
load-bundle!: Localization
load-from-port: Loading Scheme file
localized-template: Localization
log: Arithmetics
log: Arithmetics
log-default-drain: User-level logging
log-format: User-level logging
log-format: User-level logging
log-open: User-level logging
log2-binary-factors: Integers as bits
logand: Basic bitwise operations
logand: CiSE syntax
logand=: CiSE syntax
logbit?: Basic bitwise operations
logcount: Basic bitwise operations
logior: Basic bitwise operations
logior: CiSE syntax
logior=: CiSE syntax
lognot: Basic bitwise operations
lognot: CiSE syntax
logset+clear: Basic bitwise operations
logtest: Basic bitwise operations
logxor: Basic bitwise operations
logxor: CiSE syntax
logxor=: CiSE syntax
loop: CiSE syntax
loop-procedure: Combinators (SRFI)
lrange: Lazy sequences
lrxmatch: Lazy sequence operations
lseq->generator: R7RS lazy sequences
lseq->list: Lazy sequence operations
lseq-any: R7RS lazy sequences
lseq-append: R7RS lazy sequences
lseq-car: R7RS lazy sequences
lseq-cdr: R7RS lazy sequences
lseq-drop: R7RS lazy sequences
lseq-drop-while: R7RS lazy sequences
lseq-every: R7RS lazy sequences
lseq-filter: R7RS lazy sequences
lseq-find: R7RS lazy sequences
lseq-find-tail: R7RS lazy sequences
lseq-first: R7RS lazy sequences
lseq-for-each: R7RS lazy sequences
lseq-index: R7RS lazy sequences
lseq-length: R7RS lazy sequences
lseq-map: R7RS lazy sequences
lseq-member: R7RS lazy sequences
lseq-memq: R7RS lazy sequences
lseq-memv: R7RS lazy sequences
lseq-position: Lazy sequence with positions
lseq-realize: R7RS lazy sequences
lseq-remove: R7RS lazy sequences
lseq-rest: R7RS lazy sequences
lseq-take: R7RS lazy sequences
lseq-take-while: R7RS lazy sequences
lseq-zip: R7RS lazy sequences
lseq=?: R7RS lazy sequences
lseq?: R7RS lazy sequences
lset-adjoin: R7RS lists
lset-diff+intersection: R7RS lists
lset-diff+intersection!: R7RS lists
lset-difference: R7RS lists
lset-difference!: R7RS lists
lset-intersection: R7RS lists
lset-intersection!: R7RS lists
lset-union: R7RS lists
lset-union!: R7RS lists
lset-xor: R7RS lists
lset-xor!: R7RS lists
lset<=: R7RS lists
lset=: R7RS lists
lslices: Lazy sequence operations
lstate-filter: Lazy sequence operations
ltake: Lazy sequence operations
ltake-while: Lazy sequence operations
lunfold: Lazy sequence constructors

M
machine-name: Portable runtime environment inquiry
macroexpand: Expanding macros manually
macroexpand-1: Expanding macros manually
macroexpand-all: Expanding macros manually
magnitude: Numerical conversions
make: Creating instance
make: Creating instance
make: Method instantiation
make-@vector-generator: Uvector basic operations
make-accumulator: R7RS generators
make-array: Arrays
make-ball-generator: Random data generators (SRFI)
make-barrier: Barrier
make-bernoulli-genreator: Random data generators (SRFI)
make-bimap: Generic dictionaries
make-binary-heap: Heap
make-binomial-generator: Random data generators (SRFI)
make-bitvector: Bitvectors
make-bitvector-accumulator: Bitvector utilities
make-bitvector/bool-generator: Bitvector utilities
make-bitvector/int-generator: Bitvector utilities
make-bitwise-generator: R7RS bitwise operations
make-blob: Octet-addressed binary blocks
make-byte-string: String constructors
make-bytestring: String-notated bytevectors
make-bytestring!: String-notated bytevectors
make-bytestring-generator: String-notated bytevectors
make-bytevector: Bytevector compatibility
make-bytevector-comparator: Comparators
make-c128vector: Uniform vectors
make-c32vector: Uniform vectors
make-c64vector: Uniform vectors
make-car-comparator: Comparators
make-categorical-generator: Random data generators (SRFI)
make-cdr-comparator: Comparators
make-client-socket: High-level network functions
make-client-socket: Basic socket interface
make-codec: Transcoded ports
make-comparator: Comparator class and constructors
make-comparator: Comparators
make-comparator/compare: Comparator class and constructors
make-comparison<: Comparators
make-comparison<=: Comparators
make-comparison=/<: Comparators
make-comparison=/>: Comparators
make-comparison>: Comparators
make-comparison>=: Comparators
make-compound: Compound objects
make-compound-condition: Conditions
make-concurrent-modification-violation: Thread exceptions
make-condition: Conditions
make-condition-type: Conditions
make-condition-variable: Condition variable
make-continuation-mark-key: Continuation marks
make-continuation-prompt-tag: Continuation prompts
make-continuation-violation: Conditions
make-coroutine-generator: Generator constructors
make-csv-header-parser: CSV tables
make-csv-reader: CSV tables
make-csv-record-parser: CSV tables
make-csv-writer: CSV tables
make-custom-binary-input-port: Creating custom ports
make-custom-binary-input/output-port: Creating custom ports
make-custom-binary-output-port: Creating custom ports
make-custom-textual-input-port: Creating custom ports
make-custom-textual-output-port: Creating custom ports
make-date: SRFI-19 Date
make-debug-comparator: Comparators
make-default-comparator: Combining comparators
make-default-console: Text terminal control
make-directory*: Directory utilities
make-directory-files-generator: POSIX API
make-edn-object: EDN parsing and construction
make-ellipsoid-generator: Random data generators (SRFI)
make-empty-attlist: SSAX data types
make-enum-comparator: Enums and enum sets
make-enum-type: Enums and enum sets
make-enumeration: Enums and enum sets
make-ephemeron: R7RS ephemerons
make-eq-comparator: Combining comparators
make-eqv-comparator: Combining comparators
make-exponential-generator: Random data generators (SRFI)
make-f16array: Arrays
make-f16vector: Uniform vectors
make-f32array: Arrays
make-f32vector: Uniform vectors
make-f64array: Arrays
make-f64vector: Uniform vectors
make-fifo-cache: Cache
make-fllog-base: R7RS flonum
make-flonum: R7RS flonum
make-for-each-generator: Generator constructors
make-fully-concurrent-mapper: Parallel map
make-future: Futures
make-gap-buffer: Gap buffer
make-gauche-package-description: Package metainformation
make-geometric-generator: Random data generators (SRFI)
make-gettext: Localized messages
make-glob-fs-fold: Directories
make-grapheme-cluster-breaker: Unicode text segmentation
make-grapheme-cluster-reader: Unicode text segmentation
make-hash-table: Hashtables
make-hash-table: R7RS hash tables
make-hash-table: R7RS hash tables
make-hash-table: Basic hash tables
make-hashmap-comparator: Hashmaps
make-hmac: HMAC keyed-hashing
make-hook: Hooks
make-i/o-invalid-position-error: Port positioning
make-icar-comparator: R7RS immutable lists
make-icdr-comparator: R7RS immutable lists
make-ideque: Immutable deques
make-ilist-comparator: R7RS immutable lists
make-imap: Immutable map
make-imap: Immutable map
make-imap: Immutable map
make-improper-ilist-comparator: R7RS immutable lists
make-improper-list-comparator: Comparators
make-inexact-real-comparator: Comparators
make-interval-protocol: Temporal relation
make-iota-generator: Generator constructors
make-ipair-comparator: R7RS immutable lists
make-key-comparator: Combining comparators
make-keyword: Keywords
make-kmp-restart-vector: SRFI-13 Low-level string procedures
make-latch: Latch
make-legacy-parameter: Parameters
make-list: List constructors
make-list-comparator: Comparators
make-list-queue: R7RS list queues
make-listwise-comparator: Comparators
make-lru-cache: Cache
make-mapping-comparator: Mappings
make-mersenne-twister: Mersenne-Twister random number generator
make-module: Module introspection
make-mtqueue: Queue
make-mutex: Mutex
make-normal-generator: Random data generators (SRFI)
make-option-parser: Parsing command-line options
make-overflow-doubler: Ring buffer
make-packer: Packing binary data
make-pair-comparator: Comparators
make-parameter: Parameters
make-pipe: Plumbing ports
make-plumbing: Plumbing ports
make-poisson-geneartor: Random data generators (SRFI)
make-polar: Numerical conversions
make-pool-mapper: Parallel map
make-priority-map: Priority map
make-process-connection: Process connection
make-product-comparator: Composing comparators
make-promise: Delay force and lazy
make-promise: R7RS lazy evaluation
make-pump: Plumbing ports
make-queue: Queue
make-random-boolean-generator: Random data generators (SRFI)
make-random-char-generator: Random data generators (SRFI)
make-random-integer-generator: Random data generators (SRFI)
make-random-polar-generator: Random data generators (SRFI)
make-random-real-generator: Random data generators (SRFI)
make-random-rectangular-generator: Random data generators (SRFI)
make-random-s16-generator: Random data generators (SRFI)
make-random-s32-generator: Random data generators (SRFI)
make-random-s64-generator: Random data generators (SRFI)
make-random-s8-generator: Random data generators (SRFI)
make-random-source: Sources of random bits
make-random-source-generator: Random data generators (SRFI)
make-random-string-generator: Random data generators (SRFI)
make-random-u1-generator: Random data generators (SRFI)
make-random-u16-generator: Random data generators (SRFI)
make-random-u32-generator: Random data generators (SRFI)
make-random-u64-generator: Random data generators (SRFI)
make-random-u8-generator: Random data generators (SRFI)
make-range-generator: Generator constructors
make-range-iset: Integer sets
make-rbtree: Obsolete and superseded modules
make-record-type: SLIB-compatible record type
make-rectangular: Numerical conversions
make-refining-comparator: Comparators
make-reverse-comparator: Combining comparators
make-reverse-comparator: Comparators
make-ring-buffer: Ring buffer
make-rtd: Record types procedural layer
make-s16array: Arrays
make-s16vector: Uniform vectors
make-s32array: Arrays
make-s32vector: Uniform vectors
make-s64array: Arrays
make-s64vector: Uniform vectors
make-s8array: Arrays
make-s8vector: Uniform vectors
make-s8vector: Uniform vectors
make-segmented-prefix-matcher: Segmented string matching
make-selecting-comparator: Comparators
make-semaphore: Semaphore
make-server-socket: High-level network functions
make-server-socket: Basic socket interface
make-server-sockets: High-level network functions
make-shared-parameter: Parameters
make-sockaddrs: Socket address
make-socket: Low-level socket interface
make-sparse-matrix: Sparse matrixes
make-sparse-table: Sparse tables
make-sparse-vector: Sparse vectors
make-sphere-generator: Random data generators (SRFI)
make-stacked-map: Generic dictionaries
make-stacked-map: Generic dictionaries
make-static-mapper: Parallel map
make-stream: Stream constructors
make-string: String constructors
make-sum-comparator: Composing comparators
make-template-environment: Simple template expander
make-text: R7RS immutable texts
make-text-progress-bar: Showing progress on text terminals
make-thread: Thread procedures
make-thread-abandoned-mutex: Thread exceptions
make-thread-condition: Thread exceptions
make-thread-local: Thread local storage
make-thread-parameter: Parameters
make-thread-pool: Thread pools
make-thread-timeout-condition: Thread exceptions
make-time: SRFI-19 Time procedures
make-time-result: Measure timings
make-timer: Timer APIs
make-timer-delta: Timer APIs
make-tls: Transport layer security
make-transcoder: Transcoded ports
make-tree-map: Treemaps
make-tree-map: Treemaps
make-trie: Trie
make-ttl-cache: Cache
make-ttlr-cache: Cache
make-tuple-comparator: Combining comparators
make-u16array: Arrays
make-u16vector: Uniform vectors
make-u32array: Arrays
make-u32vector: Uniform vectors
make-u64array: Arrays
make-u64vector: Uniform vectors
make-u8array: Arrays
make-u8vector: Uniform vectors
make-u8vector-generator: Uvector basic operations
make-ulid-generator: Universally unique lexicographically sortable identifier
make-unfold-generator: Generator constructors
make-uvector: Uvector basic operations
make-vector: Vectors
make-vector-comparator: Comparators
make-vectorwise-comparator: Comparators
make-view-uvector: Memory mapping
make-weak-vector: Weak vectors
make-word-breaker: Unicode text segmentation
make-word-reader: Unicode text segmentation
make-wrapper-comparator: Composing comparators
make-write-controls: Output controls
make-xml-token: SSAX data types
make-zipf-generator: Random data generators (SRFI)
make<=?: Comparators
make<?: Comparators
make=?: Comparators
make>=?: Comparators
make>?: Comparators
map: Walking over lists
map: Mapping over collection
map!: R7RS lists
map$: Combinators
map$: Mapping over collection
map*: Walking over lists
map-accum: Mapping over collection
map-in-order: R7RS lists
map-to: Mapping over collection
map-to-with-index: Mapping over sequences
map-union: SXPath basic converters and applicators
map-values: Procedures and syntax for multiple values
map-with-index: Mapping over sequences
mapping: Mappings
mapping->alist: Mappings
mapping-adjoin: Mappings
mapping-adjoin!: Mappings
mapping-any?: Mappings
mapping-catenate: Mappings
mapping-catenate!: Mappings
mapping-contains?: Mappings
mapping-copy: Mappings
mapping-count: Mappings
mapping-delete: Mappings
mapping-delete!: Mappings
mapping-delete-all: Mappings
mapping-delete-all!: Mappings
mapping-difference: Mappings
mapping-difference!: Mappings
mapping-disjoint?: Mappings
mapping-empty?: Mappings
mapping-entries: Mappings
mapping-every?: Mappings
mapping-filter: Mappings
mapping-filter!: Mappings
mapping-find: Mappings
mapping-fold: Mappings
mapping-fold/reverse: Mappings
mapping-for-each: Mappings
mapping-intern: Mappings
mapping-intern!: Mappings
mapping-intersection: Mappings
mapping-intersection!: Mappings
mapping-key-comparator: Mappings
mapping-key-predecessor: Mappings
mapping-key-successor: Mappings
mapping-keys: Mappings
mapping-map: Mappings
mapping-map->list: Mappings
mapping-map/monotone: Mappings
mapping-map/monotone!: Mappings
mapping-max-entry: Mappings
mapping-max-key: Mappings
mapping-max-value: Mappings
mapping-min-entry: Mappings
mapping-min-key: Mappings
mapping-min-value: Mappings
mapping-partition: Mappings
mapping-partition!: Mappings
mapping-pop: Mappings
mapping-pop!: Mappings
mapping-range<: Mappings
mapping-range<!: Mappings
mapping-range<=: Mappings
mapping-range<=!: Mappings
mapping-range=: Mappings
mapping-range=!: Mappings
mapping-range>: Mappings
mapping-range>!: Mappings
mapping-range>=: Mappings
mapping-range>=!: Mappings
mapping-ref: Mappings
mapping-ref/default: Mappings
mapping-remove: Mappings
mapping-remove!: Mappings
mapping-replace: Mappings
mapping-replace!: Mappings
mapping-search: Mappings
mapping-search!: Mappings
mapping-set: Mappings
mapping-set!: Mappings
mapping-size: Mappings
mapping-split: Mappings
mapping-split!: Mappings
mapping-unfold: Mappings
mapping-unfold/ordered: Mappings
mapping-union: Mappings
mapping-union!: Mappings
mapping-update: Mappings
mapping-update!: Mappings
mapping-update!/default: Mappings
mapping-update/default: Mappings
mapping-values: Mappings
mapping-xor: Mappings
mapping-xor!: Mappings
mapping/ordered: Mappings
mapping<=?: Mappings
mapping<?: Mappings
mapping=?: Mappings
mapping>=?: Mappings
mapping>?: Mappings
mapping?: Mappings
match: Pattern matching
match-define: Pattern matching
match-lambda: Pattern matching
match-lambda*: Pattern matching
match-let: Pattern matching
match-let: Pattern matching
match-let*: Pattern matching
match-let1: Pattern matching
match-letrec: Pattern matching
max: Numerical comparison
max-ec: Eager comprehensions
maybe->either: Maybe and Either constructors
maybe->generation: Maybe and Either protocol converters
maybe->list: Maybe and Either protocol converters
maybe->list-truth: Maybe and Either protocol converters
maybe->truth: Maybe and Either protocol converters
maybe->two-values: Maybe and Either protocol converters
maybe->values: Maybe and Either protocol converters
maybe-and: Maybe and Either syntactic utilities
maybe-bind: Maybe and Either accessors
maybe-compose: Maybe and Either accessors
maybe-escaped: R7RS combinator formatting
maybe-filter: Maybe and Either sequence operations
maybe-fold: Maybe and Either sequence operations
maybe-for-each: Maybe and Either sequence operations
maybe-if: Maybe and Either syntactic utilities
maybe-join: Maybe and Either accessors
maybe-length: Maybe and Either sequence operations
maybe-let*: Maybe and Either syntactic utilities
maybe-let*-values: Maybe and Either syntactic utilities
maybe-map: Maybe and Either sequence operations
maybe-or: Maybe and Either syntactic utilities
maybe-ref: Maybe and Either accessors
maybe-ref/default: Maybe and Either accessors
maybe-remove: Maybe and Either sequence operations
maybe-sequence: Maybe and Either sequence operations
maybe-unfold: Maybe and Either sequence operations
maybe=: Maybe and Either types and predicates
maybe?: Maybe and Either types and predicates
mc-factorize: Prime numbers
md5-digest: MD5 message digest
md5-digest-string: MD5 message digest
member: Other list procedures
member$: Combinators
memq: Other list procedures
memv: Other list procedures
merge: Sorting and merging
merge!: Sorting and merging
message-condition?: Conditions
message-type: Basic socket interface
method-more-specific?: Customizing method application
miller-rabin-prime?: Prime numbers
mime-body->file: MIME message handling
mime-body->string: MIME message handling
mime-compose-message: MIME message handling
mime-compose-message-string: MIME message handling
mime-compose-parameters: MIME message handling
mime-decode-text: MIME message handling
mime-decode-word: MIME message handling
mime-encode-text: MIME message handling
mime-encode-word: MIME message handling
mime-make-boundary: MIME message handling
mime-parse-content-disposition: MIME message handling
mime-parse-content-type: MIME message handling
mime-parse-message: MIME message handling
mime-parse-parameters: MIME message handling
mime-parse-version: MIME message handling
mime-retrieve-body: MIME message handling
min: Numerical comparison
min&max: Numerical comparison
min-ec: Eager comprehensions
mod: Arithmetics
mod0: Arithmetics
modf: Numerical conversions
modified-julian-day->date: SRFI-19 Date
modified-julian-day->time-monotonic: SRFI-19 Date
modified-julian-day->time-tai: SRFI-19 Date
modified-julian-day->time-utc: SRFI-19 Date
modifier: Fundamental sequence accessors
module-binding-ref: Module introspection
module-binds?: Module introspection
module-exports: Module introspection
module-exports?: Module introspection
module-imports: Module introspection
module-name: Module introspection
module-name->path: Module introspection
module-parents: Module introspection
module-precedence-list: Module introspection
module-reload-rules: Reloading modules
module-table: Module introspection
module?: Module introspection
modulo: Arithmetics
monotonic-time: POSIX API
move-cursor-to: Text terminal control
move-file: File operations
mt-random-fill-f32vector!: Mersenne-Twister random number generator
mt-random-fill-f64vector!: Mersenne-Twister random number generator
mt-random-fill-u32vector!: Mersenne-Twister random number generator
mt-random-get-seed: Mersenne-Twister random number generator
mt-random-get-state: Mersenne-Twister random number generator
mt-random-integer: Mersenne-Twister random number generator
mt-random-real: Mersenne-Twister random number generator
mt-random-real0: Mersenne-Twister random number generator
mt-random-set-seed!: Mersenne-Twister random number generator
mt-random-set-state!: Mersenne-Twister random number generator
mtqueue-max-length: Queue
mtqueue-num-waiting-readers: Queue
mtqueue-room: Queue
mtqueue?: Queue
mutex-lock!: Mutex
mutex-locker: Mutex
mutex-name: Mutex
mutex-specific: Mutex
mutex-specific-set!: Mutex
mutex-state: Mutex
mutex-unlock!: Mutex
mutex-unlocker: Mutex
mutex?: Mutex

N
naive-factorize: Prime numbers
nan?: Numerical predicates
native-endian: Endianness
native-endianness: R7RS bytevectors
native-eol-style: Transcoded ports
native-transcoder: Transcoded ports
ndbm-clear-error: NDBM interface
ndbm-close: NDBM interface
ndbm-closed?: NDBM interface
ndbm-delete: NDBM interface
ndbm-error: NDBM interface
ndbm-fetch: NDBM interface
ndbm-firstkey: NDBM interface
ndbm-nextkey: NDBM interface
ndbm-open: NDBM interface
ndbm-store: NDBM interface
negative-zero?: Numerical predicates
negative?: Numerical predicates
nest: Pipeline operators
nest-reverse: Pipeline operators
nested: Eager comprehensions
never: Combinators (SRFI)
newline: Object output
next-method: Generic function and method
next-method: Generic function and method
next-token: Parsing input stream
next-token-of: Parsing input stream
ngettext: Localized messages
nice: POSIX API
nil-uuid: UUID
ninth: R7RS lists
node-closure: SXPath basic converters and applicators
node-eq?: SXPath basic converters and applicators
node-equal?: SXPath basic converters and applicators
node-join: SXPath basic converters and applicators
node-or: SXPath basic converters and applicators
node-pos: SXPath basic converters and applicators
node-reduce: SXPath basic converters and applicators
node-reverse: SXPath basic converters and applicators
node-self: SXPath basic converters and applicators
node-trace: SXPath basic converters and applicators
nodeset?: SXPath basic converters and applicators
not: Booleans
not: CiSE syntax
not: Eager comprehensions
not-ipair?: R7RS immutable lists
not-pair?: R7RS lists
nothing: Maybe and Either constructors
nothing?: Maybe and Either types and predicates
ntype-names??: SXPath basic converters and applicators
ntype-namespace-id??: SXPath basic converters and applicators
ntype??: SXPath basic converters and applicators
null-device: Pathname utilities
null-environment: Eval and repl
null-generator: Generator constructors
null-ilist?: R7RS immutable lists
null-list?: List predicates
null?: List predicates
num-pairs: List accessors and modifiers
number->string: Numerical conversions
number-hash: Hashing
number?: Numerical predicates
numerator: Arithmetics
numeric: R7RS combinator formatting
numeric-range: Range
numeric/comma: R7RS combinator formatting
numeric/fitted: R7RS combinator formatting
numeric/si: R7RS combinator formatting

O
object-apply: Applicable objects
object-compare: Comparison
object-compare: Comparison
object-equal?: Equality
object-equal?: Equality
object-equal?: Comparator predicates and accessors
object-hash: Hashing
object-hash: Hashing
object-hash: Hashing
object-isomorphic?: Determine isomorphism
odbm-close: Original DBM interface
odbm-delete: Original DBM interface
odbm-fetch: Original DBM interface
odbm-firstkey: Original DBM interface
odbm-init: Original DBM interface
odbm-nextkey: Original DBM interface
odbm-store: Original DBM interface
odd?: Numerical predicates
of-type?: Generic type predicates
on: Combinators (SRFI)
on-left: Combinators (SRFI)
on-right: Combinators (SRFI)
open-binary-input-file: R7RS file library
open-binary-output-file: R7RS file library
open-broadcast-output-port: Plumbing ports
open-coding-aware-port: Coding-aware ports
open-deflating-port: Zlib compression library
open-directory: POSIX API
open-file: POSIX API
open-inflating-port: Zlib compression library
open-info-document: Accessing info document
open-inlet-output-port: Plumbing ports
open-input-byte-generator: Virtual ports
open-input-byte-list: Virtual ports
open-input-bytevector: Virtual ports
open-input-char-generator: Virtual ports
open-input-char-list: Virtual ports
open-input-conversion-port: Conversion ports
open-input-fd-port: File descriptor ports
open-input-file: Opening file ports
open-input-process-port: Process ports
open-input-string: String ports
open-input-uvector: Virtual ports
open-outlet-input-port: Plumbing ports
open-output-accumulator: Virtual ports
open-output-bytevector: Virtual ports
open-output-char-accumulator: Virtual ports
open-output-char-accumulator: Virtual ports
open-output-conversion-port: Conversion ports
open-output-fd-port: File descriptor ports
open-output-file: Opening file ports
open-output-process-port: Process ports
open-output-string: String ports
open-output-uvector: Virtual ports
open-tapping-input-port: Plumbing ports
opt*-lambda: Optional arguments
opt-labmda: Optional arguments
opt-substring: String utilities
option: A program argument processor
option-names: A program argument processor
option-optional-arg?: A program argument processor
option-processor: A program argument processor
option-required-arg?: A program argument processor
option?: A program argument processor
or: Conditionals
or: CiSE syntax
or: Eager comprehensions
or-procedure: Combinators (SRFI)
os-name: Portable runtime environment inquiry
os-version: Portable runtime environment inquiry
output-port-open?: R7RS base library
output-port?: Common port operations

P
pa$: Combinators
pack: Packing binary data
padded: R7RS combinator formatting
padded/both: R7RS combinator formatting
padded/right: R7RS combinator formatting
pager-program: Display with pager
pair-attribute-get: Extended pairs and pair attributes
pair-attribute-set!: Extended pairs and pair attributes
pair-attributes: Extended pairs and pair attributes
pair-fold: R7RS lists
pair-fold-right: R7RS lists
pair-for-each: CiSE syntax
pair-for-each: R7RS lists
pair?: List predicates
pairs-of: Random data generators
pany: Parallel map
parallel-execute: SICP prerequisites
parameter-observer-add!: Parameters (legacy)
parameter-observer-delete!: Parameters (legacy)
parameter-post-observers: Parameters (legacy)
parameter-pre-observers: Parameters (legacy)
parameter?: Parameters
parameterization?: Parameters
parameterize: Parameters
parameterize/dynwind: Parameters
parse-cookie-string: HTTP cookie handling
parse-css: CSS parsing and construction
parse-css-file: CSS parsing and construction
parse-css-selector-string: CSS parsing and construction
parse-edn: EDN parsing and construction
parse-edn*: EDN parsing and construction
parse-edn-string: EDN parsing and construction
parse-json: JSON parsing and construction
parse-json*: JSON parsing and construction
parse-json-string: JSON parsing and construction
parse-options: Parsing command-line options
parse-success?: What is a PEG parser
parse-uuid: UUID
partition: Selection and searching in collection
partition: R7RS lists
partition!: R7RS lists
partition$: Combinators
partition-to: Selection and searching in collection
path->gauche-package-description: Package metainformation
path->module-name: Module introspection
path-extension: Pathname utilities
path-sans-extension: Pathname utilities
path-swap-extension: Pathname utilities
peek-byte: Reading data
peek-char: Reading data
peek-next-char: Parsing input stream
peek-u8: Reading data
peg-parse-port: PEG parser drivers
peg-parse-string: PEG parser drivers
peg-parser->generator: PEG parser drivers
peg-run-parser: PEG parser drivers
permutations: Combination library
permutations*: Combination library
permutations*-for-each: Combination library
permutations-for-each: Combination library
permutations-of: Random data generators
permute: Other operations over sequences
permute!: Other operations over sequences
permute-to: Other operations over sequences
pfind: Parallel map
pid: POSIX API
plumbing: Plumbing ports
plumbing-get-port: Plumbing ports
plumbing-inlet-ports: Plumbing ports
plumbing-outlet-ports: Plumbing ports
plumbing?: Plumbing ports
pmap: Parallel map
pop!: Assignments
port->byte-generator: Generator constructors
port->byte-lseq: Lazy sequences
port->char-generator: Generator constructors
port->char-lseq: Lazy sequences
port->char-lseq/position: Lazy sequence with positions
port->line-generator: Generator constructors
port->list: Input utility functions
port->sexp-generator: Generator constructors
port->sexp-list: Input utility functions
port->sexp-lseq: Lazy sequences
port->stream: Stream constructors
port->string: Input utility functions
port->string-list: Input utility functions
port->string-lseq: Lazy sequences
port->uvector: Uvector block I/O
port-buffering: Common port operations
port-closed?: Common port operations
port-current-line: Common port operations
port-fd-dup!: File descriptor ports
port-file-number: Common port operations
port-fold: Input utility functions
port-fold-right: Input utility functions
port-for-each: Input utility functions
port-has-port-position?: Common port operations
port-has-set-port-position!?: Common port operations
port-link!: Common port operations
port-map: Input utility functions
port-name: Common port operations
port-plumbing: Plumbing ports
port-position: Common port operations
port-seek: Common port operations
port-tell: Common port operations
port-type: Common port operations
port-unlink!: Common port operations
port?: Common port operations
portable-hash: Hashing
positive?: Numerical predicates
posix-error-message: POSIX API
posix-error-name: POSIX API
posix-error?: POSIX API
posix-time: POSIX API
post++: CiSE syntax
post--: CiSE syntax
power-set: Combination library
power-set*: Combination library
power-set*-for-each: Combination library
power-set-binary: Combination library
power-set-for-each: Combination library
pprint: Object output
pre++: CiSE syntax
pre--: CiSE syntax
pretty: R7RS combinator formatting
pretty-simply: R7RS combinator formatting
primes: Prime numbers
print: Object output
priority-map-max: Priority map
priority-map-max-all: Priority map
priority-map-min: Priority map
priority-map-min-all: Priority map
priority-map-pop-max!: Priority map
priority-map-pop-min!: Priority map
procedure-arity-includes?: Procedure arity
procedure-tag: Tagged procedures
procedure-type: Procedure class and applicability
procedure/tag?: Tagged procedures
procedure?: Procedure class and applicability
process-alive?: Process object
process-command: Process object
process-continue: Process object
process-error: Process object
process-exit-status: Process object
process-input: Process object
process-kill: Process object
process-list: Process object
process-output: Process object
process-output->string: Process ports
process-output->string-list: Process ports
process-pid: Process object
process-send-signal: Process object
process-shutdown: Process object
process-stop: Process object
process-upstreams: Process object
process-wait: Process object
process-wait-any: Process object
process-wait/poll: Process object
process?: Process object
product-accumulator: R7RS generators
product-ec: Eager comprehensions
profiler-reset: Profiler API
profiler-show: Profiler API
profiler-start: Profiler API
profiler-stop: Profiler API
program: Feature-based program configuration language
promise?: Delay force and lazy
proper-ilist?: R7RS immutable lists
proper-list?: List predicates
provide: Require and provide
provided?: Require and provide
pseudo-rtd: Pseudo record types
push!: Assignments
push-unique!: Assignments
put-f16!: Binary I/O
put-f16be!: Binary I/O
put-f16le!: Binary I/O
put-f32!: Binary I/O
put-f32be!: Binary I/O
put-f32le!: Binary I/O
put-f64!: Binary I/O
put-f64be!: Binary I/O
put-f64le!: Binary I/O
put-s16!: Binary I/O
put-s16be!: Binary I/O
put-s16le!: Binary I/O
put-s32!: Binary I/O
put-s32be!: Binary I/O
put-s32le!: Binary I/O
put-s64!: Binary I/O
put-s64be!: Binary I/O
put-s64le!: Binary I/O
put-s8!: Binary I/O
put-sint!: Binary I/O
put-u16!: Binary I/O
put-u16be!: Binary I/O
put-u16le!: Binary I/O
put-u32!: Binary I/O
put-u32be!: Binary I/O
put-u32le!: Binary I/O
put-u64!: Binary I/O
put-u64be!: Binary I/O
put-u64le!: Binary I/O
put-u8!: Binary I/O
put-uint!: Binary I/O
putch: Text terminal control
putstr: Text terminal control

Q
quasiquote: Quasiquotation
quasirename: Explicit-renaming macro transformer
query-cursor-position: Text terminal control
query-screen-size: Text terminal control
queue->list: Queue
queue-empty?: Queue
queue-front: Queue
queue-internal-list: Queue
queue-length: Queue
queue-pop!: Queue
queue-pop/wait!: Queue
queue-push!: Queue
queue-push-unique!: Queue
queue-push/wait!: Queue
queue-rear: Queue
queue?: Queue
quote: Literals
quoted-printable-decode: Quoted-printable encoding/decoding
quoted-printable-decode-string: Quoted-printable encoding/decoding
quoted-printable-decode-string-to: Quoted-printable encoding/decoding
quoted-printable-encode: Quoted-printable encoding/decoding
quoted-printable-encode-message: Quoted-printable encoding/decoding
quoted-printable-encode-string: Quoted-printable encoding/decoding
quotient: Arithmetics
quotient&remainder: Arithmetics

R
radians->degrees: Arithmetics
raise: Signaling exceptions
raise: R7RS base library
raise-continuable: R7RS base library
random: SICP prerequisites
random-access-list->linear-access-list: R7RS random-access lists
random-integer: Sources of random bits
random-real: Sources of random bits
random-source-make-integers: Sources of random bits
random-source-make-reals: Sources of random bits
random-source-pseudo-randomize!: Sources of random bits
random-source-randomize!: Sources of random bits
random-source-state-ref: Sources of random bits
random-source-state-set!: Sources of random bits
random-source?: Sources of random bits
range: Range
range->generator: Range
range->list: Range
range->string: Range
range->vector: Range
range-any: Range
range-append: Range
range-count: Range
range-drop: Range
range-drop-range: Range
range-drop-while: Range
range-drop-while-right: Range
range-every: Range
range-filter: Range
range-filter->list: Range
range-filter-map: Range
range-filter-map->list: Range
range-first: Range
range-fold: Range
range-fold-right: Range
range-for-each: Range
range-index: Range
range-index-right: Range
range-last: Range
range-length: Range
range-map: Range
range-map->list: Range
range-map->vector: Range
range-ref: Range
range-remove: Range
range-remove->list: Range
range-reverse: Range
range-segment: Range
range-split-at: Range
range-take: Range
range-take-right: Range
range-take-while: Range
range-take-while-right: Range
range=?: Range
range?: Range
rassoc: Association lists
rassoc-ref: Association lists
rassq: Association lists
rassq-ref: Association lists
rassv: Association lists
rassv-ref: Association lists
rational-valued?: Numerical predicates
rational?: Numerical predicates
rationalize: Arithmetics
ratnum?: Numerical predicates
rbtree->alist: Obsolete and superseded modules
rbtree-copy: Obsolete and superseded modules
rbtree-delete!: Obsolete and superseded modules
rbtree-empty?: Obsolete and superseded modules
rbtree-exists?: Obsolete and superseded modules
rbtree-extract-max!: Obsolete and superseded modules
rbtree-extract-min!: Obsolete and superseded modules
rbtree-fold: Obsolete and superseded modules
rbtree-fold-right: Obsolete and superseded modules
rbtree-get: Obsolete and superseded modules
rbtree-keys: Obsolete and superseded modules
rbtree-max: Obsolete and superseded modules
rbtree-min: Obsolete and superseded modules
rbtree-num-entries: Obsolete and superseded modules
rbtree-pop!: Obsolete and superseded modules
rbtree-push!: Obsolete and superseded modules
rbtree-put!: Obsolete and superseded modules
rbtree-update!: Obsolete and superseded modules
rbtree-values: Obsolete and superseded modules
rbtree?: Obsolete and superseded modules
re-distance: Levenshtein edit distance
re-distances: Levenshtein edit distance
read: Reading data
read-ber-integer: Binary I/O
read-block: Reading data
read-block!: Uvector block I/O
read-byte: Reading data
read-bytevector: Uvector block I/O
read-bytevector!: Uvector block I/O
read-char: Reading data
read-directory: POSIX API
read-error?: R7RS base library
read-eval-print-loop: Eval and repl
read-f16: Binary I/O
read-f32: Binary I/O
read-f64: Binary I/O
read-from-string: String ports
read-line: Reading data
read-s16: Binary I/O
read-s32: Binary I/O
read-s64: Binary I/O
read-s8: Binary I/O
read-sint: Binary I/O
read-string: Reading data
read-string: Parsing input stream
read-symlink: POSIX API
read-textual-bytestring: String-notated bytevectors
read-u16: Binary I/O
read-u32: Binary I/O
read-u64: Binary I/O
read-u8: Reading data
read-u8: Binary I/O
read-uint: Binary I/O
read-uvector: Uvector block I/O
read-uvector!: Uvector block I/O
read-with-shared-structure: Reading data
read/ss: Reading data
reader-lexical-mode: Reader lexical mode
real->rational: Numerical conversions
real-acos: Arithmetics
real-acosh: Arithmetics
real-asin: Arithmetics
real-asinh: Arithmetics
real-atan: Arithmetics
real-atan: Arithmetics
real-atanh: Arithmetics
real-cos: Arithmetics
real-cosh: Arithmetics
real-cospi: Arithmetics
real-exp: Arithmetics
real-expt: Arithmetics
real-ln: Arithmetics
real-part: Numerical conversions
real-path: POSIX API
real-sin: Arithmetics
real-sinh: Arithmetics
real-sinpi: Arithmetics
real-sqrt: Arithmetics
real-tan: Arithmetics
real-tanh: Arithmetics
real-tanpi: Arithmetics
real-valued?: Numerical predicates
real?: Numerical predicates
reals$: Random data generators
reals-between$: Random data generators
reals-exponential$: Random data generators
reals-normal$: Random data generators
rec: Binding constructs
rec: Binding constructs
receive: Binding constructs
record-accessor: SLIB-compatible record type
record-constructor: SLIB-compatible record type
record-modifier: SLIB-compatible record type
record-predicate: SLIB-compatible record type
record-rtd: Record types inspection layer
record?: Record types inspection layer
reduce: Walking over lists
reduce$: Combinators
reduce-right: Walking over lists
reduce-right$: Combinators
ref: Hashtables
ref: Universal accessor
ref: Accessing instance
ref: CiSE syntax
ref: Fundamental sequence accessors
reference-barrier: R7RS ephemerons
referencer: Fundamental sequence accessors
regexp: Using regular expressions
regexp: R7RS regular expressions
regexp->sre: Using regular expressions
regexp->sre: R7RS regular expressions
regexp->string: Using regular expressions
regexp-ast: Inspecting and assembling regular expressions
regexp-compile: Inspecting and assembling regular expressions
regexp-extract: R7RS regular expressions
regexp-fold: R7RS regular expressions
regexp-match->list: R7RS regular expressions
regexp-match-count: R7RS regular expressions
regexp-match-submatch: R7RS regular expressions
regexp-match-submatch-end: R7RS regular expressions
regexp-match-submatch-start: R7RS regular expressions
regexp-match?: R7RS regular expressions
regexp-matches: R7RS regular expressions
regexp-matches?: R7RS regular expressions
regexp-named-groups: Using regular expressions
regexp-num-groups: Using regular expressions
regexp-optimize: Inspecting and assembling regular expressions
regexp-parse: Inspecting and assembling regular expressions
regexp-parse-sre: Inspecting and assembling regular expressions
regexp-partition: R7RS regular expressions
regexp-quote: Using regular expressions
regexp-replace: Using regular expressions
regexp-replace: R7RS regular expressions
regexp-replace*: Using regular expressions
regexp-replace-all: Using regular expressions
regexp-replace-all: R7RS regular expressions
regexp-replace-all*: Using regular expressions
regexp-search: R7RS regular expressions
regexp-split: R7RS regular expressions
regexp-unparse: Inspecting and assembling regular expressions
regexp?: Using regular expressions
regexp?: R7RS regular expressions
register-edn-object-handler!: EDN parsing and construction
regmatch: Using regular expressions
regmatch: Using regular expressions
regmatch: Using regular expressions
regular-string$: Random data generators
relate: Temporal relation
relate-point: Temporal relation
relation-accessor: Relation framework
relation-coercer: Relation framework
relation-column-getter: Relation framework
relation-column-getters: Relation framework
relation-column-name?: Relation framework
relation-column-names: Relation framework
relation-column-setter: Relation framework
relation-column-setters: Relation framework
relation-deletable?: Relation framework
relation-delete!: Relation framework
relation-fold: Relation framework
relation-insert!: Relation framework
relation-insertable?: Relation framework
relation-modifier: Relation framework
relation-ref: Relation framework
relation-rows: Relation framework
relation-set!: Relation framework
relation?: Temporal relation
relative-path?: Pathname utilities
relnum-compare: Comparing version numbers
reload: Reloading modules
reload-modified-modules: Reloading modules
reload-verbose: Reloading modules
remainder: Arithmetics
remove: Walking over lists
remove: Selection and searching in collection
remove!: Walking over lists
remove$: Combinators
remove-directory*: Directory utilities
remove-file: File operations
remove-files: File operations
remove-from-queue!: Queue
remove-hook!: Hooks
remove-to: Selection and searching in collection
rename-file: POSIX API
report-error: Behavior of unhandled exception
report-time-results: Measure timings
require: Require and provide
require-extension: Requiring extensions
requires: Feature-based program configuration language
reset: Partial continuations
reset-character-attribute: Text terminal control
reset-hook!: Hooks
reset-primes: Prime numbers
reset-terminal: Text terminal control
resolve-path: Pathname utilities
return: CiSE syntax
return-failure: What is a PEG parser
return-failure/compound: What is a PEG parser
return-failure/expect: What is a PEG parser
return-failure/message: What is a PEG parser
return-failure/unexpect: What is a PEG parser
return-result: What is a PEG parser
reverse: Other list procedures
reverse!: Other list procedures
reverse-bit-field: Integers as bits
reverse-bits->generator: Generator constructors
reverse-bitvector->list/bool: Bitvector utilities
reverse-bitvector->list/int: Bitvector utilities
reverse-bitvector->vector/bool: Bitvector utilities
reverse-list->@vector: Uvector conversion operations
reverse-list->bitvector: Bitvector utilities
reverse-list->c128vector: Uvector conversion operations
reverse-list->c32vector: Uvector conversion operations
reverse-list->c64vector: Uvector conversion operations
reverse-list->f16vector: Uvector conversion operations
reverse-list->f32vector: Uvector conversion operations
reverse-list->f64vector: Uvector conversion operations
reverse-list->s16vector: Uvector conversion operations
reverse-list->s32vector: Uvector conversion operations
reverse-list->s64vector: Uvector conversion operations
reverse-list->s8vector: Uvector conversion operations
reverse-list->string: SRFI-13 String constructors
reverse-list->text: R7RS immutable texts
reverse-list->u16vector: Uvector conversion operations
reverse-list->u32vector: Uvector conversion operations
reverse-list->u64vector: Uvector conversion operations
reverse-list->u8vector: Uvector conversion operations
reverse-list->vector: Vectors
reverse-list-accumulator: R7RS generators
reverse-vector->bitvector: Bitvector utilities
reverse-vector->generator: Generator constructors
reverse-vector->list: R7RS vectors
reverse-vector-accumulator: R7RS generators
revrese-bitvector->vector/int: Bitvector utilities
rfc822-atom: RFC822 message parsing
rfc822-date->date: RFC822 message parsing
rfc822-dot-atom: RFC822 message parsing
rfc822-field->tokens: RFC822 message parsing
rfc822-header->list: RFC822 message parsing
rfc822-header-ref: RFC822 message parsing
rfc822-next-token: RFC822 message parsing
rfc822-parse-date: RFC822 message parsing
rfc822-quoted-string: RFC822 message parsing
rfc822-read-headers: RFC822 message parsing
rfc822-skip-cfws: RFC822 message parsing
rfc822-write-headers: RFC822 message parsing
right: Maybe and Either constructors
right-section: Combinators (SRFI)
right?: Maybe and Either types and predicates
ring-buffer->flat-vector: Ring buffer
ring-buffer-add-back!: Ring buffer
ring-buffer-add-front!: Ring buffer
ring-buffer-back: Ring buffer
ring-buffer-capacity: Ring buffer
ring-buffer-empty?: Ring buffer
ring-buffer-front: Ring buffer
ring-buffer-full?: Ring buffer
ring-buffer-num-entries: Ring buffer
ring-buffer-ref: Ring buffer
ring-buffer-remove-back!: Ring buffer
ring-buffer-remove-front!: Ring buffer
ring-buffer-set!: Ring buffer
rlet1: Binding constructs
rope->string: PEG ropes
rope-finalize: PEG ropes
rotate!: Assignments
rotate-bit-field: Integers as bits
round: Arithmetics
round->exact: Arithmetics
round-quotient: R7RS integer division
round-remainder: R7RS integer division
round/: R7RS integer division
rtd-accessor: Record types procedural layer
rtd-all-field-names: Record types inspection layer
rtd-constructor: Record types procedural layer
rtd-field-mutable?: Record types inspection layer
rtd-field-names: Record types inspection layer
rtd-mutator: Record types procedural layer
rtd-name: Record types inspection layer
rtd-parent: Record types inspection layer
rtd-predicate: Record types procedural layer
rtd?: Record types procedural layer
run-cgi-script->header&body: CGI testing
run-cgi-script->string: CGI testing
run-cgi-script->string-list: CGI testing
run-cgi-script->sxml: CGI testing
run-hook: Hooks
run-once: Mutex
run-pipeline: Running process pipeline
run-process: Running subprocess
runtime: SICP prerequisites
rx: R7RS regular expressions
rxmatch: Using regular expressions
rxmatch->string: Using regular expressions
rxmatch-after: Using regular expressions
rxmatch-before: Using regular expressions
rxmatch-case: Using regular expressions
rxmatch-cond: Using regular expressions
rxmatch-end: Using regular expressions
rxmatch-if: Using regular expressions
rxmatch-let: Using regular expressions
rxmatch-named-groups: Using regular expressions
rxmatch-num-matches: Using regular expressions
rxmatch-positions: Using regular expressions
rxmatch-start: Using regular expressions
rxmatch-substring: Using regular expressions
rxmatch-substrings: Using regular expressions

S
s16?: Uvector basic operations
s16array: Arrays
s16ite-u8vector: Uvector block I/O
s16ke-u8vector-generator: Uvector basic operations
s16vector: Uvector basic operations
s16vector->list: Uvector conversion operations
s16vector->vector: Uvector conversion operations
s16vector-add: Uvector numeric operations
s16vector-add!: Uvector numeric operations
s16vector-and: Uvector numeric operations
s16vector-and!: Uvector numeric operations
s16vector-any: Uvector basic operations
s16vector-append: Uvector basic operations
s16vector-append-subvectors: Uvector basic operations
s16vector-clamp: Uvector numeric operations
s16vector-clamp!: Uvector numeric operations
s16vector-compare: Uvector basic operations
s16vector-concatenate: Uvector basic operations
s16vector-copy: Uvector basic operations
s16vector-copy!: Uvector basic operations
s16vector-count: Uvector basic operations
s16vector-cumulate: Uvector basic operations
s16vector-dot: Uvector numeric operations
s16vector-drop: Uvector basic operations
s16vector-drop-right: Uvector basic operations
s16vector-drop-while: Uvector basic operations
s16vector-drop-while-right: Uvector basic operations
s16vector-empty?: Uvector basic operations
s16vector-every: Uvector basic operations
s16vector-fill!: Uvector basic operations
s16vector-filter: Uvector basic operations
s16vector-fold: Uvector basic operations
s16vector-for-each: Uvector basic operations
s16vector-index: Uvector basic operations
s16vector-index-right: Uvector basic operations
s16vector-ior: Uvector numeric operations
s16vector-ior!: Uvector numeric operations
s16vector-length: Uvector basic operations
s16vector-map: Uvector basic operations
s16vector-map!: Uvector basic operations
s16vector-mul: Uvector numeric operations
s16vector-mul!: Uvector numeric operations
s16vector-multi-copy!: Uvector basic operations
s16vector-partition: Uvector basic operations
s16vector-range-check: Uvector numeric operations
s16vector-ref: Uniform vectors
s16vector-remove: Uvector basic operations
s16vector-reverse!: Uvector basic operations
s16vector-reverse-copy: Uvector basic operations
s16vector-reverse-copy!: Uvector basic operations
s16vector-segment: Uvector basic operations
s16vector-set!: Uniform vectors
s16vector-skip: Uvector basic operations
s16vector-skip-right: Uvector basic operations
s16vector-sub: Uvector numeric operations
s16vector-sub!: Uvector numeric operations
s16vector-swap!: Uvector basic operations
s16vector-take: Uvector basic operations
s16vector-take-right: Uvector basic operations
s16vector-take-while: Uvector basic operations
s16vector-take-while-right: Uvector basic operations
s16vector-unfod-right!: Uvector basic operations
s16vector-unfold: Uvector basic operations
s16vector-unfold: Uvector basic operations
s16vector-unfold!: Uvector basic operations
s16vector-unfold!: Uvector basic operations
s16vector-unfold-right: Uvector basic operations
s16vector-unfold-right!: Uvector basic operations
s16vector-xor: Uvector numeric operations
s16vector-xor!: Uvector numeric operations
s16vector=: Uvector basic operations
s16vector=?: Uvector basic operations
s16vector?: Uniform vectors
s32?: Uvector basic operations
s32array: Arrays
s32ite-u8vector: Uvector block I/O
s32ke-u8vector-generator: Uvector basic operations
s32vector: Uvector basic operations
s32vector->list: Uvector conversion operations
s32vector->string: Uniform vectors
s32vector->vector: Uvector conversion operations
s32vector-add: Uvector numeric operations
s32vector-add!: Uvector numeric operations
s32vector-and: Uvector numeric operations
s32vector-and!: Uvector numeric operations
s32vector-any: Uvector basic operations
s32vector-append: Uvector basic operations
s32vector-append-subvectors: Uvector basic operations
s32vector-clamp: Uvector numeric operations
s32vector-clamp!: Uvector numeric operations
s32vector-compare: Uvector basic operations
s32vector-concatenate: Uvector basic operations
s32vector-copy: Uvector basic operations
s32vector-copy!: Uvector basic operations
s32vector-count: Uvector basic operations
s32vector-cumulate: Uvector basic operations
s32vector-dot: Uvector numeric operations
s32vector-drop: Uvector basic operations
s32vector-drop-right: Uvector basic operations
s32vector-drop-while: Uvector basic operations
s32vector-drop-while-right: Uvector basic operations
s32vector-empty?: Uvector basic operations
s32vector-every: Uvector basic operations
s32vector-fill!: Uvector basic operations
s32vector-filter: Uvector basic operations
s32vector-fold: Uvector basic operations
s32vector-for-each: Uvector basic operations
s32vector-index: Uvector basic operations
s32vector-index-right: Uvector basic operations
s32vector-ior: Uvector numeric operations
s32vector-ior!: Uvector numeric operations
s32vector-length: Uvector basic operations
s32vector-map: Uvector basic operations
s32vector-map!: Uvector basic operations
s32vector-mul: Uvector numeric operations
s32vector-mul!: Uvector numeric operations
s32vector-multi-copy!: Uvector basic operations
s32vector-partition: Uvector basic operations
s32vector-range-check: Uvector numeric operations
s32vector-ref: Uniform vectors
s32vector-remove: Uvector basic operations
s32vector-reverse!: Uvector basic operations
s32vector-reverse-copy: Uvector basic operations
s32vector-reverse-copy!: Uvector basic operations
s32vector-segment: Uvector basic operations
s32vector-set!: Uniform vectors
s32vector-skip: Uvector basic operations
s32vector-skip-right: Uvector basic operations
s32vector-sub: Uvector numeric operations
s32vector-sub!: Uvector numeric operations
s32vector-swap!: Uvector basic operations
s32vector-take: Uvector basic operations
s32vector-take-right: Uvector basic operations
s32vector-take-while: Uvector basic operations
s32vector-take-while-right: Uvector basic operations
s32vector-unfod-right!: Uvector basic operations
s32vector-unfold: Uvector basic operations
s32vector-unfold: Uvector basic operations
s32vector-unfold!: Uvector basic operations
s32vector-unfold!: Uvector basic operations
s32vector-unfold-right: Uvector basic operations
s32vector-unfold-right!: Uvector basic operations
s32vector-xor: Uvector numeric operations
s32vector-xor!: Uvector numeric operations
s32vector=: Uvector basic operations
s32vector=?: Uvector basic operations
s32vector?: Uniform vectors
s64?: Uvector basic operations
s64array: Arrays
s64ite-u8vector: Uvector block I/O
s64ke-u8vector-generator: Uvector basic operations
s64vector: Uvector basic operations
s64vector->list: Uvector conversion operations
s64vector->vector: Uvector conversion operations
s64vector-add: Uvector numeric operations
s64vector-add!: Uvector numeric operations
s64vector-and: Uvector numeric operations
s64vector-and!: Uvector numeric operations
s64vector-any: Uvector basic operations
s64vector-append: Uvector basic operations
s64vector-append-subvectors: Uvector basic operations
s64vector-clamp: Uvector numeric operations
s64vector-clamp!: Uvector numeric operations
s64vector-compare: Uvector basic operations
s64vector-concatenate: Uvector basic operations
s64vector-copy: Uvector basic operations
s64vector-copy!: Uvector basic operations
s64vector-count: Uvector basic operations
s64vector-cumulate: Uvector basic operations
s64vector-dot: Uvector numeric operations
s64vector-drop: Uvector basic operations
s64vector-drop-right: Uvector basic operations
s64vector-drop-while: Uvector basic operations
s64vector-drop-while-right: Uvector basic operations
s64vector-empty?: Uvector basic operations
s64vector-every: Uvector basic operations
s64vector-fill!: Uvector basic operations
s64vector-filter: Uvector basic operations
s64vector-fold: Uvector basic operations
s64vector-for-each: Uvector basic operations
s64vector-index: Uvector basic operations
s64vector-index-right: Uvector basic operations
s64vector-ior: Uvector numeric operations
s64vector-ior!: Uvector numeric operations
s64vector-length: Uvector basic operations
s64vector-map: Uvector basic operations
s64vector-map!: Uvector basic operations
s64vector-mul: Uvector numeric operations
s64vector-mul!: Uvector numeric operations
s64vector-multi-copy!: Uvector basic operations
s64vector-partition: Uvector basic operations
s64vector-range-check: Uvector numeric operations
s64vector-ref: Uniform vectors
s64vector-remove: Uvector basic operations
s64vector-reverse!: Uvector basic operations
s64vector-reverse-copy: Uvector basic operations
s64vector-reverse-copy!: Uvector basic operations
s64vector-segment: Uvector basic operations
s64vector-set!: Uniform vectors
s64vector-skip: Uvector basic operations
s64vector-skip-right: Uvector basic operations
s64vector-sub: Uvector numeric operations
s64vector-sub!: Uvector numeric operations
s64vector-swap!: Uvector basic operations
s64vector-take: Uvector basic operations
s64vector-take-right: Uvector basic operations
s64vector-take-while: Uvector basic operations
s64vector-take-while-right: Uvector basic operations
s64vector-unfod-right!: Uvector basic operations
s64vector-unfold: Uvector basic operations
s64vector-unfold: Uvector basic operations
s64vector-unfold!: Uvector basic operations
s64vector-unfold!: Uvector basic operations
s64vector-unfold-right: Uvector basic operations
s64vector-unfold-right!: Uvector basic operations
s64vector-xor: Uvector numeric operations
s64vector-xor!: Uvector numeric operations
s64vector=: Uvector basic operations
s64vector=?: Uvector basic operations
s64vector?: Uniform vectors
s8?: Uvector basic operations
s8array: Arrays
s8ite-u8vector: Uvector block I/O
s8ke-u8vector-generator: Uvector basic operations
s8vector: Uvector basic operations
s8vector->list: Uvector conversion operations
s8vector->string: Uniform vectors
s8vector->vector: Uvector conversion operations
s8vector-add: Uvector numeric operations
s8vector-add!: Uvector numeric operations
s8vector-and: Uvector numeric operations
s8vector-and!: Uvector numeric operations
s8vector-any: Uvector basic operations
s8vector-append: Uvector basic operations
s8vector-append-subvectors: Uvector basic operations
s8vector-clamp: Uvector numeric operations
s8vector-clamp!: Uvector numeric operations
s8vector-compare: Uvector basic operations
s8vector-concatenate: Uvector basic operations
s8vector-copy: Uvector basic operations
s8vector-copy!: Uvector basic operations
s8vector-count: Uvector basic operations
s8vector-cumulate: Uvector basic operations
s8vector-dot: Uvector numeric operations
s8vector-drop: Uvector basic operations
s8vector-drop-right: Uvector basic operations
s8vector-drop-while: Uvector basic operations
s8vector-drop-while-right: Uvector basic operations
s8vector-empty?: Uvector basic operations
s8vector-every: Uvector basic operations
s8vector-fill!: Uvector basic operations
s8vector-filter: Uvector basic operations
s8vector-fold: Uvector basic operations
s8vector-for-each: Uvector basic operations
s8vector-index: Uvector basic operations
s8vector-index-right: Uvector basic operations
s8vector-ior: Uvector numeric operations
s8vector-ior!: Uvector numeric operations
s8vector-length: Uvector basic operations
s8vector-map: Uvector basic operations
s8vector-map!: Uvector basic operations
s8vector-mul: Uvector numeric operations
s8vector-mul!: Uvector numeric operations
s8vector-multi-copy!: Uvector basic operations
s8vector-partition: Uvector basic operations
s8vector-range-check: Uvector numeric operations
s8vector-ref: Uniform vectors
s8vector-remove: Uvector basic operations
s8vector-reverse!: Uvector basic operations
s8vector-reverse-copy: Uvector basic operations
s8vector-reverse-copy!: Uvector basic operations
s8vector-segment: Uvector basic operations
s8vector-set!: Uniform vectors
s8vector-skip: Uvector basic operations
s8vector-skip-right: Uvector basic operations
s8vector-sub: Uvector numeric operations
s8vector-sub!: Uvector numeric operations
s8vector-swap!: Uvector basic operations
s8vector-take: Uvector basic operations
s8vector-take-right: Uvector basic operations
s8vector-take-while: Uvector basic operations
s8vector-take-while-right: Uvector basic operations
s8vector-unfod-right!: Uvector basic operations
s8vector-unfold: Uvector basic operations
s8vector-unfold: Uvector basic operations
s8vector-unfold!: Uvector basic operations
s8vector-unfold!: Uvector basic operations
s8vector-unfold-right: Uvector basic operations
s8vector-unfold-right!: Uvector basic operations
s8vector-xor: Uvector numeric operations
s8vector-xor!: Uvector numeric operations
s8vector=: Uvector basic operations
s8vector=?: Uvector basic operations
s8vector?: Uniform vectors
samples$: Random data generators
samples-from: Random data generators
save-bundle!: Localization
scheduler-exists?: Scheduler
scheduler-remove!: Scheduler
scheduler-reschedule!: Scheduler
scheduler-running?: Scheduler
scheduler-schedule!: Scheduler
scheduler-terminate!: Scheduler
scheme-report-environment: Eval and repl
script-directory: Command line
script-file: Command-line arguments
second: R7RS lists
seconds+: Time
seconds->time: Time
segmented-prefix?: Segmented string matching
select-kids: SXPath basic converters and applicators
select-module: Defining and selecting modules
selector-add!: Simple dispatcher
selector-delete!: Simple dispatcher
selector-select: Simple dispatcher
semaphore-acquire!: Semaphore
semaphore-release!: Semaphore
semaphore?: Semaphore
sequence->kmp-stepper: Other operations over sequences
sequence-contains: Other operations over sequences
sequence-position-column: Lazy sequence with positions
sequence-position-item-count: Lazy sequence with positions
sequence-position-line: Lazy sequence with positions
sequence-position-source: Lazy sequence with positions
sequences-of: Random data generators
sequences-of: Random data generators
sequential-mapper: Parallel map
serious-condition?: Conditions
set: R7RS sets
set!: Assignments
set!: Assignments
set!: CiSE syntax
set!-values: Assignments
set!-values: Assignments
set!-values: Assignments
set->bag: R7RS sets
set->bag!: R7RS sets
set->list: R7RS sets
set-adjoin: R7RS sets
set-adjoin!: R7RS sets
set-any?: R7RS sets
set-box!: Boxes
set-box-value!: Boxes
set-car!: List accessors and modifiers
set-cdr!: List accessors and modifiers
set-character-attribute: Text terminal control
set-contains?: R7RS sets
set-copy: R7RS sets
set-count: R7RS sets
set-current-directory!: POSIX API
set-delete: R7RS sets
set-delete!: R7RS sets
set-delete-all: R7RS sets
set-delete-all!: R7RS sets
set-difference: R7RS sets
set-difference!: R7RS sets
set-disjoint?: R7RS sets
set-element-comparator: R7RS sets
set-empty?: R7RS sets
set-enviroment-variable!: POSIX API
set-every?: R7RS sets
set-file-mode: POSIX API
set-file-owner: POSIX API
set-file-times: POSIX API
set-filter: R7RS sets
set-filter!: R7RS sets
set-find: R7RS sets
set-fold: R7RS sets
set-for-each: R7RS sets
set-intersection: R7RS sets
set-intersection!: R7RS sets
set-map: R7RS sets
set-member: R7RS sets
set-partition: R7RS sets
set-partition!: R7RS sets
set-port-position!: Common port operations
set-remove: R7RS sets
set-remove!: R7RS sets
set-replace: R7RS sets
set-replace!: R7RS sets
set-search!: R7RS sets
set-signal-handler!: Handling signals
set-signal-pending-limit: Handling signals
set-size: R7RS sets
set-time-nanosecond!: SRFI-19 Time procedures
set-time-second!: SRFI-19 Time procedures
set-time-type!: SRFI-19 Time procedures
set-umask!: POSIX API
set-unfold: R7RS sets
set-union: R7RS sets
set-union!: R7RS sets
set-xor: R7RS sets
set-xor!: R7RS sets
set<=?: R7RS sets
set<?: R7RS sets
set=?: R7RS sets
set>=?: R7RS sets
set>?: R7RS sets
setter: Assignments
seventh: R7RS lists
sexp-list->file: File operations
sha1-digest: SHA message digest
sha1-digest-string: SHA message digest
sha224-digest: SHA message digest
sha224-digest-string: SHA message digest
sha256-digest: SHA message digest
sha256-digest-string: SHA message digest
sha384-digest: SHA message digest
sha384-digest-string: SHA message digest
sha512-digest: SHA message digest
sha512-digest-string: SHA message digest
shape: Arrays
shape-for-each: Arrays
share-array: Arrays
shell-escape-string: Process ports
shell-tokenize-string: Process ports
shift: Partial continuations
show: R7RS combinator formatting
show-cursor: Text terminal control
shuffle: Other operations over sequences
shuffle!: Other operations over sequences
shuffle-to: Other operations over sequences
shutdown-method: Basic socket interface
simplex-solve: Simplex solver
simplify-path: Pathname utilities
sin: Arithmetics
sinh: Arithmetics
sint-list->blob: Octet-addressed binary blocks
sint-list->bytevector: R7RS bytevectors
sixth: R7RS lists
size-of: Miscellaneous operations on collection
skew-list->generator: Skew binary random-access lists
skew-list->list: Skew binary random-access lists
skew-list->lseq: Skew binary random-access lists
skew-list-append: Skew binary random-access lists
skew-list-car: Skew binary random-access lists
skew-list-cdr: Skew binary random-access lists
skew-list-cons: Skew binary random-access lists
skew-list-drop: Skew binary random-access lists
skew-list-empty?: Skew binary random-access lists
skew-list-fold: Skew binary random-access lists
skew-list-length: Skew binary random-access lists
skew-list-length<=?: Skew binary random-access lists
skew-list-map: Skew binary random-access lists
skew-list-ref: Skew binary random-access lists
skew-list-set: Skew binary random-access lists
skew-list-split-at: Skew binary random-access lists
skew-list-take: Skew binary random-access lists
skew-list?: Skew binary random-access lists
skip-until: Parsing input stream
skip-while: Parsing input stream
slices: List accessors and modifiers
slot-bound-using-accessor?: Customizing slot access
slot-bound-using-class?: Accessing instance
slot-bound?: Accessing instance
slot-definition-accessor: Slot definition object
slot-definition-allocation: Slot definition object
slot-definition-getter: Slot definition object
slot-definition-name: Slot definition object
slot-definition-option: Slot definition object
slot-definition-options: Slot definition object
slot-definition-setter: Slot definition object
slot-exists?: Accessing instance
slot-initialize-using-accessor!: Customizing slot access
slot-missing: Accessing instance
slot-missing: Accessing instance
slot-pop!: Accessing instance
slot-push!: Accessing instance
slot-ref: Accessing instance
slot-ref-using-accessor: Customizing slot access
slot-ref-using-class: Accessing instance
slot-set!: Accessing instance
slot-set-using-accessor!: Customizing slot access
slot-set-using-class!: Accessing instance
slot-unbound: Accessing instance
slot-unbound: Accessing instance
small-prime?: Prime numbers
sockaddr-addr: Socket address
sockaddr-family: Socket address
sockaddr-family: Socket address
sockaddr-family: Socket address
sockaddr-name: Socket address
sockaddr-name: Socket address
sockaddr-name: Socket address
sockaddr-port: Socket address
socket-accept: Low-level socket interface
socket-address: High-level network functions
socket-bind: Low-level socket interface
socket-buildmsg: Low-level socket interface
socket-close: High-level network functions
socket-connect: Low-level socket interface
socket-domain: Basic socket interface
socket-fd: Low-level socket interface
socket-getpeername: Low-level socket interface
socket-getsockname: Low-level socket interface
socket-getsockopt: Low-level socket interface
socket-input-port: High-level network functions
socket-listen: Low-level socket interface
socket-merge-flags: Basic socket interface
socket-output-port: High-level network functions
socket-purge-flags: Basic socket interface
socket-recv: Low-level socket interface
socket-recv: Basic socket interface
socket-recv!: Low-level socket interface
socket-recvfrom: Low-level socket interface
socket-recvfrom!: Low-level socket interface
socket-send: Low-level socket interface
socket-send: Basic socket interface
socket-sendmsg: Low-level socket interface
socket-sendto: Low-level socket interface
socket-setsockopt: Low-level socket interface
socket-shutdown: Low-level socket interface
socket-status: Low-level socket interface
socket?: Basic socket interface
sort: Sorting and merging
sort!: Sorting and merging
sort-applicable-methods: Customizing method application
sort-by: Sorting and merging
sort-by!: Sorting and merging
sorted?: Sorting and merging
source-code: Debugging aid
source-location: Debugging aid
space-to: R7RS combinator formatting
span: R7RS lists
span!: R7RS lists
sparse-matrix-clear!: Sparse matrixes
sparse-matrix-copy: Sparse matrixes
sparse-matrix-delete!: Sparse matrixes
sparse-matrix-exists?: Sparse matrixes
sparse-matrix-fold: Sparse matrixes
sparse-matrix-for-each: Sparse matrixes
sparse-matrix-inc!: Sparse matrixes
sparse-matrix-keys: Sparse matrixes
sparse-matrix-map: Sparse matrixes
sparse-matrix-num-entries: Sparse matrixes
sparse-matrix-pop!: Sparse matrixes
sparse-matrix-push!: Sparse matrixes
sparse-matrix-ref: Sparse matrixes
sparse-matrix-set!: Sparse matrixes
sparse-matrix-update!: Sparse matrixes
sparse-matrix-values: Sparse matrixes
sparse-table-clear!: Sparse tables
sparse-table-comparator: Sparse tables
sparse-table-copy: Sparse tables
sparse-table-delete!: Sparse tables
sparse-table-exists?: Sparse tables
sparse-table-fold: Sparse tables
sparse-table-for-each: Sparse tables
sparse-table-keys: Sparse tables
sparse-table-map: Sparse tables
sparse-table-num-entries: Sparse tables
sparse-table-pop!: Sparse tables
sparse-table-push!: Sparse tables
sparse-table-ref: Sparse tables
sparse-table-set!: Sparse tables
sparse-table-update!: Sparse tables
sparse-table-values: Sparse tables
sparse-vector-clear!: Sparse vectors
sparse-vector-copy: Sparse vectors
sparse-vector-delete!: Sparse vectors
sparse-vector-exists?: Sparse vectors
sparse-vector-fold: Sparse vectors
sparse-vector-for-each: Sparse vectors
sparse-vector-inc!: Sparse vectors
sparse-vector-keys: Sparse vectors
sparse-vector-map: Sparse vectors
sparse-vector-max-index-bits: Sparse vectors
sparse-vector-num-entries: Sparse vectors
sparse-vector-pop!: Sparse vectors
sparse-vector-push!: Sparse vectors
sparse-vector-ref: Sparse vectors
sparse-vector-set!: Sparse vectors
sparse-vector-update!: Sparse vectors
sparse-vector-values: Sparse vectors
split-at: List accessors and modifiers
split-at!: List accessors and modifiers
split-at*: List accessors and modifiers
sql-tokenize: SQL parsing and construction
sqrt: Arithmetics
square: Arithmetics
sre->regexp: Using regular expressions
srl:display-sxml: Custom SXML serializing
srl:parameterizable: Custom SXML serializing
srl:sxml->html: Simple SXML serializing
srl:sxml->html-noindent: Simple SXML serializing
srl:sxml->string: Custom SXML serializing
srl:sxml->xml: Simple SXML serializing
srl:sxml->xml-noindent: Simple SXML serializing
ssax:assert-token: SSAX higher-level parsers and scanners
ssax:complete-start-tag: SSAX low-level parsing code
ssax:handle-parsed-entity: SSAX low-level parsing code
ssax:make-elem-parser: SSAX Highest-level parsers - XML to SXML
ssax:make-parser: SSAX Highest-level parsers - XML to SXML
ssax:make-pi-parser: SSAX Highest-level parsers - XML to SXML
ssax:ncname-starting-char?: SSAX low-level parsing code
ssax:read-attributes: SSAX low-level parsing code
ssax:read-cdata-body: SSAX low-level parsing code
ssax:read-char-data: SSAX higher-level parsers and scanners
ssax:read-char-ref: SSAX low-level parsing code
ssax:read-external-id: SSAX low-level parsing code
ssax:read-markup-token: SSAX low-level parsing code
ssax:read-NCName: SSAX low-level parsing code
ssax:read-pi-body-as-string: SSAX low-level parsing code
ssax:read-QName: SSAX low-level parsing code
ssax:resolve-name: SSAX low-level parsing code
ssax:reverse-collect-str: SSAX Highest-level parsers - XML to SXML
ssax:reverse-collect-str-drop-ws: SSAX Highest-level parsers - XML to SXML
ssax:scan-Misc: SSAX higher-level parsers and scanners
ssax:skip-internal-dtd: SSAX low-level parsing code
ssax:skip-pi: SSAX low-level parsing code
ssax:skip-S: SSAX low-level parsing code
ssax:uri-string->symbol: SSAX low-level parsing code
ssax:xml->sxml: SSAX Highest-level parsers - XML to SXML
stable-sort: Sorting and merging
stable-sort!: Sorting and merging
stable-sort-by: Sorting and merging
stable-sort-by!: Sorting and merging
stacked-map-depth: Generic dictionaries
stacked-map-entry-delete!: Generic dictionaries
stacked-map-entry-update!: Generic dictionaries
stacked-map-pop!: Generic dictionaries
stacked-map-push!: Generic dictionaries
stacked-map-stack: Generic dictionaries
standard-error-port: Common port operations
standard-input-port: Common port operations
standard-output-port: Common port operations
stirng-replace-linear!: Linear adjustable-length strings
stream: R7RS stream
stream: Stream constructors
stream+: Stream constructors
stream->generator: Generator/accumulator sub-library
stream->list: Stream operations
stream->list: Stream operations
stream->string: Stream operations
stream-any: Stream operations
stream-append: Stream operations
stream-break: Stream operations
stream-butlast: Stream operations
stream-butlast-n: Stream operations
stream-caaaar: Stream operations
stream-caaadr: Stream operations
stream-caaar: Stream operations
stream-caadar: Stream operations
stream-caaddr: Stream operations
stream-caadr: Stream operations
stream-caar: Stream operations
stream-cadaar: Stream operations
stream-cadadr: Stream operations
stream-cadar: Stream operations
stream-caddar: Stream operations
stream-cadddr: Stream operations
stream-caddr: Stream operations
stream-cadr: Stream operations
stream-car: Stream primitives
stream-cdaaar: Stream operations
stream-cdaadr: Stream operations
stream-cdaar: Stream operations
stream-cdadar: Stream operations
stream-cdaddr: Stream operations
stream-cdadr: Stream operations
stream-cdar: Stream operations
stream-cddaar: Stream operations
stream-cddadr: Stream operations
stream-cddar: Stream operations
stream-cdddar: Stream operations
stream-cddddr: Stream operations
stream-cdddr: Stream operations
stream-cddr: Stream operations
stream-cdr: Stream primitives
stream-concat: Stream operations
stream-concatenate: Stream operations
stream-cons: Stream primitives
stream-cons*: Stream constructors
stream-constant: Stream constructors
stream-count: Stream operations
stream-delay: Stream primitives
stream-delete: Stream operations
stream-delete-duplicates: Stream operations
stream-drop: R7RS stream
stream-drop: Stream operations
stream-drop-safe: Stream operations
stream-drop-while: Stream operations
stream-eighth: Stream operations
stream-every: Stream operations
stream-fifth: Stream operations
stream-filter: Stream operations
stream-find: Stream operations
stream-find-tail: Stream operations
stream-first: Stream operations
stream-fold: Stream consumers
stream-for-each: Stream consumers
stream-format: Stream constructors
stream-fourth: Stream operations
stream-from: Stream constructors
stream-grep: Stream operations
stream-index: Stream operations
stream-intersperse: Stream operations
stream-iota: Stream constructors
stream-iterate: Stream constructors
stream-lambda: Stream primitives
stream-last: Stream operations
stream-last-n: Stream operations
stream-length: Stream operations
stream-length=: Stream operations
stream-length>=: Stream operations
stream-let: Stream binding
stream-lines: Stream operations
stream-map: Stream operations
stream-match: Stream binding
stream-member: Stream operations
stream-memq: Stream operations
stream-memv: Stream operations
stream-ninth: Stream operations
stream-null?: SICP prerequisites
stream-null?: Stream primitives
stream-of: Stream constructors
stream-pair?: Stream primitives
stream-partition: Stream operations
stream-prefix=: Stream operations
stream-range: Stream constructors
stream-ref: Stream operations
stream-remove: Stream operations
stream-reverse: Stream operations
stream-scan: Stream operations
stream-second: Stream operations
stream-seventh: Stream operations
stream-sixth: Stream operations
stream-span: Stream operations
stream-split: Stream operations
stream-tabulate: Stream constructors
stream-take: R7RS stream
stream-take: Stream operations
stream-take-safe: Stream operations
stream-take-while: Stream operations
stream-tenth: Stream operations
stream-third: Stream operations
stream-unfold: Stream constructors
stream-unfoldn: Stream constructors
stream-unfolds: Stream constructors
stream-xcons: Stream constructors
stream-zip: Stream operations
stream=: Stream operations
stream?: Stream primitives
string: String constructors
string->bitvector: Bitvectors
string->bytevector: Transcoded ports
string->char-set: Character-set constructors
string->char-set!: Character-set constructors
string->date: SRFI-19 Date reader and writer
string->file: File operations
string->gap-buffer: Gap buffer
string->generator: Generator constructors
string->grapheme-clusters: Unicode text segmentation
string->list: String utilities
string->number: Numerical conversions
string->regexp: Using regular expressions
string->s32vector: Uniform vectors
string->s32vector!: Uniform vectors
string->s8vector: Uniform vectors
string->s8vector!: Uniform vectors
string->stream: Stream constructors
string->symbol: Symbols
string->text: R7RS immutable texts
string->u32vector: Uniform vectors
string->u32vector!: Uniform vectors
string->u8vector: Uniform vectors
string->u8vector!: Uniform vectors
string->ulid: Universally unique lexicographically sortable identifier
string->uninterned-symbol: Symbols
string->utf16: Unicode transfer encodings
string->utf32: Unicode transfer encodings
string->utf8: Unicode transfer encodings
string->vector: Vectors
string->words: Unicode text segmentation
string-accumulator: R7RS generators
string-any: SRFI-13 String predicates
string-append: String utilities
string-append!: Simple adjustable-size strings
string-append!: Linear adjustable-length strings
string-append-ec: Eager comprehensions
string-append-linear!: Linear adjustable-length strings
string-append/shared: SRFI-13 String reverse & append
string-break: String library (reduced)
string-build-index!: String indexing
string-byte-ref: String accessors & modifiers
string-byte-set!: String accessors & modifiers
string-ci-hash: Hashing
string-ci-hash: R7RS hash tables
string-ci-hash: Basic hash tables
string-ci<: SRFI-13 String comparison
string-ci<=: SRFI-13 String comparison
string-ci<=?: String comparison
string-ci<=?: Full string case conversion
string-ci<>: SRFI-13 String comparison
string-ci<?: String comparison
string-ci<?: Full string case conversion
string-ci=: SRFI-13 String comparison
string-ci=?: String comparison
string-ci=?: Full string case conversion
string-ci>: SRFI-13 String comparison
string-ci>=: SRFI-13 String comparison
string-ci>=?: String comparison
string-ci>=?: Full string case conversion
string-ci>?: String comparison
string-ci>?: Full string case conversion
string-compare: SRFI-13 String comparison
string-compare-ci: SRFI-13 String comparison
string-concatenate: SRFI-13 String reverse & append
string-concatenate-reverse: SRFI-13 String reverse & append
string-concatenate-reverse/shared: SRFI-13 String reverse & append
string-concatenate/shared: SRFI-13 String reverse & append
string-contains: SRFI-13 String searching
string-contains: Cursor-based string library
string-contains-ci: SRFI-13 String searching
string-contains-right: Cursor-based string library
string-contains-right: String library (reduced)
string-copy: String utilities
string-copy!: SRFI-13 String selection
string-copy-immutable: String utilities
string-count: SRFI-13 String searching
string-cursor->index: String cursors
string-cursor-back: String cursors
string-cursor-diff: String cursors
string-cursor-end: String cursors
string-cursor-forward: String cursors
string-cursor-next: String cursors
string-cursor-prev: String cursors
string-cursor-start: String cursors
string-cursor<=?: String cursors
string-cursor<?: String cursors
string-cursor=?: String cursors
string-cursor>=?: String cursors
string-cursor>?: String cursors
string-cursor?: String cursors
string-delete: SRFI-13 String filtering
string-downcase: Full string case conversion
string-downcase: SRFI-13 String case mapping
string-downcase!: SRFI-13 String case mapping
string-drop: SRFI-13 String selection
string-drop-right: SRFI-13 String selection
string-drop-while: String library (reduced)
string-drop-while-right: String library (reduced)
string-drop-width: East asian width property
string-east-asian-width: East asian width property
string-ec: Eager comprehensions
string-every: SRFI-13 String predicates
string-fast-indexable?: String indexing
string-fill!: String utilities
string-filter: SRFI-13 String filtering
string-fold: SRFI-13 String mapping
string-fold-right: SRFI-13 String mapping
string-foldcase: Full string case conversion
string-for-each: String utilities
string-for-each: String utilities
string-for-each-cursor: Cursor-based string library
string-for-each-index: SRFI-13 String mapping
string-hash: Hashing
string-hash: R7RS hash tables
string-hash: SRFI-13 String comparison
string-hash: Basic hash tables
string-hash-ci: SRFI-13 String comparison
string-immutable?: String predicates
string-incomplete->complete: Incomplete strings
string-incomplete?: String predicates
string-index: SRFI-13 String searching
string-index: Cursor-based string library
string-index->cursor: String cursors
string-index-right: SRFI-13 String searching
string-index-right: Cursor-based string library
string-join: String utilities
string-kmp-partial-search: SRFI-13 Low-level string procedures
string-length: String accessors & modifiers
string-list->file: File operations
string-map: String utilities
string-map: String utilities
string-map!: SRFI-13 String mapping
string-null?: SRFI-13 String predicates
string-pad: SRFI-13 String selection
string-pad-right: SRFI-13 String selection
string-parse-final-start+end: SRFI-13 Low-level string procedures
string-parse-start+end: SRFI-13 Low-level string procedures
string-prefix-ci?: SRFI-13 String prefixes & suffixes
string-prefix-length: SRFI-13 String prefixes & suffixes
string-prefix-length-ci: SRFI-13 String prefixes & suffixes
string-prefix?: SRFI-13 String prefixes & suffixes
string-range: Range
string-ref: String accessors & modifiers
string-remove: String library (reduced)
string-replace: SRFI-13 Other string operations
string-replace!: Simple adjustable-size strings
string-replace!: Linear adjustable-length strings
string-replicate: String library (reduced)
string-reverse: SRFI-13 String reverse & append
string-reverse!: SRFI-13 String reverse & append
string-scan: String utilities
string-scan-right: String utilities
string-segment: String library (reduced)
string-set!: String accessors & modifiers
string-size: String accessors & modifiers
string-skip: SRFI-13 String searching
string-skip: Cursor-based string library
string-skip-right: SRFI-13 String searching
string-skip-right: Cursor-based string library
string-span: String library (reduced)
string-split: String utilities
string-split: String utilities
string-suffix-ci?: SRFI-13 String prefixes & suffixes
string-suffix-length: SRFI-13 String prefixes & suffixes
string-suffix-length-ci: SRFI-13 String prefixes & suffixes
string-suffix?: SRFI-13 String prefixes & suffixes
string-tabulate: SRFI-13 String constructors
string-take: SRFI-13 String selection
string-take-right: SRFI-13 String selection
string-take-while: String library (reduced)
string-take-while-right: String library (reduced)
string-take-width: East asian width property
string-titlecase: Full string case conversion
string-titlecase: SRFI-13 String case mapping
string-titlecase!: SRFI-13 String case mapping
string-tokenize: SRFI-13 Other string operations
string-tr: Transliterate characters
string-trim: SRFI-13 String selection
string-trim-both: SRFI-13 String selection
string-trim-right: SRFI-13 String selection
string-unfold: SRFI-13 String constructors
string-unfold-right: SRFI-13 String constructors
string-upcase: Full string case conversion
string-upcase: SRFI-13 String case mapping
string-upcase!: SRFI-13 String case mapping
string-xcopy!: SRFI-13 String rotation
string<: SRFI-13 String comparison
string<=: SRFI-13 String comparison
string<=?: String comparison
string<>: SRFI-13 String comparison
string<?: String comparison
string=: SRFI-13 String comparison
string=?: String comparison
string>: SRFI-13 String comparison
string>=: SRFI-13 String comparison
string>=?: String comparison
string>?: String comparison
string?: String predicates
strings-of: Random data generators
strings-of: Random data generators
strings-of: Random data generators
subclass?: Generic type predicates
subrange: Range
subseq: Slicing sequence
substring: String utilities
substring-spec-ok?: SRFI-13 Low-level string procedures
substring/shared: SRFI-13 String selection
subtext: R7RS immutable texts
subtextual: R7RS immutable texts
subtract-duration: SRFI-19 Time procedures
subtract-duration!: SRFI-19 Time procedures
subtype?: Generic type predicates
sum-accumulator: R7RS generators
sum-ec: Eager comprehensions
supported-character-encodings: Characters
swap: Combinators
sxml:add-attr: SXML modifiers
sxml:add-attr!: SXML modifiers
sxml:add-aux: SXML modifiers
sxml:add-aux!: SXML modifiers
sxml:add-parents: SXPath auxiliary utilities
sxml:ancestor: SXPath extension
sxml:ancestor-or-self: SXPath extension
sxml:attr: SXML accessors
sxml:attr->html: SXML to markup conversion
sxml:attr->xml: SXML to markup conversion
sxml:attr-as-list: SXML accessors
sxml:attr-list: SXPath extension
sxml:attr-list-node: SXML accessors
sxml:attr-list-u: SXML accessors
sxml:attr-u: SXML accessors
sxml:attribute: SXPath extension
sxml:aux-as-list: SXML accessors
sxml:aux-list: SXML accessors
sxml:aux-list-node: SXML accessors
sxml:aux-list-u: SXML accessors
sxml:aux-node: SXML accessors
sxml:aux-nodes: SXML accessors
sxml:boolean: SXPath extension
sxml:change-attr: SXML modifiers
sxml:change-attr!: SXML modifiers
sxml:change-attrlist: SXML modifiers
sxml:change-attrlist!: SXML modifiers
sxml:change-content: SXML modifiers
sxml:change-content!: SXML modifiers
sxml:change-name: SXML modifiers
sxml:change-name!: SXML modifiers
sxml:child: SXPath extension
sxml:child-elements: SXPath extension
sxml:child-nodes: SXPath extension
sxml:clean: SXML modifiers
sxml:clean-feed: SXML to markup conversion
sxml:content: SXML accessors
sxml:content-raw: SXML accessors
sxml:descendant: SXPath extension
sxml:descendant-or-self: SXPath extension
sxml:element-name: SXML accessors
sxml:element?: SXPath basic converters and applicators
sxml:empty-element?: SXML predicates
sxml:equal?: SXPath extension
sxml:equality-cmp: SXPath extension
sxml:filter: SXPath basic converters and applicators
sxml:following: SXPath extension
sxml:following-sibling: SXPath extension
sxml:id: SXPath extension
sxml:id-alist: SXPath query language
sxml:invert: SXPath basic converters and applicators
sxml:lookup: SXPath auxiliary utilities
sxml:minimized?: SXML predicates
sxml:name: SXML accessors
sxml:name->ns-id: SXML accessors
sxml:namespace: SXPath extension
sxml:ncname: SXML accessors
sxml:node-name: SXML accessors
sxml:node-parent: SXPath auxiliary utilities
sxml:node?: SXPath extension
sxml:non-terminated-html-tag?: SXML to markup conversion
sxml:normalized?: SXML predicates
sxml:not-equal?: SXPath extension
sxml:ns-id: SXML accessors
sxml:ns-id->nodes: SXML accessors
sxml:ns-id->uri: SXML accessors
sxml:ns-list: SXML accessors
sxml:ns-prefix: SXML accessors
sxml:ns-uri: SXML accessors
sxml:ns-uri->id: SXML accessors
sxml:num-attr: SXML accessors
sxml:number: SXPath extension
sxml:parent: SXPath extension
sxml:preceding: SXPath extension
sxml:preceding-sibling: SXPath extension
sxml:relational-cmp: SXPath extension
sxml:set-attr: SXML modifiers
sxml:set-attr!: SXML modifiers
sxml:shallow-minimized?: SXML predicates
sxml:shallow-normalized?: SXML predicates
sxml:squeeze: SXML modifiers
sxml:squeeze!: SXML modifiers
sxml:string: SXPath extension
sxml:string->html: SXML to markup conversion
sxml:string->xml: SXML to markup conversion
sxml:string-value: SXPath extension
sxml:sxml->html: SXML to markup conversion
sxml:sxml->xml: SXML to markup conversion
sxpath: SXPath query language
symbol->string: Symbols
symbol-append: Symbols
symbol-append: Symbols
symbol-hash: Hashing
symbol-interned?: Symbols
symbol-sans-prefix: Symbols
symbol=?: Symbols
symbol?: Symbols
syntax-error: Macro utilities
syntax-errorf: Macro utilities
syntax-rules: Syntax-rules macro transformer
syntax-rules: Syntax-rules macro transformer
sys-abort: Program termination
sys-access: File stats
sys-alarm: Miscellaneous system calls
sys-alloc-console: Windows console API
sys-asctime: Time
sys-available-processors: Environment inquiry
sys-basename: Pathnames
sys-cfgetispeed: Posix termios interface
sys-cfgetospeed: Posix termios interface
sys-cfsetispeed: Posix termios interface
sys-cfsetospeed: Posix termios interface
sys-chdir: Other file operations
sys-chmod: File stats
sys-chown: File stats
sys-clearenv: Environment inquiry
sys-closelog: Syslog
sys-create-console-screen-buffer: Windows console API
sys-crypt: Unix groups and users
sys-ctermid: System inquiry
sys-ctime: Time
sys-difftime: Time
sys-dirname: Pathnames
sys-environ: Environment inquiry
sys-environ->alist: Environment inquiry
sys-errno->symbol: System inquiry
sys-exec: Process management
sys-exit: Program termination
sys-fchmod: File stats
sys-fcntl: Low-level file operations
sys-fdset: I/O multiplexing
sys-fdset->list: I/O multiplexing
sys-fdset-clear!: I/O multiplexing
sys-fdset-copy!: I/O multiplexing
sys-fdset-max-fd: I/O multiplexing
sys-fdset-ref: I/O multiplexing
sys-fdset-set!: I/O multiplexing
sys-fill-console-output-attribute: Windows console API
sys-fill-console-output-character: Windows console API
sys-flush-console-input-buffer: Windows console API
sys-fork: Process management
sys-fork-and-exec: Process management
sys-forkpty: Posix termios interface
sys-forkpty-and-exec: Posix termios interface
sys-free-console: Windows console API
sys-fstat: File stats
sys-fstatvfs: Low-level file operations
sys-ftruncate: Other file operations
sys-generate-console-ctrl-event: Windows console API
sys-get-console-cp: Windows console API
sys-get-console-cursor-info: Windows console API
sys-get-console-mode: Windows console API
sys-get-console-output-cp: Windows console API
sys-get-console-screen-buffer-info: Windows console API
sys-get-console-title: Windows console API
sys-get-largest-console-window-size: Windows console API
sys-get-number-of-console-input-events: Windows console API
sys-get-number-of-console-mouse-buttons: Windows console API
sys-get-osfhandle: Miscellaneous system calls
sys-get-std-handle: Windows console API
sys-getaddrinfo: Netdb interface
sys-getcwd: System inquiry
sys-getdomainname: System inquiry
sys-getegid: System inquiry
sys-getenv: Environment inquiry
sys-geteuid: System inquiry
sys-getgid: System inquiry
sys-getgrgid: Unix groups and users
sys-getgrnam: Unix groups and users
sys-getgroups: System inquiry
sys-gethostbyaddr: Netdb interface
sys-gethostbyname: Netdb interface
sys-gethostname: System inquiry
sys-getlogin: System inquiry
sys-getpgid: System inquiry
sys-getpgrp: System inquiry
sys-getpid: System inquiry
sys-getppid: System inquiry
sys-getprotobyname: Netdb interface
sys-getprotobynumber: Netdb interface
sys-getpwnam: Unix groups and users
sys-getpwuid: Unix groups and users
sys-getrlimit: System inquiry
sys-getservbyname: Netdb interface
sys-getservbyport: Netdb interface
sys-gettimeofday: Time
sys-getuid: System inquiry
sys-gid->group-name: Unix groups and users
sys-glob: Directories
sys-gmtime: Time
sys-group-name->gid: Unix groups and users
sys-htonl: Netdb interface
sys-htons: Netdb interface
sys-isatty: Other file operations
sys-kill: Sending signals
sys-link: Directory manipulation
sys-localeconv: Locale
sys-localtime: Time
sys-logmask: Syslog
sys-lstat: File stats
sys-message-box: Windows dialogs
sys-mkdir: Directory manipulation
sys-mkdtemp: Directory manipulation
sys-mkfifo: Other file operations
sys-mkstemp: Directory manipulation
sys-mktime: Time
sys-mmap: Memory mapping
sys-nanosleep: Miscellaneous system calls
sys-nice: System inquiry
sys-normalize-pathname: Pathnames
sys-ntohl: Netdb interface
sys-ntohs: Netdb interface
sys-open: Low-level file operations
sys-openlog: Syslog
sys-openpty: Posix termios interface
sys-pause: Miscellaneous system calls
sys-peek-console-input: Windows console API
sys-pipe: Other file operations
sys-putenv: Environment inquiry
sys-random: Miscellaneous system calls
sys-read-console: Windows console API
sys-read-console-input: Windows console API
sys-read-console-output: Windows console API
sys-read-console-output-attribute: Windows console API
sys-read-console-output-character: Windows console API
sys-readdir: Directories
sys-readlink: Directory manipulation
sys-realpath: Pathnames
sys-remove: Directory manipulation
sys-rename: Directory manipulation
sys-rmdir: Directory manipulation
sys-scroll-console-screen-buffer: Windows console API
sys-select: I/O multiplexing
sys-select!: I/O multiplexing
sys-set-console-active-screen-buffer: Windows console API
sys-set-console-cp: Windows console API
sys-set-console-cursor-info: Windows console API
sys-set-console-cursor-position: Windows console API
sys-set-console-mode: Windows console API
sys-set-console-output-cp: Windows console API
sys-set-console-text-attribute: Windows console API
sys-set-console-title: Windows console API
sys-set-console-window-info: Windows console API
sys-set-screen-buffer-size: Windows console API
sys-set-std-handle: Windows console API
sys-setenv: Environment inquiry
sys-setgid: System inquiry
sys-setgroups: System inquiry
sys-setlocale: Locale
sys-setlogmask: Syslog
sys-setpgid: System inquiry
sys-setrlimit: System inquiry
sys-setsid: System inquiry
sys-setugid?: System inquiry
sys-setuid: System inquiry
sys-sigmask: Masking and waiting signals
sys-signal-name: Signals and signal sets
sys-sigset: Signals and signal sets
sys-sigset-add!: Signals and signal sets
sys-sigset-delete!: Signals and signal sets
sys-sigset-empty!: Signals and signal sets
sys-sigset-fill!: Signals and signal sets
sys-sigsuspend: Masking and waiting signals
sys-sigwait: Masking and waiting signals
sys-sleep: Miscellaneous system calls
sys-srandom: Miscellaneous system calls
sys-stat: File stats
sys-stat->atime: File stats
sys-stat->ctime: File stats
sys-stat->dev: File stats
sys-stat->file-type: File stats
sys-stat->gid: File stats
sys-stat->ino: File stats
sys-stat->mode: File stats
sys-stat->mtime: File stats
sys-stat->nlink: File stats
sys-stat->rdev: File stats
sys-stat->size: File stats
sys-stat->uid: File stats
sys-statvfs: Low-level file operations
sys-strerror: System inquiry
sys-strftime: Time
sys-strsignal: Signals and signal sets
sys-symbol->errno: System inquiry
sys-symlink: Directory manipulation
sys-syslog: Syslog
sys-system: Process management
sys-tcdrain: Posix termios interface
sys-tcflow: Posix termios interface
sys-tcflush: Posix termios interface
sys-tcgetattr: Posix termios interface
sys-tcgetpgrp: Posix termios interface
sys-tcsendbreak: Posix termios interface
sys-tcsetattr: Posix termios interface
sys-tcsetpgrp: Posix termios interface
sys-time: Time
sys-times: System inquiry
sys-tm->alist: Time
sys-tmpdir: Pathnames
sys-tmpnam: Directory manipulation
sys-truncate: Other file operations
sys-ttyname: Other file operations
sys-uid->user-name: Unix groups and users
sys-umask: Directory manipulation
sys-uname: System inquiry
sys-unlink: Directory manipulation
sys-unsetenv: Environment inquiry
sys-user-name->uid: Unix groups and users
sys-utime: File stats
sys-wait: Process management
sys-wait-exit-status: Process management
sys-wait-exited?: Process management
sys-wait-signaled?: Process management
sys-wait-stopped?: Process management
sys-wait-stopsig: Process management
sys-wait-termsig: Process management
sys-waitpid: Process management
sys-win-process-pid: Process management
sys-win-process?: Process management
sys-write-console: Windows console API
sys-write-console-output-character: Windows console API

T
tab-to: R7RS combinator formatting
tabular: R7RS combinator formatting
tabulate-array: Arrays
take: List accessors and modifiers
take!: List accessors and modifiers
take*: List accessors and modifiers
take-after: SXPath basic converters and applicators
take-right: List accessors and modifiers
take-right*: List accessors and modifiers
take-until: SXPath basic converters and applicators
take-while: R7RS lists
take-while!: R7RS lists
tan: Arithmetics
tanh: Arithmetics
temp-file-prefix: POSIX API
temporarily: Dynamic states
temporary-directory: Temporary files and directories
tenth: R7RS lists
terminal?: POSIX API
terminate-all!: Thread pools
terminated-thread-exception?: Thread exceptions
test: Individual test
test*: Individual test
test*/diff: Better test failure reporting
test-and-set!: SICP prerequisites
test-check: Individual test
test-check-diff: Better test failure reporting
test-end: Structuring a test file
test-error: Individual test
test-include-r7: Incorporating external tests
test-log: Structuring a test file
test-module: Quasi-static checks
test-none-of: Individual test
test-one-of: Individual test
test-record-file: Structuring a test file
test-report-failure: Individual test
test-report-failure-diff: Better test failure reporting
test-script: Quasi-static checks
test-section: Structuring a test file
test-start: Structuring a test file
test-summary-check: Structuring a test file
test-truthy: Individual test
text: R7RS immutable texts
text-length: R7RS immutable texts
text-ref: R7RS immutable texts
text-tabulate: R7RS immutable texts
text-unfold: R7RS immutable texts
text-unfold-right: R7RS immutable texts
text?: R7RS immutable texts
textdomain: Localized messages
textual->list: R7RS immutable texts
textual->string: R7RS immutable texts
textual->text: R7RS immutable texts
textual->utf16: R7RS immutable texts
textual->utf16be: R7RS immutable texts
textual->utf16le: R7RS immutable texts
textual->utf8: R7RS immutable texts
textual->vector: R7RS immutable texts
textual-any: R7RS immutable texts
textual-append: R7RS immutable texts
textual-ci<=?: R7RS immutable texts
textual-ci<?: R7RS immutable texts
textual-ci=?: R7RS immutable texts
textual-ci>=?: R7RS immutable texts
textual-ci>?: R7RS immutable texts
textual-concatenate: R7RS immutable texts
textual-concatenate-reversse: R7RS immutable texts
textual-contains: R7RS immutable texts
textual-contains-right: R7RS immutable texts
textual-copy: R7RS immutable texts
textual-count: R7RS immutable texts
textual-downcase: R7RS immutable texts
textual-drop: R7RS immutable texts
textual-drop-right: R7RS immutable texts
textual-every: R7RS immutable texts
textual-filter: R7RS immutable texts
textual-fold: R7RS immutable texts
textual-fold-right: R7RS immutable texts
textual-foldcase: R7RS immutable texts
textual-for-each: R7RS immutable texts
textual-for-each-index: R7RS immutable texts
textual-index: R7RS immutable texts
textual-index-right: R7RS immutable texts
textual-join: R7RS immutable texts
textual-length: R7RS immutable texts
textual-map: R7RS immutable texts
textual-map-index: R7RS immutable texts
textual-null?: R7RS immutable texts
textual-pad: R7RS immutable texts
textual-pad-right: R7RS immutable texts
textual-port?: R7RS base library
textual-prefix-length: R7RS immutable texts
textual-prefix?: R7RS immutable texts
textual-ref: R7RS immutable texts
textual-remove: R7RS immutable texts
textual-replace: R7RS immutable texts
textual-replicate: R7RS immutable texts
textual-skip: R7RS immutable texts
textual-skip-right: R7RS immutable texts
textual-split: R7RS immutable texts
textual-suffix-length: R7RS immutable texts
textual-suffix?: R7RS immutable texts
textual-take: R7RS immutable texts
textual-take-right: R7RS immutable texts
textual-titlecase: R7RS immutable texts
textual-trim: R7RS immutable texts
textual-trim-both: R7RS immutable texts
textual-trim-right: R7RS immutable texts
textual-upcase: R7RS immutable texts
textual<=?: R7RS immutable texts
textual<?: R7RS immutable texts
textual=?: R7RS immutable texts
textual>=?: R7RS immutable texts
textual>?: R7RS immutable texts
textual?: R7RS immutable texts
third: R7RS lists
thread-abandoned-mutex-condition?: Thread exceptions
thread-already-terminated-condition?: Thread exceptions
thread-condition?: Thread exceptions
thread-cont!: Thread procedures
thread-join!: Thread procedures
thread-local?: Thread local storage
thread-name: Thread procedures
thread-pool-results: Thread pools
thread-pool-shut-down?: Thread pools
thread-schedule-terminate!: Thread procedures
thread-sleep!: Thread procedures
thread-specific: Thread procedures
thread-specific-set!: Thread procedures
thread-start!: Thread procedures
thread-state: Thread procedures
thread-stop!: Thread procedures
thread-terminate!: Thread procedures
thread-timeout-condition?: Thread exceptions
thread-try-start!: Thread procedures
thread-yield!: Thread procedures
thread?: Thread procedures
time: Measure timings
time->seconds: Time
time-counter-reset!: Measure timings
time-counter-start!: Measure timings
time-counter-stop!: Measure timings
time-counter-value: Measure timings
time-difference: SRFI-19 Time procedures
time-difference!: SRFI-19 Time procedures
time-monotonic->date: SRFI-19 Date
time-monotonic->julian-day: SRFI-19 Date
time-monotonic->modified-julian-day: SRFI-19 Date
time-monotonic->time-tai: SRFI-19 Date
time-monotonic->time-tai!: SRFI-19 Date
time-monotonic->time-utc: SRFI-19 Date
time-monotonic->time-utc!: SRFI-19 Date
time-nanosecond: SRFI-19 Time procedures
time-resolution: SRFI-19 Time queries
time-result+: Measure timings
time-result-: Measure timings
time-result-count: Measure timings
time-result-real: Measure timings
time-result-sys: Measure timings
time-result-user: Measure timings
time-result?: Measure timings
time-second: SRFI-19 Time procedures
time-tai->date: SRFI-19 Date
time-tai->julian-day: SRFI-19 Date
time-tai->modified-julian-day: SRFI-19 Date
time-tai->time-monotonic: SRFI-19 Date
time-tai->time-monotonic!: SRFI-19 Date
time-tai->time-utc: SRFI-19 Date
time-tai->time-utc!: SRFI-19 Date
time-these: Measure timings
time-these/report: Measure timings
time-this: Measure timings
time-type: SRFI-19 Time procedures
time-utc->date: SRFI-19 Date
time-utc->julian-day: SRFI-19 Date
time-utc->modified-julian-day: SRFI-19 Date
time-utc->time-monotonic: SRFI-19 Date
time-utc->time-monotonic!: SRFI-19 Date
time-utc->time-tai: SRFI-19 Date
time-utc->time-tai!: SRFI-19 Date
time<=?: SRFI-19 Time procedures
time<?: SRFI-19 Time procedures
time=?: SRFI-19 Time procedures
time>=?: SRFI-19 Time procedures
time>?: SRFI-19 Time procedures
time?: Time
timer-cancel!: Timer APIs
timer-delta?: Timer APIs
timer-reschedule!: Timer APIs
timer-schedule!: Timer APIs
timer-task-exists?: Timer APIs
timer-task-remove!: Timer APIs
timer?: Timer APIs
timespec: POSIX timespecs
timespec->inexact: POSIX timespecs
timespec-hash: POSIX timespecs
timespec-nanosecods: POSIX timespecs
timespec-seconds: POSIX timespecs
timespec<?: POSIX timespecs
timespec=?: POSIX timespecs
timespec?: POSIX timespecs
tlref: Thread local storage
tls-accept: Transport layer security
tls-bind: Transport layer security
tls-ca-bundle-path: Transport layer security
tls-close: Transport layer security
tls-connect: Transport layer security
tls-input-port: Transport layer security
tls-load-certificate: Transport layer security
tls-load-private-key: Transport layer security
tls-output-port: Transport layer security
tls-poll: Transport layer security
tlset!: Thread local storage
topological-sort: Topological sort
totient: Prime numbers
touch-file: File operations
touch-files: File operations
tr: Transliterate characters
trace-macro: Tracing macro expansion
trace-macro: Tracing macro expansion
trace-macro: Tracing macro expansion
transcoded-port: Transcoded ports
tree->string: Lazy text construction
tree-map->alist: Treemaps
tree-map->generator/key-range: Treemaps
tree-map->imap: Immutable map
tree-map-ceiling: Treemaps
tree-map-ceiling-key: Treemaps
tree-map-ceiling-value: Treemaps
tree-map-clear!: Treemaps
tree-map-comparator: Treemaps
tree-map-compare-as-sequences: Treemaps
tree-map-compare-as-sets: Treemaps
tree-map-copy: Treemaps
tree-map-delete!: Treemaps
tree-map-empty?: Treemaps
tree-map-exists?: Treemaps
tree-map-floor: Treemaps
tree-map-floor-key: Treemaps
tree-map-floor-value: Treemaps
tree-map-fold: Treemaps
tree-map-fold-right: Treemaps
tree-map-for-each: Treemaps
tree-map-get: Treemaps
tree-map-keys: Treemaps
tree-map-map: Treemaps
tree-map-max: Treemaps
tree-map-min: Treemaps
tree-map-num-entries: Treemaps
tree-map-pop!: Treemaps
tree-map-pop-max!: Treemaps
tree-map-pop-min!: Treemaps
tree-map-predecessor: Treemaps
tree-map-predecessor-key: Treemaps
tree-map-predecessor-value: Treemaps
tree-map-push!: Treemaps
tree-map-put!: Treemaps
tree-map-successor: Treemaps
tree-map-successor-key: Treemaps
tree-map-successor-value: Treemaps
tree-map-update!: Treemaps
tree-map-values: Treemaps
tri-not: Trivalent logic
trie: Trie
trie->hash-table: Trie
trie->list: Trie
trie-common-prefix: Trie
trie-common-prefix-fold: Trie
trie-common-prefix-for-each: Trie
trie-common-prefix-keys: Trie
trie-common-prefix-map: Trie
trie-common-prefix-values: Trie
trie-delete!: Trie
trie-exists?: Trie
trie-fold: Trie
trie-for-each: Trie
trie-get: Trie
trie-keys: Trie
trie-longest-match: Trie
trie-map: Trie
trie-num-entries: Trie
trie-partial-key?: Trie
trie-put!: Trie
trie-update!: Trie
trie-values: Trie
trie-with-keys: Trie
trie?: Trie
trimmed: R7RS combinator formatting
trimmed/both: R7RS combinator formatting
trimmed/lazy: R7RS combinator formatting
trimmed/right: R7RS combinator formatting
truncate: Arithmetics
truncate->exact: Arithmetics
truncate-file: POSIX API
truncate-quotient: Arithmetics
truncate-remainder: Arithmetics
truncate/: Arithmetics
truth->either: Maybe and Either protocol converters
truth->maybe: Maybe and Either protocol converters
try-and: Trivalent logic
try-merge: Trivalent logic
try-or: Trivalent logic
try=?: Trivalent logic
tuples-of: Random data generators
two-values->maybe: Maybe and Either protocol converters
twos-exponent: Basic bitwise operations
twos-exponent-factor: Basic bitwise operations
typecase: Conditionals

U
u16?: Uvector basic operations
u16array: Arrays
u16ite-u8vector: Uvector block I/O
u16ke-u8vector-generator: Uvector basic operations
u16vector: Uvector basic operations
u16vector->list: Uvector conversion operations
u16vector->vector: Uvector conversion operations
u16vector-add: Uvector numeric operations
u16vector-add!: Uvector numeric operations
u16vector-and: Uvector numeric operations
u16vector-and!: Uvector numeric operations
u16vector-any: Uvector basic operations
u16vector-append: Uvector basic operations
u16vector-append-subvectors: Uvector basic operations
u16vector-clamp: Uvector numeric operations
u16vector-clamp!: Uvector numeric operations
u16vector-compare: Uvector basic operations
u16vector-concatenate: Uvector basic operations
u16vector-copy: Uvector basic operations
u16vector-copy!: Uvector basic operations
u16vector-count: Uvector basic operations
u16vector-cumulate: Uvector basic operations
u16vector-dot: Uvector numeric operations
u16vector-drop: Uvector basic operations
u16vector-drop-right: Uvector basic operations
u16vector-drop-while: Uvector basic operations
u16vector-drop-while-right: Uvector basic operations
u16vector-empty?: Uvector basic operations
u16vector-every: Uvector basic operations
u16vector-fill!: Uvector basic operations
u16vector-filter: Uvector basic operations
u16vector-fold: Uvector basic operations
u16vector-for-each: Uvector basic operations
u16vector-index: Uvector basic operations
u16vector-index-right: Uvector basic operations
u16vector-ior: Uvector numeric operations
u16vector-ior!: Uvector numeric operations
u16vector-length: Uvector basic operations
u16vector-map: Uvector basic operations
u16vector-map!: Uvector basic operations
u16vector-mul: Uvector numeric operations
u16vector-mul!: Uvector numeric operations
u16vector-multi-copy!: Uvector basic operations
u16vector-partition: Uvector basic operations
u16vector-range-check: Uvector numeric operations
u16vector-ref: Uniform vectors
u16vector-remove: Uvector basic operations
u16vector-reverse!: Uvector basic operations
u16vector-reverse-copy: Uvector basic operations
u16vector-reverse-copy!: Uvector basic operations
u16vector-segment: Uvector basic operations
u16vector-set!: Uniform vectors
u16vector-skip: Uvector basic operations
u16vector-skip-right: Uvector basic operations
u16vector-sub: Uvector numeric operations
u16vector-sub!: Uvector numeric operations
u16vector-swap!: Uvector basic operations
u16vector-take: Uvector basic operations
u16vector-take-right: Uvector basic operations
u16vector-take-while: Uvector basic operations
u16vector-take-while-right: Uvector basic operations
u16vector-unfod-right!: Uvector basic operations
u16vector-unfold: Uvector basic operations
u16vector-unfold: Uvector basic operations
u16vector-unfold!: Uvector basic operations
u16vector-unfold!: Uvector basic operations
u16vector-unfold-right: Uvector basic operations
u16vector-unfold-right!: Uvector basic operations
u16vector-xor: Uvector numeric operations
u16vector-xor!: Uvector numeric operations
u16vector=: Uvector basic operations
u16vector=?: Uvector basic operations
u16vector?: Uniform vectors
u32?: Uvector basic operations
u32array: Arrays
u32ite-u8vector: Uvector block I/O
u32ke-u8vector-generator: Uvector basic operations
u32vector: Uvector basic operations
u32vector->list: Uvector conversion operations
u32vector->string: Uniform vectors
u32vector->vector: Uvector conversion operations
u32vector-add: Uvector numeric operations
u32vector-add!: Uvector numeric operations
u32vector-and: Uvector numeric operations
u32vector-and!: Uvector numeric operations
u32vector-any: Uvector basic operations
u32vector-append: Uvector basic operations
u32vector-append-subvectors: Uvector basic operations
u32vector-clamp: Uvector numeric operations
u32vector-clamp!: Uvector numeric operations
u32vector-compare: Uvector basic operations
u32vector-concatenate: Uvector basic operations
u32vector-copy: Uvector basic operations
u32vector-copy!: Uvector basic operations
u32vector-count: Uvector basic operations
u32vector-cumulate: Uvector basic operations
u32vector-dot: Uvector numeric operations
u32vector-drop: Uvector basic operations
u32vector-drop-right: Uvector basic operations
u32vector-drop-while: Uvector basic operations
u32vector-drop-while-right: Uvector basic operations
u32vector-empty?: Uvector basic operations
u32vector-every: Uvector basic operations
u32vector-fill!: Uvector basic operations
u32vector-filter: Uvector basic operations
u32vector-fold: Uvector basic operations
u32vector-for-each: Uvector basic operations
u32vector-index: Uvector basic operations
u32vector-index-right: Uvector basic operations
u32vector-ior: Uvector numeric operations
u32vector-ior!: Uvector numeric operations
u32vector-length: Uvector basic operations
u32vector-map: Uvector basic operations
u32vector-map!: Uvector basic operations
u32vector-mul: Uvector numeric operations
u32vector-mul!: Uvector numeric operations
u32vector-multi-copy!: Uvector basic operations
u32vector-partition: Uvector basic operations
u32vector-range-check: Uvector numeric operations
u32vector-ref: Uniform vectors
u32vector-remove: Uvector basic operations
u32vector-reverse!: Uvector basic operations
u32vector-reverse-copy: Uvector basic operations
u32vector-reverse-copy!: Uvector basic operations
u32vector-segment: Uvector basic operations
u32vector-set!: Uniform vectors
u32vector-skip: Uvector basic operations
u32vector-skip-right: Uvector basic operations
u32vector-sub: Uvector numeric operations
u32vector-sub!: Uvector numeric operations
u32vector-swap!: Uvector basic operations
u32vector-take: Uvector basic operations
u32vector-take-right: Uvector basic operations
u32vector-take-while: Uvector basic operations
u32vector-take-while-right: Uvector basic operations
u32vector-unfod-right!: Uvector basic operations
u32vector-unfold: Uvector basic operations
u32vector-unfold: Uvector basic operations
u32vector-unfold!: Uvector basic operations
u32vector-unfold!: Uvector basic operations
u32vector-unfold-right: Uvector basic operations
u32vector-unfold-right!: Uvector basic operations
u32vector-xor: Uvector numeric operations
u32vector-xor!: Uvector numeric operations
u32vector=: Uvector basic operations
u32vector=?: Uvector basic operations
u32vector?: Uniform vectors
u64?: Uvector basic operations
u64array: Arrays
u64ite-u8vector: Uvector block I/O
u64ke-u8vector-generator: Uvector basic operations
u64vector: Uvector basic operations
u64vector->list: Uvector conversion operations
u64vector->vector: Uvector conversion operations
u64vector-add: Uvector numeric operations
u64vector-add!: Uvector numeric operations
u64vector-and: Uvector numeric operations
u64vector-and!: Uvector numeric operations
u64vector-any: Uvector basic operations
u64vector-append: Uvector basic operations
u64vector-append-subvectors: Uvector basic operations
u64vector-clamp: Uvector numeric operations
u64vector-clamp!: Uvector numeric operations
u64vector-compare: Uvector basic operations
u64vector-concatenate: Uvector basic operations
u64vector-copy: Uvector basic operations
u64vector-copy!: Uvector basic operations
u64vector-count: Uvector basic operations
u64vector-cumulate: Uvector basic operations
u64vector-dot: Uvector numeric operations
u64vector-drop: Uvector basic operations
u64vector-drop-right: Uvector basic operations
u64vector-drop-while: Uvector basic operations
u64vector-drop-while-right: Uvector basic operations
u64vector-empty?: Uvector basic operations
u64vector-every: Uvector basic operations
u64vector-fill!: Uvector basic operations
u64vector-filter: Uvector basic operations
u64vector-fold: Uvector basic operations
u64vector-for-each: Uvector basic operations
u64vector-index: Uvector basic operations
u64vector-index-right: Uvector basic operations
u64vector-ior: Uvector numeric operations
u64vector-ior!: Uvector numeric operations
u64vector-length: Uvector basic operations
u64vector-map: Uvector basic operations
u64vector-map!: Uvector basic operations
u64vector-mul: Uvector numeric operations
u64vector-mul!: Uvector numeric operations
u64vector-multi-copy!: Uvector basic operations
u64vector-partition: Uvector basic operations
u64vector-range-check: Uvector numeric operations
u64vector-ref: Uniform vectors
u64vector-remove: Uvector basic operations
u64vector-reverse!: Uvector basic operations
u64vector-reverse-copy: Uvector basic operations
u64vector-reverse-copy!: Uvector basic operations
u64vector-segment: Uvector basic operations
u64vector-set!: Uniform vectors
u64vector-skip: Uvector basic operations
u64vector-skip-right: Uvector basic operations
u64vector-sub: Uvector numeric operations
u64vector-sub!: Uvector numeric operations
u64vector-swap!: Uvector basic operations
u64vector-take: Uvector basic operations
u64vector-take-right: Uvector basic operations
u64vector-take-while: Uvector basic operations
u64vector-take-while-right: Uvector basic operations
u64vector-unfod-right!: Uvector basic operations
u64vector-unfold: Uvector basic operations
u64vector-unfold: Uvector basic operations
u64vector-unfold!: Uvector basic operations
u64vector-unfold!: Uvector basic operations
u64vector-unfold-right: Uvector basic operations
u64vector-unfold-right!: Uvector basic operations
u64vector-xor: Uvector numeric operations
u64vector-xor!: Uvector numeric operations
u64vector=: Uvector basic operations
u64vector=?: Uvector basic operations
u64vector?: Uniform vectors
u8-list->blob: Octet-addressed binary blocks
u8-list->bytevector: Bytevector compatibility
u8-ready?: Reading data
u8?: Uvector basic operations
u8array: Arrays
u8vector: Uvector basic operations
u8vector->list: Uvector conversion operations
u8vector->string: Uniform vectors
u8vector->vector: Uvector conversion operations
u8vector-add: Uvector numeric operations
u8vector-add!: Uvector numeric operations
u8vector-and: Uvector numeric operations
u8vector-and!: Uvector numeric operations
u8vector-any: Uvector basic operations
u8vector-append: Uvector basic operations
u8vector-append-subvectors: Uvector basic operations
u8vector-clamp: Uvector numeric operations
u8vector-clamp!: Uvector numeric operations
u8vector-compare: Uvector basic operations
u8vector-concatenate: Uvector basic operations
u8vector-copy: Uvector basic operations
u8vector-copy!: Uvector basic operations
u8vector-copy!: Octet vectors
u8vector-count: Uvector basic operations
u8vector-cumulate: Uvector basic operations
u8vector-dot: Uvector numeric operations
u8vector-drop: Uvector basic operations
u8vector-drop-right: Uvector basic operations
u8vector-drop-while: Uvector basic operations
u8vector-drop-while-right: Uvector basic operations
u8vector-empty?: Uvector basic operations
u8vector-every: Uvector basic operations
u8vector-fill!: Uvector basic operations
u8vector-filter: Uvector basic operations
u8vector-fold: Uvector basic operations
u8vector-for-each: Uvector basic operations
u8vector-index: Uvector basic operations
u8vector-index-right: Uvector basic operations
u8vector-ior: Uvector numeric operations
u8vector-ior!: Uvector numeric operations
u8vector-length: Uvector basic operations
u8vector-map: Uvector basic operations
u8vector-map!: Uvector basic operations
u8vector-mul: Uvector numeric operations
u8vector-mul!: Uvector numeric operations
u8vector-multi-copy!: Uvector basic operations
u8vector-partition: Uvector basic operations
u8vector-range-check: Uvector numeric operations
u8vector-ref: Uniform vectors
u8vector-remove: Uvector basic operations
u8vector-reverse!: Uvector basic operations
u8vector-reverse-copy: Uvector basic operations
u8vector-reverse-copy!: Uvector basic operations
u8vector-segment: Uvector basic operations
u8vector-set!: Uniform vectors
u8vector-skip: Uvector basic operations
u8vector-skip-right: Uvector basic operations
u8vector-sub: Uvector numeric operations
u8vector-sub!: Uvector numeric operations
u8vector-swap!: Uvector basic operations
u8vector-take: Uvector basic operations
u8vector-take-right: Uvector basic operations
u8vector-take-while: Uvector basic operations
u8vector-take-while-right: Uvector basic operations
u8vector-unfod-right!: Uvector basic operations
u8vector-unfold: Uvector basic operations
u8vector-unfold: Uvector basic operations
u8vector-unfold!: Uvector basic operations
u8vector-unfold!: Uvector basic operations
u8vector-unfold-right: Uvector basic operations
u8vector-unfold-right!: Uvector basic operations
u8vector-xor: Uvector numeric operations
u8vector-xor!: Uvector numeric operations
u8vector=: Uvector basic operations
u8vector=?: Uvector basic operations
u8vector?: Uniform vectors
ucs->char: Characters
ucs-range->char-set: Character-set constructors
ucs-range->char-set!: Character-set constructors
ucs4->utf16: Unicode transfer encodings
ucs4->utf8: Unicode transfer encodings
uint-list->blob: Octet-addressed binary blocks
uint-list->bytevector: R7RS bytevectors
uint16s: Random data generators
uint16s$: Random data generators
uint32s: Random data generators
uint32s$: Random data generators
uint64s: Random data generators
uint64s$: Random data generators
uint8s: Random data generators
uint8s$: Random data generators
ulid->bytevector: Universally unique lexicographically sortable identifier
ulid->integer: Universally unique lexicographically sortable identifier
ulid->string: Universally unique lexicographically sortable identifier
ulid-hash: Universally unique lexicographically sortable identifier
ulid-randomness: Universally unique lexicographically sortable identifier
ulid-timestamp: Universally unique lexicographically sortable identifier
ulid<?: Universally unique lexicographically sortable identifier
ulid=?: Universally unique lexicographically sortable identifier
ulid?: Universally unique lexicographically sortable identifier
umask: POSIX API
unbox: Boxes
unbox-value: Boxes
uncaught-exception-condition?: Thread exceptions
uncaught-exception?: Thread exceptions
undefined: Undefined values
undefined?: Undefined values
unfold: R7RS lists
unfold-right: R7RS lists
unicode-terminal-width: R7RS combinator formatting
unify: Unification
unify-merge: Unification
unknown-encoding-error-name: Transcoded ports
unknown-encoding-error?: Transcoded ports
unless: Conditionals
unless: CiSE syntax
unless-procedure: Combinators (SRFI)
unpack: Packing binary data
unpack-skip: Packing binary data
unquote: Quasiquotation
unquote-splicing: Quasiquotation
unravel-syntax: Identifiers
until: Iteration
until: Iteration
until-procedure: Combinators (SRFI)
untrace-macro: Tracing macro expansion
untrace-macro: Tracing macro expansion
unwind-protect: High-level exception handling mechanism
unwrap-syntax: Identifiers
unzip1: R7RS lists
unzip2: R7RS lists
unzip3: R7RS lists
unzip4: R7RS lists
unzip5: R7RS lists
update!: Assignments
uri-compose: URI parsing and construction
uri-compose-data: URI parsing and construction
uri-decode: URI parsing and construction
uri-decode-string: URI parsing and construction
uri-decompose-authority: URI parsing and construction
uri-decompose-data: URI parsing and construction
uri-decompose-hierarchical: URI parsing and construction
uri-encode: URI parsing and construction
uri-encode-string: URI parsing and construction
uri-merge: URI parsing and construction
uri-parse: URI parsing and construction
uri-ref: URI parsing and construction
uri-scheme&specific: URI parsing and construction
use: Using modules
user-effecitve-gid: POSIX API
user-effective-uid: POSIX API
user-gid: POSIX API
user-info: POSIX API
user-info:full-name: POSIX API
user-info:gid: POSIX API
user-info:home-dir: POSIX API
user-info:name: POSIX API
user-info:parsed-full-name: POSIX API
user-info:shell: POSIX API
user-info:uid: POSIX API
user-info?: POSIX API
user-supplementary-gids: POSIX API
user-uid: POSIX API
utf-16-codec: Transcoded ports
utf-8-codec: Transcoded ports
utf16->string: Unicode transfer encodings
utf16->text: R7RS immutable texts
utf16->ucs4: Unicode transfer encodings
utf16-length: Unicode transfer encodings
utf16be->text: R7RS immutable texts
utf16le->text: R7RS immutable texts
utf32->string: Unicode transfer encodings
utf8->string: Unicode transfer encodings
utf8->text: R7RS immutable texts
utf8->ucs4: Unicode transfer encodings
utf8-length: Unicode transfer encodings
uuid->string: UUID
uuid-random-source: UUID
uuid-random-source-set!: UUID
uuid-value: UUID
uuid-version: UUID
uuid1: UUID
uuid4: UUID
uvector->generator: Generator constructors
uvector->list: Uvector conversion operations
uvector->vector: Uvector conversion operations
uvector-alias: Uvector conversion operations
uvector-binary-search: Uvector basic operations
uvector-class-element-size: Uvector basic operations
uvector-copy: Uvector basic operations
uvector-copy!: Uvector basic operations
uvector-length: Uniform vectors
uvector-range: Range
uvector-ref: Uniform vectors
uvector-set!: Uniform vectors
uvector-size: Uvector basic operations
uvector?: Uniform vectors

V
valid-sre?: R7RS regular expressions
valid-version-spec?: Comparing version numbers
value: Procedures and syntax for multiple values
value-procedure: Combinators (SRFI)
value/mv: Procedures and syntax for multiple values
values: Multiple values
values->either: Maybe and Either protocol converters
values->list: Multiple values
values->maybe: Maybe and Either protocol converters
values-ref: Multiple values
vector: Vectors
vector->@vector: Uvector conversion operations
vector->bits: R7RS bitwise operations
vector->bitvetor: Bitvector utilities
vector->c128vector: Uvector conversion operations
vector->c32vector: Uvector conversion operations
vector->c64vector: Uvector conversion operations
vector->f16vector: Uvector conversion operations
vector->f32vector: Uvector conversion operations
vector->f64vector: Uvector conversion operations
vector->generator: Generator constructors
vector->list: Vectors
vector->range: Range
vector->s16vector: Uvector conversion operations
vector->s32vector: Uvector conversion operations
vector->s64vector: Uvector conversion operations
vector->s8vector: Uvector conversion operations
vector->string: Vectors
vector->text: R7RS immutable texts
vector->u16vector: Uvector conversion operations
vector->u32vector: Uvector conversion operations
vector->u64vector: Uvector conversion operations
vector->u8vector: Uvector conversion operations
vector-accumulator: R7RS generators
vector-accumulator!: R7RS generators
vector-any: R7RS vectors
vector-append: Vectors
vector-append-subvectors: R7RS vectors
vector-binary-search: R7RS vectors
vector-concatenate: R7RS vectors
vector-copy: Vectors
vector-copy!: Vectors
vector-count: R7RS vectors
vector-count: Vector library (Legacy)
vector-cumulate: R7RS vectors
vector-delete-neighbor-dups: R7RS sort
vector-delete-neighbor-dups!: R7RS sort
vector-ec: Eager comprehensions
vector-empty?: R7RS vectors
vector-every: R7RS vectors
vector-fill!: Vectors
vector-find-median: R7RS sort
vector-find-median!: R7RS sort
vector-fold: R7RS vectors
vector-fold: Vector library (Legacy)
vector-fold-right: R7RS vectors
vector-fold-right: Vector library (Legacy)
vector-for-each: Vectors
vector-for-each: Vector library (Legacy)
vector-for-each-with-index: Vectors
vector-index: R7RS vectors
vector-index-right: R7RS vectors
vector-length: Vectors
vector-map: Vectors
vector-map: Vector library (Legacy)
vector-map!: Vectors
vector-map!: Vector library (Legacy)
vector-map-with-index: Vectors
vector-map-with-index!: Vectors
vector-merge: R7RS sort
vector-merge!: R7RS sort
vector-of-length-ec: Eager comprehensions
vector-partition: R7RS vectors
vector-range: Range
vector-ref: Vectors
vector-reverse!: R7RS vectors
vector-reverse-copy: R7RS vectors
vector-reverse-copy!: R7RS vectors
vector-select!: R7RS sort
vector-separate!: R7RS sort
vector-set!: Vectors
vector-skip: R7RS vectors
vector-skip-right: R7RS vectors
vector-sort: R7RS sort
vector-sort!: R7RS sort
vector-sorted?: R7RS sort
vector-stable-sort: R7RS sort
vector-stable-sort!: R7RS sort
vector-swap!: R7RS vectors
vector-tabulate: Vectors
vector-unfold: R7RS vectors
vector-unfold!: R7RS vectors
vector-unfold-right: R7RS vectors
vector-unfold-right!: R7RS vectors
vector-values: Procedures and syntax for multiple values
vector/mv: Procedures and syntax for multiple values
vector=: R7RS vectors
vector?: Vectors
vectors-of: Random data generators
vectors-of: Random data generators
version-alist: Environment inquiry
version-compare: Comparing version numbers
version-satisfy?: Comparing version numbers
version<=?: Comparing version numbers
version<?: Comparing version numbers
version=?: Comparing version numbers
version>=?: Comparing version numbers
version>?: Comparing version numbers
vt100-compatible?: Text terminal control

W
wait-all: Thread pools
weak-vector-length: Weak vectors
weak-vector-ref: Weak vectors
weak-vector-set!: Weak vectors
weighted-samples-from: Random data generators
when: Conditionals
when: CiSE syntax
when: Stub generation
when-procedure: Combinators (SRFI)
while: Iteration
while: Iteration
while: Iteration
while: CiSE syntax
while-procedure: Combinators (SRFI)
with: R7RS combinator formatting
with!: R7RS combinator formatting
with-builder: Fundamental iterator creators
with-cf-subst: Configure API
with-character-attribute: Text terminal control
with-continuation-mark: Continuation marks
with-continuation-mark: Continuation marks
with-dynamic-extent: First-class dynamic extents
with-error-handler: High-level exception handling mechanism
with-error-to-port: Common port operations
with-exception-handler: Low-level exception handling mechanism
with-input-conversion: Conversion ports
with-input-from-file: Opening file ports
with-input-from-port: Common port operations
with-input-from-process: Process ports
with-input-from-string: String ports
with-iterator: Fundamental iterator creators
with-lock-file: Lock files
with-locking-mutex: Mutex
with-module: Defining and selecting modules
with-output-conversion: Conversion ports
with-output-to-file: Opening file ports
with-output-to-pager: Display with pager
with-output-to-port: Common port operations
with-output-to-process: Process ports
with-output-to-string: String ports
with-port-locking: Port and threads
with-ports: Common port operations
with-profiler: Profiler API
with-random-source: Random data generators (SRFI)
with-signal-handlers: Handling signals
with-string-io: String ports
with-time-counter: Measure timings
with-values: Procedures and syntax for multiple values
without-echoing: Common high-level terminal control
wrap-with-input-conversion: Conversion ports
wrap-with-output-conversion: Conversion ports
wrapped: R7RS combinator formatting
wrapped-identifier?: Identifiers
wrapped/char: R7RS combinator formatting
wrapped/list: R7RS combinator formatting
write: Object output
write*: Object output
write-@vector: Uvector block I/O
write-ber-integer: Binary I/O
write-binary-bitestring: String-notated bytevectors
write-block: Uvector block I/O
write-byte: Low-level output
write-bytevector: Uvector block I/O
write-char: Low-level output
write-controls-copy: Output controls
write-f16: Binary I/O
write-f32: Binary I/O
write-f64: Binary I/O
write-gauche-package-description: Package metainformation
write-object: Object output
write-s16: Binary I/O
write-s32: Binary I/O
write-s64: Binary I/O
write-s8: Binary I/O
write-shared: Object output
write-simple: Object output
write-sint: Binary I/O
write-stream: Stream operations
write-string: Low-level output
write-textual-bytestring: String-notated bytevectors
write-to-string: String ports
write-tree: Lazy text construction
write-tree: Lazy text construction
write-tree: Lazy text construction
write-u16: Binary I/O
write-u32: Binary I/O
write-u64: Binary I/O
write-u8: Low-level output
write-u8: Binary I/O
write-u8vector: Uvector block I/O
write-uint: Binary I/O
write-uuid: UUID
write-uvector: Uvector block I/O
write-with-shared-structure: Object output
write/ss: Object output
written: R7RS combinator formatting
written-simply: R7RS combinator formatting

X
x->generator: Generator constructors
x->integer: Numerical conversions
x->lseq: Lazy sequence constructors
x->number: Numerical conversions
x->string: String constructors
xcons: R7RS lists
xml-token-head: SSAX data types
xml-token-kind: SSAX data types
xml-token?: SSAX data types
xsubstring: SRFI-13 String rotation

Z
zero?: Numerical predicates
zip: R7RS lists
zlib-version: Zlib compression library
zstream-adler32: Zlib compression library
zstream-data-type: Zlib compression library
zstream-dictionary-adler32: Zlib compression library
zstream-params-set!: Zlib compression library
zstream-total-in: Zlib compression library
zstream-total-out: Zlib compression library

Jump to:   !   $   %   &   (   *   +   -   .   /   :   <   =   >   ?   @   ^   ~  
A   B   C   D   E   F   G   H   I   J   K   L   M   N   O   P   Q   R   S   T   U   V   W   X   Z  

Next: , Previous: , Up: Top   [Contents][Index]


For Gauche 0.9.14Search (procedure/syntax/module):