For Gauche 0.9.9

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

Appendix C 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

%: 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
: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
: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: Uvector basic operations
@vector-reverse-copy: Uvector basic operations
@vector-set!: Uvector basic operations
@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?: Uvector basic operations

^: 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

abandoned-mutex-exception?: Thread exceptions
abs: Arithmetics
absolute-path?: Pathname utilities
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-nodeset: SXPath basic converters and applicators
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: Synchronization primitives
atom-ref: Synchronization primitives
atom?: Synchronization primitives
atomic: Synchronization primitives
atomic-update!: Synchronization primitives
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

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
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-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
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: R7RS boxes
box?: R7RS 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-accumulator: R7RS generators
bytevector-accumulator!: R7RS generators
bytevector-append: Bytevector compatibility
bytevector-copy: Bytevector compatibility
bytevector-copy!: Bytevector compatibility
bytevector-length: Bytevector compatibility
bytevector-u8-ref: Bytevector compatibility
bytevector-u8-set!: Bytevector compatibility
bytevector=?: Bytevector compatibility
bytevector?: Bytevector compatibility

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: Uvector basic operations
c128vector-reverse-copy: Uvector basic operations
c128vector-set!: Uvector basic operations
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?: Uvector basic operations
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: Uvector basic operations
c32vector-reverse-copy: Uvector basic operations
c32vector-set!: Uvector basic operations
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?: Uvector basic operations
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: Uvector basic operations
c64vector-reverse-copy: Uvector basic operations
c64vector-set!: Uvector basic operations
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?: Uvector basic operations
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-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-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-define: Configure API
cf-echo: Configure API
cf-feature-ref: Configure API
cf-have-subst?: 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-make-gpd: 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
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
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
char-set: Character set
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
char-set-complement!: Character set
char-set-contains?: Character set
char-set-copy: Character set
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
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
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
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-directory-tree: Directory utilities
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: Types and classes
class-post-initialize: Class instantiation
class-precedence-list: Class object
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-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
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-line: Command-line arguments
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-ref: Conditions
condition-type?: Conditions
condition-variable-broadcast!: Synchronization primitives
condition-variable-name: Synchronization primitives
condition-variable-signal!: Synchronization primitives
condition-variable-specific: Synchronization primitives
condition-variable-specific-set!: Synchronization primitives
condition-variable?: Synchronization primitives
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
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
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*: Directory utilities
create-directory-tree: Directory utilities
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: Handling exceptions
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
cursor-down/scroll-up: Text terminal control
cursor-up/scroll-down: Text terminal control
cut: Making procedures
cute: Making procedures

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-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-generic: Generic function and method
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
delay: Delay force and lazy
delay-force: R7RS lazy evaluation
delete: Walking over lists
delete!: Walking over lists
delete$: Combinators
delete-directory*: Directory utilities
delete-duplicates: Walking over lists
delete-duplicates!: Walking over lists
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
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-fold: Directory utilities
directory-list: Directory utilities
directory-list2: Directory utilities
disasm: Debugging aid
display: Object output
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-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

eager: Delay force and lazy
ecase: Conditionals
ed: Interactive session
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
emergency-exit: R7RS process context
encode-float: Numerical conversions
end-of-char-set?: Character-set iteration
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
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
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
extract-condition: Conditions

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: Uvector basic operations
f16vector-reverse-copy: Uvector basic operations
f16vector-set!: Uvector basic operations
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?: Uvector basic operations
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: Uvector basic operations
f32vector-reverse-copy: Uvector basic operations
f32vector-set!: Uvector basic operations
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?: Uvector basic operations
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: Uvector basic operations
f64vector-reverse-copy: Uvector basic operations
f64vector-set!: Uvector basic operations
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?: Uvector basic operations
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-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-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
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
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
format: Formatting output
format: Formatting output
format: Formatting output
format: Formatting output
format: Formatting output
format: Localization
fourth: R7RS lists
frexp: Numerical conversions
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
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

gamma: Arithmetics
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
gcombine: Generator operations
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
generator: Generator constructors
generator->bytevector: Generator consumers
generator->bytevector!: Generator consumers
generator->ideque: R7RS immutable deques
generator->list: Generator consumers
generator->lseq: Lazy sequences
generator->lseq: Lazy sequences
generator->reverse-list: Generator consumers
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
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: R7RS base library
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
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-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: Handling exceptions
gunfold: Generator constructors
gzip-decode-string: Zlib compression library
gzip-encode-string: Zlib compression library

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-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

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
identifier->symbol: Identifiers
identifier?: Identifiers
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
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
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
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?: Numerical predicates
infinite?: Numerical predicates
inflate-string: Zlib compression library
inflate-sync: Zlib compression library
info: Interactive session
info-search: Interactive session
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
int16s: Random data generators
int32s: Random data generators
int64s: Random data generators
int8s: Random data generators
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
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
is-a?: Types and classes
isomorphic?: Determine isomorphism
iterator->stream: Stream constructors

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
json-array-handler: JSON parsing and construction
json-object-handler: JSON parsing and construction
json-special-handler: JSON parsing and construction
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

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

