For Development HEAD DRAFTSearch (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
$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
$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
%macroexpand: Expanding macros manually
%macroexpand-1: Expanding macros manually

&
&: 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 random-data-seed): Random data generators
(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-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-div: Uvector numeric operations
@vector-div!: Uvector numeric operations
@vector-dot: Uvector numeric operations
@vector-empty?: Uvector basic operations
@vector-fill!: Uvector basic operations
@vector-ior: Uvector numeric operations
@vector-ior!: Uvector numeric operations
@vector-length: Uvector basic operations
@vector-mul: Uvector numeric operations
@vector-mul!: Uvector numeric operations
@vector-multi-copy!: Uvector basic operations
@vector-range-check: Uvector numeric operations
@vector-ref: Uniform vectors
@vector-reverse-copy: Uvector basic operations
@vector-set!: Uniform vectors
@vector-sub: Uvector numeric operations
@vector-sub!: Uvector numeric operations
@vector-swap!: Uvector basic operations
@vector-unfold: 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
abs: Arithmetics
absolute-path?: Pathname utilities
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-job!: Thread pools
add-load-path: Loading Scheme file
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->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
allocate-instance: Creating instance
allocate-instance: Creating instance
and: Conditionals
and: CiSE syntax
and: Eager comprehensions
and-let*: Binding constructs
and-let1: Binding constructs
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-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-generic: Customizing method application
apply-method: Customizing method application
apply-methods: Customizing method application
approx=?: Numerical comparison
apropos: Interactive session
aref: CiSE syntax
args-fold: A program argument processor
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
base64-decode: Base64 encoding/decoding
base64-decode-string: Base64 encoding/decoding
base64-encode: Base64 encoding/decoding
base64-encode-string: Base64 encoding/decoding
bcrypt-gensalt: Password hashing
bcrypt-hashpw: Password hashing
beep: Text terminal control
begin: Sequencing
begin: CiSE syntax
begin: Stub generation
begin: Eager comprehensions
begin0: Sequencing
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
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->integer: Bitvector library
bitvector->list/bool: Bitvector library
bitvector->list/int: Bitvector library
bitvector->string: Bitvectors
bitvector->vector/bool: Bitvector library
bitvector->vector/int: Bitvector library
bitvector-and: Bitvector library
bitvector-and!: Bitvector library
bitvector-andc1: Bitvector library
bitvector-andc1!: Bitvector library
bitvector-andc2: Bitvector library
bitvector-andc2!: Bitvector library
bitvector-append: Bitvector library
bitvector-append-subbitvectors: Bitvector library
bitvector-concatenate: Bitvector library
bitvector-copy: Bitvectors
bitvector-copy!: Bitvectors
bitvector-count: Bitvector library
bitvector-count-run: Bitvector library
bitvector-drop: Bitvector library
bitvector-drop-right: Bitvector library
bitvector-emtpy?: Bitvector library
bitvector-eqv: Bitvector library
bitvector-eqv!: Bitvector library
bitvector-field-any?: Bitvector library
bitvector-field-clear: Bitvector library
bitvector-field-clear!: Bitvector library
bitvector-field-every?: Bitvector library
bitvector-field-flip: Bitvector library
bitvector-field-flip!: Bitvector library
bitvector-field-replace: Bitvector library
bitvector-field-replace!: Bitvector library
bitvector-field-replace-same: Bitvector library
bitvector-field-replace-same!: Bitvector library
bitvector-field-rotate: Bitvector library
bitvector-field-set: Bitvector library
bitvector-field-set!: Bitvector library
bitvector-first-bit: Bitvector library
bitvector-fold-right/bool: Bitvector library
bitvector-fold-right/int: Bitvector library
bitvector-fold/bool: Bitvector library
bitvector-fold/int: Bitvector library
bitvector-for-reach/bool: Bitvector library
bitvector-for-reach/int: Bitvector library
bitvector-if: Bitvector library
bitvector-ior: Bitvector library
bitvector-ior!: Bitvector library
bitvector-logical-shift: Bitvector library
bitvector-map!/bool: Bitvector library
bitvector-map!/int: Bitvector library
bitvector-map->list/bool: Bitvector library
bitvector-map->list/int: Bitvector library
bitvector-map/bool: Bitvector library
bitvector-map/int: Bitvector library
bitvector-nand: Bitvector library
bitvector-nand!: Bitvector library
bitvector-nor: Bitvector library
bitvector-nor!: Bitvector library
bitvector-not: Bitvector library
bitvector-not!: Bitvector library
bitvector-orc1: Bitvector library
bitvector-orc1!: Bitvector library
bitvector-orc2: Bitvector library
bitvector-orc2!: Bitvector library
bitvector-pad: Bitvector library
bitvector-pad-right: Bitvector library
bitvector-prefix-length: Bitvector library
bitvector-prefix?: Bitvector library
bitvector-ref/bool: Bitvectors
bitvector-ref/int: Bitvectors
bitvector-reverse!: Bitvector library
bitvector-reverse-copy: Bitvector library
bitvector-reverse-copy!: Bitvector library
bitvector-segment: Bitvector library
bitvector-set!: Bitvectors
bitvector-suffix-length: Bitvector library
bitvector-suffix?: Bitvector library
bitvector-swap!: Bitvector library
bitvector-take: Bitvector library
bitvector-take-right: Bitvector library
bitvector-trim: Bitvector library
bitvector-trim-both: Bitvector library
bitvector-trim-right: Bitvector library
bitvector-unfold: Bitvector library
bitvector-unfold-right: Bitvector library
bitvector-xor: Bitvector library
bitvector-xor!: Bitvector library
bitvector=?: Bitvector library
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->integer: Integers as bits
box: Boxes
box-arity: Boxes
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
bytevector: Bytevector compatibility
bytevector->generator: Generator constructors
bytevector->sint-list: R7RS bytevectors
bytevector->string: Custom ports
bytevector->u8-list: Bytevector compatibility
bytevector->uint-list: R7RS bytevectors
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

C
c128?: 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-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-div: Uvector numeric operations
c128vector-div!: Uvector numeric operations
c128vector-dot: Uvector numeric operations
c128vector-empty?: Uvector basic operations
c128vector-fill!: Uvector basic operations
c128vector-length: Uvector basic operations
c128vector-mul: Uvector numeric operations
c128vector-mul!: Uvector numeric operations
c128vector-multi-copy!: Uvector basic operations
c128vector-ref: Uniform vectors
c128vector-reverse-copy: Uvector basic operations
c128vector-set!: Uniform vectors
c128vector-sub: Uvector numeric operations
c128vector-sub!: Uvector numeric operations
c128vector-swap!: Uvector basic operations
c128vector-unfold: Uvector basic operations
c128vector-unfold-right: Uvector basic operations
c128vector=: Uvector basic operations
c128vector=?: Uvector basic operations
c128vector?: Uniform vectors
c32?: 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-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-div: Uvector numeric operations
c32vector-div!: Uvector numeric operations
c32vector-dot: Uvector numeric operations
c32vector-empty?: Uvector basic operations
c32vector-fill!: Uvector basic operations
c32vector-length: Uvector basic operations
c32vector-mul: Uvector numeric operations
c32vector-mul!: Uvector numeric operations
c32vector-multi-copy!: Uvector basic operations
c32vector-ref: Uniform vectors
c32vector-reverse-copy: Uvector basic operations
c32vector-set!: Uniform vectors
c32vector-sub: Uvector numeric operations
c32vector-sub!: Uvector numeric operations
c32vector-swap!: Uvector basic operations
c32vector-unfold: Uvector basic operations
c32vector-unfold-right: Uvector basic operations
c32vector=: Uvector basic operations
c32vector=?: Uvector basic operations
c32vector?: Uniform vectors
c64?: 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-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-div: Uvector numeric operations
c64vector-div!: Uvector numeric operations
c64vector-dot: Uvector numeric operations
c64vector-empty?: Uvector basic operations
c64vector-fill!: Uvector basic operations
c64vector-length: Uvector basic operations
c64vector-mul: Uvector numeric operations
c64vector-mul!: Uvector numeric operations
c64vector-multi-copy!: Uvector basic operations
c64vector-ref: Uniform vectors
c64vector-reverse-copy: Uvector basic operations
c64vector-set!: Uniform vectors
c64vector-sub: Uvector numeric operations
c64vector-sub!: Uvector numeric operations
c64vector-swap!: Uvector basic operations
c64vector-unfold: 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-current-continuation: Continuations
call-with-ftp-connection: FTP
call-with-input-conversion: Conversion ports
call-with-input-file: 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: File ports
call-with-output-process: Process ports
call-with-output-string: String ports
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/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/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-titlecase: Characters
char-upcase: Characters
char-upper-case?: Characters
char-whitespace?: 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
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
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
compose: Combinators
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
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
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
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
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-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-second: R7RS time
current-thread: Thread procedures
current-time: Time
current-time: SRFI-19 Time queries
current-trace-port: Common port operations
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-label: Debugging aid
debug-print: 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-endian: Endianness
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-cvar: CiSE syntax
define-cvar: Stub generation
define-dict-interface: Generic functions for dictionaries
define-enum: Stub generation
define-enum-conditionally: Stub generation
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-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-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-string: 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
display: Object output
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
eager: Delay force and lazy
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
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
errorf: Signaling exceptions
errorf: Signaling exceptions
escaped: R7RS combinator formatting
euclidean-quotient: R7RS integer division
euclidean-remainder: R7RS integer division
euclidean/: R7RS integer division
eval: Eval and repl
eval: R7RS eval
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
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
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-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-div: Uvector numeric operations
f16vector-div!: Uvector numeric operations
f16vector-dot: Uvector numeric operations
f16vector-empty?: Uvector basic operations
f16vector-fill!: Uvector basic operations
f16vector-length: Uvector basic operations
f16vector-mul: Uvector numeric operations
f16vector-mul!: Uvector numeric operations
f16vector-multi-copy!: Uvector basic operations
f16vector-range-check: Uvector numeric operations
f16vector-ref: Uniform vectors
f16vector-reverse-copy: Uvector basic operations
f16vector-set!: Uniform vectors
f16vector-sub: Uvector numeric operations
f16vector-sub!: Uvector numeric operations
f16vector-swap!: Uvector basic operations
f16vector-unfold: 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
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-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-div: Uvector numeric operations
f32vector-div!: Uvector numeric operations
f32vector-dot: Uvector numeric operations
f32vector-empty?: Uvector basic operations
f32vector-fill!: Uvector basic operations
f32vector-length: Uvector basic operations
f32vector-mul: Uvector numeric operations
f32vector-mul!: Uvector numeric operations
f32vector-multi-copy!: Uvector basic operations
f32vector-range-check: Uvector numeric operations
f32vector-ref: Uniform vectors
f32vector-reverse-copy: Uvector basic operations
f32vector-set!: Uniform vectors
f32vector-sub: Uvector numeric operations
f32vector-sub!: Uvector numeric operations
f32vector-swap!: Uvector basic operations
f32vector-unfold: 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
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-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-div: Uvector numeric operations
f64vector-div!: Uvector numeric operations
f64vector-dot: Uvector numeric operations
f64vector-empty?: Uvector basic operations
f64vector-fill!: Uvector basic operations
f64vector-length: Uvector basic operations
f64vector-mul: Uvector numeric operations
f64vector-mul!: Uvector numeric operations
f64vector-multi-copy!: Uvector basic operations
f64vector-range-check: Uvector numeric operations
f64vector-ref: Uniform vectors
f64vector-reverse-copy: Uvector basic operations
f64vector-set!: Uniform vectors
f64vector-sub: Uvector numeric operations
f64vector-sub!: Uvector numeric operations
f64vector-swap!: Uvector basic operations
f64vector-unfold: 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
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
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: Formatting output
format: Formatting output
format: Formatting output
format: Formatting output
format: Localization
fourth: R7RS lists
free-identifier=?: Identifiers
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
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-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-move!: Gap buffer
gap-buffer-pos: 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-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
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
hide-cursor: Text terminal control
hmac-digest: HMAC keyed-hashing
hmac-digest-string: HMAC keyed-hashing
hmac-final!: HMAC keyed-hashing
hmac-update!: 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
http-compose-query: HTTP
http-default-redirect-handler: HTTP
http-delete: HTTP
http-get: HTTP
http-head: HTTP
http-post: HTTP
http-proxy: HTTP
http-put: HTTP
http-secure-connection-available?: HTTP
http-status-code->description: HTTP
http-user-agent: HTTP

I
i/o-decoding-error?: Custom ports
i/o-encoding-error-char: Custom ports
i/o-encoding-error?: Custom 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-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-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
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-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
int32s: Random data generators
int64s: Random data generators
int8s: Random data generators
integer->bitvector: Bitvector library
integer->char: Characters
integer->digit: Characters
integer->list: Integers as bits
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
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
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: Custom ports
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?: 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 argument parsing
let-optionals*: Optional argument parsing
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->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-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=: 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
logtest: Basic bitwise operations
logxor: Basic bitwise operations
logxor: CiSE syntax
logxor=: CiSE syntax
loop: CiSE syntax
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: Uvector basic operations
make-accumulator: R7RS generators
make-array: Arrays
make-barrier: Barrier
make-bimap: Generic dictionaries
make-binary-heap: Heap
make-bitvector: Bitvectors
make-bitvector-accumulator: Bitvector library
make-bitvector/bool-generator: Bitvector library
make-bitvector/int-generator: Bitvector library
make-bitwise-generator: R7RS bitwise operations
make-blob: Octet-addressed binary blocks
make-byte-string: String constructors
make-bytevector: Bytevector compatibility
make-bytevector-comparator: Comparators
make-c128vector: Uvector basic operations
make-c32vector: Uvector basic operations
make-c64vector: Uvector basic operations
make-car-comparator: Comparators
make-cdr-comparator: Comparators
make-client-socket: High-level network functions
make-client-socket: Basic socket interface
make-codec: Custom 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-condition: Conditions
make-condition: Conditions
make-condition-type: Conditions
make-condition-variable: Condition variable
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: Custom ports
make-custom-binary-input/output-port: Custom ports
make-custom-binary-output-port: Custom ports
make-custom-textual-input-port: Custom ports
make-custom-textual-output-port: 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-empty-attlist: SSAX data types
make-ephemeron: R7RS ephemerons
make-eq-comparator: Combining comparators
make-eqv-comparator: Combining comparators
make-f16array: Arrays
make-f16vector: Uvector basic operations
make-f32array: Arrays
make-f32vector: Uvector basic operations
make-f64array: Arrays
make-f64vector: Uvector basic operations
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-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-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-iota-generator: Generator constructors
make-key-comparator: Combining comparators
make-keyword: Keywords
make-kmp-restart-vector: SRFI-13 Low-level string procedures
make-latch: Latch
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-module: Module introspection
make-mtqueue: Queue
make-mutex: Mutex
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-polar: Numerical conversions
make-pool-mapper: Parallel map
make-priority-map: Priority map
make-process-connection: Process connection
make-promise: R7RS lazy evaluation
make-queue: Queue
make-random-source: Sources of random bits
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: Uvector basic operations
make-s32array: Arrays
make-s32vector: Uvector basic operations
make-s64array: Arrays
make-s64vector: Uvector basic operations
make-s8array: Arrays
make-s8vector: Uvector basic operations
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-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-stacked-map: Generic dictionaries
make-stacked-map: Generic dictionaries
make-static-mapper: Parallel map
make-stream: Stream constructors
make-string: String constructors
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-pool: Thread pools
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: Custom 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: Uvector basic operations
make-u32array: Arrays
make-u32vector: Uvector basic operations
make-u64array: Arrays
make-u64vector: Uvector basic operations
make-u8array: Arrays
make-u8vector: Uvector basic operations
make-unfold-generator: Generator constructors
make-uvector: Uvector basic operations
make-vector: Vectors
make-vector-comparator: Comparators
make-vectorwise-comparator: Comparators
make-weak-vector: Weak vectors
make-word-breaker: Unicode text segmentation
make-word-reader: Unicode text segmentation
make-write-controls: Output controls
make-xml-token: SSAX data types
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-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-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-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-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: Custom ports
native-transcoder: Custom 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?: Numerical predicates
nest: Pipeline operators
nest-reverse: Pipeline operators
nested: Eager comprehensions
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
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
open-binary-input-file: R7RS file library
open-binary-output-file: R7RS file library
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-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 ports
open-input-file: File ports
open-input-process-port: Process ports
open-input-string: String ports
open-input-uvector: Virtual 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 ports
open-output-file: File ports
open-output-process-port: Process ports
open-output-string: String ports
open-output-uvector: Virtual ports
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
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
parameter-observer-add!: Parameters (extra)
parameter-observer-delete!: Parameters (extra)
parameter-post-observers: Parameters (extra)
parameter-pre-observers: Parameters (extra)
parameter?: Parameters
parameterize: 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
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 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-map: Input utility functions
port-name: Common port operations
port-position: Common port operations
port-seek: Common port operations
port-tell: Common port operations
port-type: 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?: 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
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-encode: 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-access-list->linear-access-list: R7RS random-access lists
random-data-seed: Random data generators
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-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-part: Numerical conversions
real-path: POSIX API
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
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
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 library
reverse-bitvector->list/int: Bitvector library
reverse-bitvector->vector/bool: Bitvector library
reverse-list->@vector: Uvector conversion operations
reverse-list->bitvector: Bitvector library
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 library
reverse-vector->generator: Generator constructors
reverse-vector->list: R7RS vectors
reverse-vector-accumulator: R7RS generators
revrese-bitvector->vector/int: Bitvector library
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?: 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-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-pipeline: Running process pipeline
run-process: Running subprocess
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
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-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-dot: Uvector numeric operations
s16vector-empty?: Uvector basic operations
s16vector-fill!: Uvector basic operations
s16vector-ior: Uvector numeric operations
s16vector-ior!: Uvector numeric operations
s16vector-length: Uvector basic operations
s16vector-mul: Uvector numeric operations
s16vector-mul!: Uvector numeric operations
s16vector-multi-copy!: Uvector basic operations
s16vector-range-check: Uvector numeric operations
s16vector-ref: Uniform vectors
s16vector-reverse-copy: Uvector basic operations
s16vector-set!: Uniform vectors
s16vector-sub: Uvector numeric operations
s16vector-sub!: Uvector numeric operations
s16vector-swap!: Uvector basic operations
s16vector-unfold: 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
s32vector: Uvector basic operations
s32vector->list: Uvector conversion operations
s32vector->string: Uvector conversion operations
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-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-dot: Uvector numeric operations
s32vector-empty?: Uvector basic operations
s32vector-fill!: Uvector basic operations
s32vector-ior: Uvector numeric operations
s32vector-ior!: Uvector numeric operations
s32vector-length: Uvector basic operations
s32vector-mul: Uvector numeric operations
s32vector-mul!: Uvector numeric operations
s32vector-multi-copy!: Uvector basic operations
s32vector-range-check: Uvector numeric operations
s32vector-ref: Uniform vectors
s32vector-reverse-copy: Uvector basic operations
s32vector-set!: Uniform vectors
s32vector-sub: Uvector numeric operations
s32vector-sub!: Uvector numeric operations
s32vector-swap!: Uvector basic operations
s32vector-unfold: 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
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-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-dot: Uvector numeric operations
s64vector-empty?: Uvector basic operations
s64vector-fill!: Uvector bas