l-distance: Levenshtein edit distance
l-distances: Levenshtein edit distance
label: CiSE syntax
lambda: Making procedures
lappend: Lazy sequence utilities
lappend-map: Lazy sequence utilities
last: List accessors and modifiers
last-ec: Eager comprehensions
last-pair: List accessors and modifiers
lazy: Delay force and lazy
lazy-size-of: Miscellaneous operations on collection
lcm: Arithmetics
lconcatenate: Lazy sequence utilities
lcons: Lazy sequences
lcons*: Lazy sequences
lcs: The longest common subsequence
lcs-edit-list: The longest common subsequence
lcs-fold: The longest common subsequence
lcs-with-positions: The longest common subsequence
ldexp: Numerical conversions
least-fixnum: Arithmetics
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 utilities
lfilter-map: Lazy sequence utilities
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
linterweave: Lazy sequence utilities
liota: Lazy sequences
list: List constructors
list*: List constructors
list->@vector: Uvector conversion operations
list->bag: R7RS sets
list->bag!: R7RS sets
list->bits: R7RS bitwise operations
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->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->queue: Queue
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->stream: Stream constructors
list->string: String utilities
list->sys-fdset: I/O multiplexing
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-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=: R7RS lists
list?: List predicates
listener-read-handler: Listener
listener-show-prompt: Listener
lists-of: Random data generators
lists-of: Random data generators
llist*: Lazy sequences
lmap: Lazy sequence utilities
lmap-accum: Lazy sequence utilities
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 utilities
lseq->generator: R7RS lazy sequences
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-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 utilities
lstate-filter: Lazy sequence utilities
ltake: Lazy sequence utilities
ltake-while: Lazy sequence utilities
lunfold: Lazy sequence utilities

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-bimap: Generic dictionaries
make-binary-heap: Heap
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-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: Synchronization primitives
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-date: SRFI-19 Date
make-debug-comparator: Comparators
make-default-comparator: Combining comparators
make-default-console: Text terminal control
make-directory*: Directory utilities
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-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-ideque: Immutable deques
make-imap: Immutable map
make-imap: Immutable map
make-imap: Immutable map
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-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: Synchronization primitives
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-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-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-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-stream: Stream constructors
make-string: String Constructors
make-template-environment: Simple template expander
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-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 pointers
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
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
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!: Synchronization primitives
mutex-locker: Synchronization primitives
mutex-name: Synchronization primitives
mutex-specific: Synchronization primitives
mutex-specific-set!: Synchronization primitives
mutex-state: Synchronization primitives
mutex-unlock!: Synchronization primitives
mutex-unlocker: Synchronization primitives
mutex?: Synchronization primitives

naive-factorize: Prime numbers
nan?: Numerical predicates
native-endian: Endianness
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
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
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-pair?: R7RS lists
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-list?: List predicates
null?: List predicates
number->string: Numerical conversions
number-hash: Hashing
number?: Numerical predicates
numerator: Arithmetics

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
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-inflating-port: Zlib compression library
open-input-byte-generator: Virtual ports
open-input-byte-list: Virtual ports
open-input-bytevector: R7RS base library
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-bytevector: R7RS base library
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

pa$: Combinators
pack: Packing binary data
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
parameter-observer-add!: Parameters
parameter-observer-delete!: Parameters
parameter-post-observers: Parameters
parameter-pre-observers: 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
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: R7RS base library
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
pop!: Assignments
port->byte-generator: Generator constructors
port->byte-lseq: Lazy sequences
port->char-generator: Generator constructors
port->char-lseq: Lazy sequences
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-map: Input utility functions
port-name: 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
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
primes: Prime numbers
print: Object output
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-stop: Process object
process-upstreams: Process object
process-wait: Process object
process-wait-any: 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-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

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

raise: Signaling exceptions
raise: R7RS base library
raise-continuable: R7RS base library
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
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
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: R7RS base library
read-bytevector!: R7RS base library
read-char: Reading data
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-u16: Binary I/O
read-u32: Binary I/O
read-u64: Binary I/O
read-u8: R7RS base library
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-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: R7RS regular expressions
regexp->string: Using regular expressions
regexp-ast: Inspecting and assembling regular expressions
regexp-compile: Inspecting and assembling regular expressions
regexp-compile-sre: 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
report-error: Handling exceptions
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
reverse: Other list procedures
reverse!: Other list procedures
reverse-bit-field: Integers as bits
reverse-bits->generator: Generator constructors
reverse-list->@vector: Uvector conversion operations
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->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->generator: Generator constructors
reverse-vector->list: R7RS vectors
reverse-vector-accumulator: R7RS generators
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
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
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

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: Uvector basic operations
s16vector-reverse-copy: Uvector basic operations
s16vector-set!: Uvector basic operations
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?: Uvector basic operations
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: Uvector basic operations
s32vector-reverse-copy: Uvector basic operations
s32vector-set!: Uvector basic operations
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?: Uvector basic operations
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 basic operations
s64vector-ior: Uvector numeric operations
s64vector-ior!: Uvector numeric operations
s64vector-length: Uvector basic operations
s64vector-mul: Uvector numeric operations
s64vector-mul!: Uvector numeric operations
s64vector-multi-copy!: Uvector basic operations
s64vector-range-check: Uvector numeric operations
s64vector-ref: Uvector basic operations
s64vector-reverse-copy: Uvector basic operations
s64vector-set!: Uvector basic operations
s64vector-sub: Uvector numeric operations
s64vector-sub!: Uvector numeric operations
s64vector-swap!: Uvector basic operations
s64vector-unfold: Uvector basic operations
s64vector-unfold-right: Uvector basic operations
s64vector-xor: Uvector numeric operations
s64vector-xor!: Uvector numeric operations
s64vector=: Uvector basic operations
s64vector=?: Uvector basic operations
s64vector?: Uvector basic operations
s8?: Uvector basic operations
s8array: Arrays
s8vector: Uvector basic operations
s8vector->list: Uvector conversion operations
s8vector->string: Uvector conversion operations
s8vector->vector: Uvector conversion operations
s8vector-add: Uvector numeric operations
s8vector-add!: Uvector numeric operations
s8vector-and: Uvector numeric operations
s8vector-and!: Uvector numeric operations
s8vector-append: Uvector basic operations
s8vector-append-subvectors: Uvector basic operations
s8vector-clamp: Uvector numeric operations
s8vector-clamp!: Uvector numeric operations
s8vector-compare: Uvector basic operations
s8vector-concatenate: Uvector basic operations
s8vector-copy: Uvector basic operations
s8vector-copy!: Uvector basic operations
s8vector-dot: Uvector numeric operations
s8vector-empty?: Uvector basic operations
s8vector-fill!: Uvector basic operations
s8vector-ior: Uvector numeric operations
s8vector-ior!: Uvector numeric operations
s8vector-length: Uvector basic operations
s8vector-mul: Uvector numeric operations
s8vector-mul!: Uvector numeric operations
s8vector-multi-copy!: Uvector basic operations
s8vector-range-check: Uvector numeric operations
s8vector-ref: Uvector basic operations
s8vector-reverse-copy: Uvector basic operations
s8vector-set!: Uvector basic operations
s8vector-sub: Uvector numeric operations
s8vector-sub!: Uvector numeric operations
s8vector-swap!: Uvector basic operations
s8vector-unfold: Uvector basic operations
s8vector-unfold-right: Uvector basic operations
s8vector-xor: Uvector numeric operations
s8vector-xor!: Uvector numeric operations
s8vector=: Uvector basic operations
s8vector=?: Uvector basic operations
s8vector?: Uvector basic operations
samples$: Random data generators
samples-from: Random data generators
save-bundle!: Localization
scheme-report-environment: Eval and repl
second: R7RS lists
seconds->time: Time
select-kids: SXPath basic converters and applicators
select-module: Defining and selecting modules
selector-add!: Simple dispatcher
selector-delete!: Simple dispatcher
selector-select: Simple dispatcher
sequence->kmp-stepper: Other operations over sequences
sequence-contains: Other operations over sequences
sequences-of: Random data generators
sequences-of: Random data generators
set: R7RS sets
set!: Assignments
set!: Assignments
set!: CiSE syntax
set!-values: Assignments
set->bag: R7RS sets
set->bag!: R7RS sets
set->list: R7RS sets
set-adjoin: R7RS sets
set-adjoin!: R7RS sets
set-any?: R7RS sets
set-box!: R7RS boxes
set-car!: List accessors and modifiers
set-cdr!: List accessors and modifiers
set-character-attribute: Text terminal control
set-contains?: R7RS sets
set-copy: R7RS sets
set-count: R7RS sets
set-delete: R7RS sets
set-delete!: R7RS sets
set-delete-all: R7RS sets
set-delete-all!: R7RS sets
set-difference: R7RS sets
set-difference!: R7RS sets
set-disjoint?: R7RS sets
set-element-comparator: R7RS sets
set-empty?: R7RS sets
set-every?: R7RS sets
set-filter: R7RS sets
set-filter!: R7RS sets
set-find: R7RS sets
set-fold: R7RS sets
set-for-each: R7RS sets
set-intersection: R7RS sets
set-intersection!: R7RS sets
set-map: R7RS sets
set-member: R7RS sets
set-partition: R7RS sets
set-partition!: R7RS sets
set-remove: R7RS sets
set-remove!: R7RS sets
set-replace: R7RS sets
set-replace!: R7RS sets
set-search!: R7RS sets
set-signal-handler!: Handling signals
set-signal-pending-limit: Handling signals
set-size: R7RS sets
set-time-nanosecond!: SRFI-19 Time procedures
set-time-second!: SRFI-19 Time procedures
set-time-type!: SRFI-19 Time procedures
set-unfold: R7RS sets
set-union: R7RS sets
set-union!: R7RS sets
set-xor: R7RS sets
set-xor!: R7RS sets
set<=?: R7RS sets
set<?: R7RS sets
set=?: R7RS sets
set>=?: R7RS sets
set>?: R7RS sets
setter: Assignments
seventh: R7RS lists
sexp-list->file: File operations
sha1-digest: SHA message digest
sha1-digest-string: SHA message digest
sha224-digest: SHA message digest
sha224-digest-string: SHA message digest
sha256-digest: SHA message digest
sha256-digest-string: SHA message digest
sha384-digest: SHA message digest
sha384-digest-string: SHA message digest
sha512-digest: SHA message digest
sha512-digest-string: SHA message digest
shape: Arrays
shape-for-each: Arrays
share-array: Arrays
shell-escape-string: Process ports
shell-tokenize-string: Process ports
shift: Partial continuations
show-cursor: Text terminal control
shuffle: Other operations over sequences
shuffle!: Other operations over sequences
shuffle-to: Other operations over sequences
shutdown-method: Basic socket interface
simplify-path: Pathname utilities
sin: Arithmetics
sinh: Arithmetics
sint-list->blob: Octet-addressed binary blocks
sixth: R7RS lists
size-of: Miscellaneous operations on collection
skip-until: Parsing input stream
skip-while: Parsing input stream
slices: List accessors and modifiers
slot-bound-using-accessor?: Customizing slot access
slot-bound-using-class?: Accessing instance
slot-bound?: Accessing instance
slot-definition-accessor: Slot definition object
slot-definition-allocation: Slot definition object
slot-definition-getter: Slot definition object
slot-definition-name: Slot definition object
slot-definition-option: Slot definition object
slot-definition-options: Slot definition object
slot-definition-setter: Slot definition object
slot-exists?: Accessing instance
slot-initialize-using-accessor!: Customizing slot access
slot-missing: Accessing instance
slot-missing: Accessing instance
slot-pop!: Accessing instance
slot-push!: Accessing instance
slot-ref: Accessing instance
slot-ref-using-accessor: Customizing slot access
slot-ref-using-class: Accessing instance
slot-set!: Accessing instance
slot-set-using-accessor!: Customizing slot access
slot-set-using-class!: Accessing instance
slot-unbound: Accessing instance
slot-unbound: Accessing instance
small-prime?: Prime numbers
sockaddr-addr: Socket address
sockaddr-family: Socket address
sockaddr-family: Socket address
sockaddr-family: Socket address
sockaddr-name: Socket address
sockaddr-name: Socket address
sockaddr-name: Socket address
sockaddr-port: Socket address
socket-accept: Low-level socket interface
socket-address: High-level network functions
socket-bind: Low-level socket interface
socket-buildmsg: Low-level socket interface
socket-close: High-level network functions
socket-connect: Low-level socket interface
socket-domain: Basic socket interface
socket-fd: Low-level socket interface
socket-getpeername: Low-level socket interface
socket-getsockname: Low-level socket interface
socket-getsockopt: Low-level socket interface
socket-input-port: High-level network functions
socket-listen: Low-level socket interface
socket-merge-flags: Basic socket interface
socket-output-port: High-level network functions
socket-purge-flags: Basic socket interface
socket-recv: Low-level socket interface
socket-recv: Basic socket interface
socket-recv!: Low-level socket interface
socket-recvfrom: Low-level socket interface
socket-recvfrom!: Low-level socket interface
socket-send: Low-level socket interface
socket-send: Basic socket interface
socket-sendmsg: Low-level socket interface
socket-sendto: Low-level socket interface
socket-setsockopt: Low-level socket interface
socket-shutdown: Low-level socket interface
socket-status: Low-level socket interface
socket?: Basic socket interface
sort: Sorting and merging
sort!: Sorting and merging
sort-applicable-methods: Customizing method application
sort-by: Sorting and merging
sort-by!: Sorting and merging
sorted?: Sorting and merging
source-code: Debugging aid
source-location: Debugging aid
span: R7RS lists
span!: R7RS lists
sparse-matrix-clear!: Sparse matrixes
sparse-matrix-copy: Sparse matrixes
sparse-matrix-delete!: Sparse matrixes
sparse-matrix-exists?: Sparse matrixes
sparse-matrix-fold: Sparse matrixes
sparse-matrix-for-each: Sparse matrixes
sparse-matrix-inc!: Sparse matrixes
sparse-matrix-keys: Sparse matrixes
sparse-matrix-map: Sparse matrixes
sparse-matrix-num-entries: Sparse matrixes
sparse-matrix-pop!: Sparse matrixes
sparse-matrix-push!: Sparse matrixes
sparse-matrix-ref: Sparse matrixes
sparse-matrix-set!: Sparse matrixes
sparse-matrix-update!: Sparse matrixes
sparse-matrix-values: Sparse matrixes
sparse-table-clear!: Sparse tables
sparse-table-comparator: Sparse tables
sparse-table-copy: Sparse tables
sparse-table-delete!: Sparse tables
sparse-table-exists?: Sparse tables
sparse-table-fold: Sparse tables
sparse-table-for-each: Sparse tables
sparse-table-keys: Sparse tables
sparse-table-map: Sparse tables
sparse-table-num-entries: Sparse tables
sparse-table-pop!: Sparse tables
sparse-table-push!: Sparse tables
sparse-table-ref: Sparse tables
sparse-table-set!: Sparse tables
sparse-table-update!: Sparse tables
sparse-table-values: Sparse tables
sparse-vector-clear!: Sparse vectors
sparse-vector-copy: Sparse vectors
sparse-vector-delete!: Sparse vectors
sparse-vector-exists?: Sparse vectors
sparse-vector-fold: Sparse vectors
sparse-vector-for-each: Sparse vectors
sparse-vector-inc!: Sparse vectors
sparse-vector-keys: Sparse vectors
sparse-vector-map: Sparse vectors
sparse-vector-max-index-bits: Sparse vectors
sparse-vector-num-entries: Sparse vectors
sparse-vector-pop!: Sparse vectors
sparse-vector-push!: Sparse vectors
sparse-vector-ref: Sparse vectors
sparse-vector-set!: Sparse vectors
sparse-vector-update!: Sparse vectors
sparse-vector-values: Sparse vectors
split-at: List accessors and modifiers
split-at!: List accessors and modifiers
split-at*: List accessors and modifiers
sql-tokenize: SQL parsing and construction
sqrt: Arithmetics
square: Arithmetics
srl:display-sxml: Custom SXML serializing
srl:parameterizable: Custom SXML serializing
srl:sxml->html: Simple SXML serializing
srl:sxml->html-noindent: Simple SXML serializing
srl:sxml->string: Custom SXML serializing
srl:sxml->xml: Simple SXML serializing
srl:sxml->xml-noindent: Simple SXML serializing
ssax:assert-token: SSAX higher-level parsers and scanners
ssax:complete-start-tag: SSAX low-level parsing code
ssax:handle-parsed-entity: SSAX low-level parsing code
ssax:make-elem-parser: SSAX Highest-level parsers - XML to SXML
ssax:make-parser: SSAX Highest-level parsers - XML to SXML
ssax:make-pi-parser: SSAX Highest-level parsers - XML to SXML
ssax:ncname-starting-char?: SSAX low-level parsing code
ssax:read-attributes: SSAX low-level parsing code
ssax:read-cdata-body: SSAX low-level parsing code
ssax:read-char-data: SSAX higher-level parsers and scanners
ssax:read-char-ref: SSAX low-level parsing code
ssax:read-external-id: SSAX low-level parsing code
ssax:read-markup-token: SSAX low-level parsing code
ssax:read-NCName: SSAX low-level parsing code
ssax:read-pi-body-as-string: SSAX low-level parsing code
ssax:read-QName: SSAX low-level parsing code
ssax:resolve-name: SSAX low-level parsing code
ssax:reverse-collect-str: SSAX Highest-level parsers - XML to SXML
ssax:reverse-collect-str-drop-ws: SSAX Highest-level parsers - XML to SXML
ssax:scan-Misc: SSAX higher-level parsers and scanners
ssax:skip-internal-dtd: SSAX low-level parsing code
ssax:skip-pi: SSAX low-level parsing code
ssax:skip-S: SSAX low-level parsing code
ssax:uri-string->symbol: SSAX low-level parsing code
ssax:xml->sxml: SSAX Highest-level parsers - XML to SXML
stable-sort: Sorting and merging
stable-sort!: Sorting and merging
stable-sort-by: Sorting and merging
stable-sort-by!: Sorting and merging
standard-error-port: Common port operations
standard-input-port: Common port operations
standard-output-port: Common port operations
stream: R7RS stream
stream: Stream constructors
stream+: Stream constructors
stream->list: Stream operations
stream->list: Stream operations
stream->string: Stream operations
stream-any: Stream operations
stream-append: Stream operations
stream-break: Stream operations
stream-butlast: Stream operations
stream-butlast-n: Stream operations
stream-caaaar: Stream operations
stream-caaadr: Stream operations
stream-caaar: Stream operations
stream-caadar: Stream operations
stream-caaddr: Stream operations
stream-caadr: Stream operations
stream-caar: Stream operations
stream-cadaar: Stream operations
stream-cadadr: Stream operations
stream-cadar: Stream operations
stream-caddar: Stream operations
stream-cadddr: Stream operations
stream-caddr: Stream operations
stream-cadr: Stream operations
stream-car: Stream primitives
stream-cdaaar: Stream operations
stream-cdaadr: Stream operations
stream-cdaar: Stream operations
stream-cdadar: Stream operations
stream-cdaddr: Stream operations
stream-cdadr: Stream operations
stream-cdar: Stream operations
stream-cddaar: Stream operations
stream-cddadr: Stream operations
stream-cddar: Stream operations
stream-cdddar: Stream operations
stream-cddddr: Stream operations
stream-cdddr: Stream operations
stream-cddr: Stream operations
stream-cdr: Stream primitives
stream-concat: Stream operations
stream-concatenate: Stream operations
stream-cons: Stream primitives
stream-cons*: Stream constructors
stream-constant: Stream constructors
stream-count: Stream operations
stream-delay: Stream primitives
stream-delete: Stream operations
stream-delete-duplicates: Stream operations
stream-drop: R7RS stream
stream-drop: Stream operations
stream-drop-safe: Stream operations
stream-drop-while: Stream operations
stream-eighth: Stream operations
stream-every: Stream operations
stream-fifth: Stream operations
stream-filter: Stream operations
stream-find: Stream operations
stream-find-tail: Stream operations
stream-first: Stream operations
stream-fold: Stream consumers
stream-for-each: Stream consumers
stream-format: Stream constructors
stream-fourth: Stream operations
stream-from: Stream constructors
stream-grep: Stream operations
stream-index: Stream operations
stream-intersperse: Stream operations
stream-iota: Stream constructors
stream-iterate: Stream constructors
stream-lambda: Stream primitives
stream-last: Stream operations
stream-last-n: Stream operations
stream-length: Stream operations
stream-length=: Stream operations
stream-length>=: Stream operations
stream-let: Stream binding
stream-lines: Stream operations
stream-map: Stream operations
stream-match: Stream binding
stream-member: Stream operations
stream-memq: Stream operations
stream-memv: Stream operations
stream-ninth: Stream operations
stream-null?: Stream primitives
stream-of: Stream constructors
stream-pair?: Stream primitives
stream-partition: Stream operations
stream-prefix=: Stream operations
stream-range: Stream constructors
stream-ref: Stream operations
stream-remove: Stream operations
stream-reverse: Stream operations
stream-scan: Stream operations
stream-second: Stream operations
stream-seventh: Stream operations
stream-sixth: Stream operations
stream-span: Stream operations
stream-split: Stream operations
stream-tabulate: Stream constructors
stream-take: R7RS stream
stream-take: Stream operations
stream-take-safe: Stream operations
stream-take-while: Stream operations
stream-tenth: Stream operations
stream-third: Stream operations
stream-unfold: Stream constructors
stream-unfoldn: Stream constructors
stream-unfolds: Stream constructors
stream-xcons: Stream constructors
stream-zip: Stream operations
stream=: Stream operations
stream?: Stream primitives
string: String Constructors
string->char-set: Character-set constructors
string->char-set!: Character-set constructors
string->date: SRFI-19 Date reader and writer
string->file: File operations
string->generator: Generator constructors
string->grapheme-clusters: Unicode text segmentation
string->list: String utilities
string->number: Numerical conversions
string->regexp: Using regular expressions
string->s32vector: Uvector conversion operations
string->s32vector!: Uvector conversion operations
string->s8vector: Uvector conversion operations
string->s8vector!: Uvector conversion operations
string->stream: Stream constructors
string->symbol: Symbols
string->u32vector: Uvector conversion operations
string->u32vector!: Uvector conversion operations
string->u8vector: Uvector conversion operations
string->u8vector!: Uvector conversion operations
string->uninterned-symbol: Symbols
string->utf8: Unicode transfer encodings
string->vector: Vectors
string->words: Unicode text segmentation
string-accumulator: R7RS generators
string-any: SRFI-13 String predicates
string-append: String utilities
string-append!: Simple adjustable-size strings
string-append-ec: Eager comprehensions
string-append/shared: SRFI-13 String reverse & append
string-break: String library (reduced)
string-byte-ref: String Accessors & Modifiers
string-byte-set!: String Accessors & Modifiers
string-ci-hash: Hashing
string-ci-hash: R7RS hash tables
string-ci-hash: Basic hash tables
string-ci<: SRFI-13 String Comparison
string-ci<=: SRFI-13 String Comparison
string-ci<=?: String Comparison
string-ci<=?: Full string case conversion
string-ci<>: SRFI-13 String Comparison
string-ci<?: String Comparison
string-ci<?: Full string case conversion
string-ci=: SRFI-13 String Comparison
string-ci=?: String Comparison
string-ci=?: Full string case conversion
string-ci>: SRFI-13 String Comparison
string-ci>=: SRFI-13 String Comparison
string-ci>=?: String Comparison
string-ci>=?: Full string case conversion
string-ci>?: String Comparison
string-ci>?: Full string case conversion
string-compare: SRFI-13 String Comparison
string-compare-ci: SRFI-13 String Comparison
string-concatenate: SRFI-13 String reverse & append
string-concatenate-reverse: SRFI-13 String reverse & append
string-concatenate-reverse/shared: SRFI-13 String reverse & append
string-concatenate/shared: SRFI-13 String reverse & append
string-contains: SRFI-13 String searching
string-contains-ci: SRFI-13 String searching
string-contains-right: String library (reduced)
string-copy: String utilities
string-copy!: SRFI-13 String Selection
string-count: SRFI-13 String searching
string-delete: SRFI-13 String filtering
string-downcase: Full string case conversion
string-downcase: SRFI-13 String case mapping
string-downcase!: SRFI-13 String case mapping
string-drop: SRFI-13 String Selection
string-drop-right: SRFI-13 String Selection
string-drop-while: String library (reduced)
string-drop-while-right: String library (reduced)
string-ec: Eager comprehensions
string-every: SRFI-13 String predicates
string-fill!: String utilities
string-filter: SRFI-13 String filtering
string-fold: SRFI-13 String mapping
string-fold-right: SRFI-13 String mapping
string-foldcase: Full string case conversion
string-for-each: R7RS base library
string-for-each: SRFI-13 String mapping
string-for-each-index: SRFI-13 String mapping
string-hash: Hashing
string-hash: R7RS hash tables
string-hash: SRFI-13 String Comparison
string-hash: Basic hash tables
string-hash-ci: SRFI-13 String Comparison
string-immutable?: String Predicates
string-incomplete->complete: Incomplete strings
string-incomplete?: String Predicates
string-index: SRFI-13 String searching
string-index-right: SRFI-13 String searching
string-join: String utilities
string-kmp-partial-search: SRFI-13 Low-level string procedures
string-length: String Accessors & Modifiers
string-list->file: File operations
string-map: R7RS base library
string-map: SRFI-13 String mapping
string-map!: SRFI-13 String mapping
string-null?: SRFI-13 String predicates
string-pad: SRFI-13 String Selection
string-pad-right: SRFI-13 String Selection
string-parse-final-start+end: SRFI-13 Low-level string procedures
string-parse-start+end: SRFI-13 Low-level string procedures
string-prefix-ci?: SRFI-13 String Prefixes & Suffixes
string-prefix-length: SRFI-13 String Prefixes & Suffixes
string-prefix-length-ci: SRFI-13 String Prefixes & Suffixes
string-prefix?: SRFI-13 String Prefixes & Suffixes
string-ref: String Accessors & Modifiers
string-remove: String library (reduced)
string-replace: SRFI-13 other string operations
string-replace!: Simple adjustable-size strings
string-replicate: String library (reduced)
string-reverse: SRFI-13 String reverse & append
string-reverse!: SRFI-13 String reverse & append
string-scan: String utilities
string-scan-right: String utilities
string-segment: String library (reduced)
string-set!: String Accessors & Modifiers
string-size: String Accessors & Modifiers
string-skip: SRFI-13 String searching
string-skip-right: SRFI-13 String searching
string-span: String library (reduced)
string-split: String utilities
string-split: String utilities
string-suffix-ci?: SRFI-13 String Prefixes & Suffixes
string-suffix-length: SRFI-13 String Prefixes & Suffixes
string-suffix-length-ci: SRFI-13 String Prefixes & Suffixes
string-suffix?: SRFI-13 String Prefixes & Suffixes
string-tabulate: SRFI-13 String Constructors
string-take: SRFI-13 String Selection
string-take-right: SRFI-13 String Selection
string-take-while: String library (reduced)
string-take-while-right: String library (reduced)
string-titlecase: Full string case conversion
string-titlecase: SRFI-13 String case mapping
string-titlecase!: SRFI-13 String case mapping
string-tokenize: SRFI-13 other string operations
string-tr: Transliterate characters
string-trim: SRFI-13 String Selection
string-trim-both: SRFI-13 String Selection
string-trim-right: SRFI-13 String Selection
string-unfold: SRFI-13 String mapping
string-unfold-right: SRFI-13 String mapping
string-upcase: Full string case conversion
string-upcase: SRFI-13 String case mapping
string-upcase!: SRFI-13 String case mapping
string-xcopy!: SRFI-13 String rotation
string<: SRFI-13 String Comparison
string<=: SRFI-13 String Comparison
string<=?: String Comparison
string<>: SRFI-13 String Comparison
string<?: String Comparison
string=: SRFI-13 String Comparison
string=?: String Comparison
string>: SRFI-13 String Comparison
string>=: SRFI-13 String Comparison
string>=?: String Comparison
string>?: String Comparison
string?: String Predicates
strings-of: Random data generators
strings-of: Random data generators
strings-of: Random data generators
subseq: Slicing sequence
substring: String utilities
substring-spec-ok?: SRFI-13 Low-level string procedures
substring/shared: SRFI-13 String Selection
subtract-duration: SRFI-19 Time procedures
subtract-duration!: SRFI-19 Time procedures
subtype?: Types and classes
sum-accumulator: R7RS generators
sum-ec: Eager comprehensions
supported-character-encodings: Characters
sxml:add-attr: SXML modifiers
sxml:add-attr!: SXML modifiers
sxml:add-aux: SXML modifiers
sxml:add-aux!: SXML modifiers
sxml:add-parents: SXPath auxiliary utilities
sxml:ancestor: SXPath extension
sxml:ancestor-or-self: SXPath extension
sxml:attr: SXML accessors
sxml:attr->html: SXML to markup conversion
sxml:attr->xml: SXML to markup conversion
sxml:attr-as-list: SXML accessors
sxml:attr-list: SXPath extension
sxml:attr-list-node: SXML accessors
sxml:attr-list-u: SXML accessors
sxml:attr-u: SXML accessors
sxml:attribute: SXPath extension
sxml:aux-as-list: SXML accessors
sxml:aux-list: SXML accessors
sxml:aux-list-node: SXML accessors
sxml:aux-list-u: SXML accessors
sxml:aux-node: SXML accessors
sxml:aux-nodes: SXML accessors
sxml:boolean: SXPath extension
sxml:change-attr: SXML modifiers
sxml:change-attr!: SXML modifiers
sxml:change-attrlist: SXML modifiers
sxml:change-attrlist!: SXML modifiers
sxml:change-content: SXML modifiers
sxml:change-content!: SXML modifiers
sxml:change-name: SXML modifiers
sxml:change-name!: SXML modifiers
sxml:child: SXPath extension
sxml:child-elements: SXPath extension
sxml:child-nodes: SXPath extension
sxml:clean: SXML modifiers
sxml:clean-feed: SXML to markup conversion
sxml:content: SXML accessors
sxml:content-raw: SXML accessors
sxml:descendant: SXPath extension
sxml:descendant-or-self: SXPath extension
sxml:element-name: SXML accessors
sxml:element?: SXPath basic converters and applicators
sxml:empty-element?: SXML predicates
sxml:equal?: SXPath extension
sxml:equality-cmp: SXPath extension
sxml:filter: SXPath basic converters and applicators
sxml:following: SXPath extension
sxml:following-sibling: SXPath extension
sxml:id: SXPath extension
sxml:id-alist: SXPath query language
sxml:invert: SXPath basic converters and applicators
sxml:lookup: SXPath auxiliary utilities
sxml:minimized?: SXML predicates
sxml:name: SXML accessors
sxml:name->ns-id: SXML accessors
sxml:namespace: SXPath extension
sxml:ncname: SXML accessors
sxml:node-name: SXML accessors
sxml:node-parent: SXPath auxiliary utilities
sxml:node?: SXPath extension
sxml:non-terminated-html-tag?: SXML to markup conversion
sxml:normalized?: SXML predicates
sxml:not-equal?: SXPath extension
sxml:ns-id: SXML accessors
sxml:ns-id->nodes: SXML accessors
sxml:ns-id->uri: SXML accessors
sxml:ns-list: SXML accessors
sxml:ns-prefix: SXML accessors
sxml:ns-uri: SXML accessors
sxml:ns-uri->id: SXML accessors
sxml:num-attr: SXML accessors
sxml:number: SXPath extension
sxml:parent: SXPath extension
sxml:preceding: SXPath extension
sxml:preceding-sibling: SXPath extension
sxml:relational-cmp: SXPath extension
sxml:set-attr: SXML modifiers
sxml:set-attr!: SXML modifiers
sxml:shallow-minimized?: SXML predicates
sxml:shallow-normalized?: SXML predicates
sxml:squeeze: SXML modifiers
sxml:squeeze!: SXML modifiers
sxml:string: SXPath extension
sxml:string->html: SXML to markup conversion
sxml:string->xml: SXML to markup conversion
sxml:string-value: SXPath extension
sxml:sxml->html: SXML to markup conversion
sxml:sxml->xml: SXML to markup conversion
sxpath: SXPath query language
symbol->string: Symbols
symbol-append: Symbols
symbol-append: Symbols
symbol-hash: Hashing
symbol-interned?: Symbols
symbol-sans-prefix: Symbols
symbol=?: Symbols
symbol?: Symbols
syntax-error: Macro utilities
syntax-errorf: Macro utilities
syntax-rules: Syntax-rules macro transformer
syntax-rules: Syntax-rules macro transformer
sys-abort: Program termination
sys-access: File stats
sys-alarm: Miscellaneous system calls
sys-alloc-console: Windows console API
sys-asctime: Time
sys-available-processors: Environment inquiry
sys-basename: Pathnames
sys-cfgetispeed: Posix termios interface
sys-cfgetospeed: Posix termios interface
sys-cfsetispeed: Posix termios interface
sys-cfsetospeed: Posix termios interface
sys-chdir: Other file operations
sys-chmod: File stats
sys-chown: File stats
sys-clearenv: Environment inquiry
sys-closelog: Syslog
sys-create-console-screen-buffer: Windows console API
sys-crypt: Unix groups and users
sys-ctermid: System inquiry
sys-ctime: Time
sys-difftime: Time
sys-dirname: Pathnames
sys-environ: Environment inquiry
sys-environ->alist: Environment inquiry
sys-errno->symbol: System inquiry
sys-exec: Process management
sys-exit: Program termination
sys-fchmod: File stats
sys-fcntl: Low-level file operations
sys-fdset: I/O multiplexing
sys-fdset->list: I/O multiplexing
sys-fdset-clear!: I/O multiplexing
sys-fdset-copy!: I/O multiplexing
sys-fdset-max-fd: I/O multiplexing
sys-fdset-ref: I/O multiplexing
sys-fdset-set!: I/O multiplexing
sys-fill-console-output-attribute: Windows console API
sys-fill-console-output-character: Windows console API
sys-flush-console-input-buffer: Windows console API
sys-fork: Process management
sys-fork-and-exec: Process management
sys-forkpty: Posix termios interface
sys-forkpty-and-exec: Posix termios interface
sys-free-console: Windows console API
sys-fstat: File stats
sys-ftruncate: Other file operations
sys-generate-console-ctrl-event: Windows console API
sys-get-console-cp: Windows console API
sys-get-console-cursor-info: Windows console API
sys-get-console-mode: Windows console API
sys-get-console-output-cp: Windows console API
sys-get-console-screen-buffer-info: Windows console API
sys-get-console-title: Windows console API
sys-get-largest-console-window-size: Windows console API
sys-get-number-of-console-input-events: Windows console API
sys-get-number-of-console-mouse-buttons: Windows console API
sys-get-osfhandle: Miscellaneous system calls
sys-get-std-handle: Windows console API
sys-getaddrinfo: Netdb interface
sys-getcwd: System inquiry
sys-getdomainname: System inquiry
sys-getegid: System inquiry
sys-getenv: Environment inquiry
sys-geteuid: System inquiry
sys-getgid: System inquiry
sys-getgrgid: Unix groups and users
sys-getgrnam: Unix groups and users
sys-getgroups: System inquiry