For Gauche 0.9.5

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

$: Making Procedures

%macroexpand: Macro expansion
%macroexpand-1: Macro expansion

(setter cgi-test-enviornment-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
*.: Arithmetics

+: Arithmetics
+.: Arithmetics

-: Arithmetics
-.: Arithmetics
->char-set: SRFI-14 Character-set constructors

.$: Combinators

/: Arithmetics
/.: Arithmetics

:: 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
:vector: Eager comprehensions
:while: Eager comprehensions

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

=: Numerical comparison
=?: Comparator predicates and accessors

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

^: 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: Sets and bags
alist->hash-table: Hashtables
alist->hash-table: Basic hash tables
alist->imap: Immutable map
alist->imap: Immutable map
alist->imap: Immutable map
alist->rbtree: Obsoleted modules
alist->tree-map: Treemaps
alist->tree-map: Treemaps
alist-cons: SRFI-1 List utilities
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: Eager comprehensions
and-let*: Binding constructs
and-let1: Binding constructs
angle: Numerical conversions
any: Walking over lists
any$: Combinators
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
apropos: Interactive session
args-fold: A program argument processor
arithmetic-shift: Integers as bits
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-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-rank: 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: Bitwise operations
ash: Integers as bits
asin: Arithmetics
asinh: Arithmetics
assert-curr-char: Parsing input stream
assoc: Association lists
assoc$: Combinators
assoc-ref: Association lists
assoc-set!: Association lists
assq: Association lists
assq-ref: Association lists
assq-set!: Association lists
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: Sets and bags
bag->alist: Sets and bags
bag->list: Sets and bags
bag->set: Sets and bags
bag-adjoin: Sets and bags
bag-adjoin!: Sets and bags
bag-any?: Sets and bags
bag-contains?: Sets and bags
bag-copy: Sets and bags
bag-count: Sets and bags
bag-decrement!: Sets and bags
bag-delete: Sets and bags
bag-delete!: Sets and bags
bag-delete-all: Sets and bags
bag-delete-all!: Sets and bags
bag-difference: Sets and bags
bag-difference!: Sets and bags
bag-disjoint?: Sets and bags
bag-element-comparator: Sets and bags
bag-element-count: Sets and bags
bag-empty?: Sets and bags
bag-every?: Sets and bags
bag-filter: Sets and bags
bag-filter!: Sets and bags
bag-find: Sets and bags
bag-fold: Sets and bags
bag-fold-unique: Sets and bags
bag-for-each: Sets and bags
bag-for-each-unique: Sets and bags
bag-increment!: Sets and bags
bag-intersection: Sets and bags
bag-intersection!: Sets and bags
bag-map: Sets and bags
bag-member: Sets and bags
bag-partition: Sets and bags
bag-partition!: Sets and bags
bag-product: Sets and bags
bag-product!: Sets and bags
bag-remove: Sets and bags
bag-remove!: Sets and bags
bag-replace: Sets and bags
bag-replace!: Sets and bags
bag-search!: Sets and bags
bag-size: Sets and bags
bag-sum: Sets and bags
bag-sum!: Sets and bags
bag-unfold: Sets and bags
bag-union: Sets and bags
bag-union!: Sets and bags
bag-unique-size: Sets and bags
bag-xor: Sets and bags
bag-xor!: Sets and bags
bag<=?: Sets and bags
bag<?: Sets and bags
bag=?: Sets and bags
bag>=?: Sets and bags
bag>?: Sets and bags
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: 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: Integers as bits
bit-field: Bitwise operations
bit-field: Integers as bits
bit-set?: Integers as bits
bits->generator: Generator constructors
bitwise-and: Integers as bits
bitwise-if: Integers as bits
bitwise-ior: Integers as bits
bitwise-not: Integers as bits
bitwise-xor: Integers as bits
boolean: Booleans
boolean-hash: Hashing
boolean=?: Booleans
boolean?: Booleans
booleans: Random data generators
booleans->integer: Integers as bits
box: Boxes
box?: Boxes
bpsw-prime?: Prime numbers
break: SRFI-1 List utilities
break!: SRFI-1 List utilities
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: R7RS base library
bytevector->generator: Generator constructors
bytevector-append: R7RS base library
bytevector-copy: R7RS base library
bytevector-copy!: R7RS base library
bytevector-length: R7RS base library
bytevector-u8-ref: R7RS base library
bytevector-u8-set!: R7RS base library
bytevector?: R7RS base library

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-values: Multiple values
call/cc: Continuations
call/pc: Partial continuations
car: List accessors and modifiers
car+cdr: SRFI-1 List utilities
car-sxpath: SXPath query language
cartesian-product: Combination library
cartesian-product-right: Combination library
case: Conditionals
case-lambda: Making Procedures
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
ces-conversion-supported?: Supported character encoding schemes
ces-convert: 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-header: Configure API
cf-check-headers: Configure API
cf-check-prog: 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-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-result: Configure API
cf-msg-warn: Configure API
cf-output: Configure API
cf-package-ref: Configure API
cf-path-prog: Configure API
cf-prog-cxx: Configure API
cf-ref: Configure API
cf-show-variables: Configure API
cf-subst: 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-enviornment-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-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: SRFI-14 Character-set query
char-set->string: SRFI-14 Character-set query
char-set-adjoin: SRFI-14 Character-set algebra
char-set-adjoin!: SRFI-14 Character-set algebra
char-set-any: SRFI-14 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: SRFI-14 Character-set query
char-set-cursor: SRFI-14 Character-set iteration
char-set-cursor-next: SRFI-14 Character-set iteration
char-set-delete: SRFI-14 Character-set algebra
char-set-delete!: SRFI-14 Character-set algebra
char-set-diff+intersection: SRFI-14 Character-set algebra
char-set-diff+intersection!: SRFI-14 Character-set algebra
char-set-difference: SRFI-14 Character-set algebra
char-set-difference!: SRFI-14 Character-set algebra
char-set-every: SRFI-14 Character-set query
char-set-filter: SRFI-14 Character-set constructors
char-set-filter!: SRFI-14 Character-set constructors
char-set-fold: SRFI-14 Character-set iteration
char-set-for-each: SRFI-14 Character-set iteration
char-set-hash: SRFI-14 Character-set comparison
char-set-intersection: SRFI-14 Character-set algebra
char-set-intersection!: SRFI-14 Character-set algebra
char-set-map: SRFI-14 Character-set iteration
char-set-ref: SRFI-14 Character-set iteration
char-set-size: Character set
char-set-unfold: SRFI-14 Character-set iteration
char-set-unfold!: SRFI-14 Character-set iteration
char-set-union: SRFI-14 Character-set algebra
char-set-union!: SRFI-14 Character-set algebra
char-set-xor: SRFI-14 Character-set algebra
char-set-xor!: SRFI-14 Character-set algebra
char-set<=: SRFI-14 Character-set comparison
char-set=: SRFI-14 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
chready?: Text terminal control
circular-generator: Generator constructors
circular-list: SRFI-1 List utilities
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: Comparators
comparator-min: Comparators
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-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
cons: List constructors
cons*: List constructors
console-device: Pathname utilities
construct-cookie-string: HTTP cookie handling
construct-css: CSS parsing and construction
construct-json: JSON parsing and construction
construct-json-string: JSON parsing and construction
continued-fraction: Arithmetics
copy-bit: Bitwise operations
copy-bit: Integers as bits
copy-bit-field: Bitwise operations
copy-bit-field: Integers as bits
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
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-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
decode-float: Numerical conversions
decompose-path: Pathname utilities
default-endian: Endianness
default-hash: Hashing
default-sizer: Random data generators
define: Definitions
define: Definitions
define-cise-expr: CiSE procedures
define-cise-macro: CiSE procedures
define-cise-macro: CiSE procedures
define-cise-stmt: CiSE procedures
define-cise-toplevel: CiSE procedures
define-class: Defining class
define-condition-type: Conditions
define-constant: Definitions
define-constant: Definitions
define-dict-interface: Generic functions for dictionaries
define-generic: Generic function and method
define-in-module: Definitions
define-in-module: 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-syntax: Hygienic macros
define-values: Definitions
define-values: Definitions
define-values: Definitions
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: R7RS file library
delete-file: File operations
delete-files: File operations
delete-hook!: Hooks
delete-keyword: Keywords
delete-keyword!: Keywords
delete-keywords: Keywords
delete-keywords!: Keywords
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
dolist: Iteration
dotimes: Iteration
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: SRFI-1 List utilities
dynamic-load: Loading dynamic library
dynamic-wind: Continuations

ecase: Conditionals
ed: Interactive session
eighth: SRFI-1 List utilities
emergency-exit: R7RS process context
encode-float: Numerical conversions
end-of-char-set?: SRFI-14 Character-set iteration
enqueue!: Queue
enqueue-unique!: Queue
enqueue/wait!: Queue
environment: R7RS eval
eof-object: Reading data
eof-object?: Reading data
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
eval: Eval and repl
eval: R7RS eval
even?: Numerical predicates
every: Walking over lists
every$: Combinators
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
export: Using modules
export-all: Using modules
expt: Arithmetics
expt-mod: Arithmetics
extend: Module inheritance
extract-condition: Conditions

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-clamp!: Uvector numeric 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-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-set!: Uvector basic operations
f16vector-sub: Uvector numeric operations
f16vector-sub!: Uvector numeric operations
f16vector?: 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-clamp: Uvector numeric operations
f32vector-clamp!: Uvector numeric 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-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-set!: Uvector basic operations
f32vector-sub: Uvector numeric operations
f32vector-sub!: Uvector numeric operations
f32vector?: 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-clamp: Uvector numeric operations
f64vector-clamp!: Uvector numeric 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-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-set!: Uvector basic operations
f64vector-sub: Uvector numeric operations
f64vector-sub!: Uvector numeric operations
f64vector?: Uvector basic operations
feature-cond: Feature-based program configuration language
features: R7RS base library
fifth: SRFI-1 List utilities
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: SRFI-1 List utilities
first-ec: Eager comprehensions
first-set-bit: Integers as bits
fixnum-width: Arithmetics
fixnum?: Numerical predicates
fixnums: Random data generators
floor: Arithmetics
floor->exact: Arithmetics
fluid-let: Binding constructs
flush: Low-level output
flush-all-ports: Low-level output
flush-output-port: R7RS base library
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-each: Walking over lists
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: SRFI-1 List utilities
frexp: Numerical conversions
ftp-chdir: FTP
ftp-current-directory: FTP
ftp-get: FTP
ftp-help: FTP
ftp-list: FTP
ftp-login: FTP
ftp-mdtm: FTP
ftp-mkdir: FTP
ftp-mtime: 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

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->ideque: Immutable deques
generator->list: Generator consumers
generator->lseq: Lazy sequences
generator->lseq: Lazy sequences
generator->reverse-list: Generator consumers
generator->string: 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-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-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
getch: Text terminal control
getter-with-setter: Assignments
gettext: Localized messages
gfilter: Generator operations
gfilter-map: Generator operations
gflatten: 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
grange: Generator constructors
greatest-fixnum: Arithmetics
gremove: Generator operations
group-collection: Selection and searching in collection
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: Basic hash tables
hash-bound: Hashing
hash-by-identity: Basic hash tables
hash-salt: Hashing
hash-table: Hashtables
hash-table->alist: Hashtables
hash-table-clear!: Hashtables
hash-table-comparator: Hashtables
hash-table-copy: Hashtables
hash-table-delete!: Hashtables
hash-table-equivalence-function: Basic hash tables
hash-table-exists?: Hashtables
hash-table-fold: Hashtables
hash-table-for-each: Hashtables
hash-table-get: Hashtables
hash-table-hash-function: Basic hash tables
hash-table-keys: Hashtables
hash-table-map: Hashtables
hash-table-merge!: Basic hash tables
hash-table-num-entries: Hashtables
hash-table-pop!: Hashtables
hash-table-push!: Hashtables
hash-table-put!: Hashtables
hash-table-ref: Basic hash tables
hash-table-ref/default: Basic hash tables
hash-table-set!: Basic hash tables
hash-table-size: Basic hash tables
hash-table-type: Hashtables
hash-table-update!: Hashtables
hash-table-update!: Basic hash tables
hash-table-update!/default: Basic hash tables
hash-table-values: Hashtables
hash-table-walk: Basic hash tables
hash-table?: Hashtables
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-empty?: Hooks
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: Immutable deques
ideque->generator: Immutable deques
ideque->list: Immutable deques
ideque-add-back: Immutable deques
ideque-add-front: Immutable deques
ideque-any: Immutable deques
ideque-append: Immutable deques
ideque-append-map: Immutable deques
ideque-bakc: Immutable deques
ideque-break: Immutable deques
ideque-drop: Immutable deques
ideque-drop-right: Immutable deques
ideque-drop-while: Immutable deques
ideque-drop-while-right: Immutable deques
ideque-empty?: Immutable deques
ideque-every: Immutable deques
ideque-filter: Immutable deques
ideque-filter-map: Immutable deques
ideque-find: Immutable deques
ideque-find-right: Immutable deques
ideque-fold: Immutable deques
ideque-fold-right: Immutable deques
ideque-for-each: Immutable deques
ideque-for-each-right: Immutable deques
ideque-front: Immutable deques
ideque-length: Immutable deques
ideque-map: Immutable deques
ideque-partition: Immutable deques
ideque-ref: Immutable deques
ideque-remove: Immutable deques
ideque-remove-back: Immutable deques
ideque-remove-front: Immutable deques
ideque-reverse: Immutable deques
ideque-span: Immutable deques
ideque-split-at: Immutable deques
ideque-tabulate: Immutable deques
ideque-take: Immutable deques
ideque-take-right: Immutable deques
ideque-take-while: Immutable deques
ideque-take-while-right: Immutable deques
ideque-unfold: Immutable deques
ideque-unfold-right: Immutable deques
ideque-zip: Immutable deques
ideque=: Immutable deques
if: Conditionals
if: Conditionals
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-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
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: Bitwise operations
integer-length: Integers as bits
integer-range->char-set: SRFI-14 Character-set constructors
integer-range->char-set!: SRFI-14 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 library

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
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*-values: Let-values
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: Let-values
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->bag: Sets and bags
list->bag!: Sets and bags
list->char-set: SRFI-14 Character-set constructors
list->char-set!: SRFI-14 Character-set constructors
list->f16vector: Uvector conversion operations
list->f32vector: Uvector conversion operations
list->f64vector: Uvector conversion operations
list->generator: Generator constructors
list->ideque: 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: Sets and bags
list->set!: Sets and bags
list->stream: Stream library
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-copy: List constructors
list-ec: Eager comprehensions
list-index: SRFI-1 List utilities
list-queue: Queues based on lists
list-queue-add-back!: Queues based on lists
list-queue-add-front!: Queues based on lists
list-queue-append: Queues based on lists
list-queue-append!: Queues based on lists
list-queue-back: Queues based on lists
list-queue-concatenate: Queues based on lists
list-queue-copy: Queues based on lists
list-queue-empty?: Queues based on lists
list-queue-fist-last: Queues based on lists
list-queue-for-each: Queues based on lists
list-queue-front: Queues based on lists
list-queue-list: Queues based on lists
list-queue-map: Queues based on lists
list-queue-map!: Queues based on lists
list-queue-remove-all!: Queues based on lists
list-queue-remove-back!: Queues based on lists
list-queue-remove-front!: Queues based on lists
list-queue-set-list!: Queues based on lists
list-queue-unfold: Queues based on lists
list-queue-unfold-right: Queues based on lists
list-queue?: Queues based on lists
list-ref: List accessors and modifiers
list-set!: List accessors and modifiers
list-tabulate: SRFI-1 List utilities
list-tail: List accessors and modifiers
list=: SRFI-1 List utilities
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: Bitwise operations
logand: Integers as bits
logbit?: Bitwise operations
logbit?: Integers as bits
logcount: Bitwise operations
logcount: Integers as bits
logior: Bitwise operations
logior: Integers as bits
lognot: Bitwise operations
lognot: Integers as bits
logtest: Bitwise operations
logtest: Integers as bits
logxor: Bitwise operations
logxor: Integers as bits
lrange: Lazy sequences
lrxmatch: Lazy sequence utilities
lset-adjoin: SRFI-1 Set operations
lset-diff+intersection: SRFI-1 Set operations
lset-diff+intersection!: SRFI-1 Set operations
lset-difference: SRFI-1 Set operations
lset-difference!: SRFI-1 Set operations
lset-intersection: SRFI-1 Set operations
lset-intersection!: SRFI-1 Set operations
lset-union: SRFI-1 Set operations
lset-union!: SRFI-1 Set operations
lset-xor: SRFI-1 Set operations
lset-xor!: SRFI-1 Set operations
lset<=: SRFI-1 Set operations
lset=: SRFI-1 Set operations
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: Macro expansion
macroexpand-1: Macro expansion
macroexpand-all: Macro expansion
magnitude: Numerical conversions
make: Creating instance
make: Creating instance
make: Method instantiation
make-array: Arrays
make-bimap: Generic dictionaries
make-binary-heap: Heap
make-bits-generator: Generator constructors
make-byte-string: String Constructors
make-bytevector: R7RS base library
make-bytevector-comparator: Comparators
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-empty-attlist: SSAX data types
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-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: Basic hash tables
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: Queues based on lists
make-listwise-comparator: Comparators
make-lru-cache: Cache
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-promise: R7RS lazy evaluation
make-queue: Queue
make-random-source: Sources of random bits
make-range-generator: Generator constructors
make-rbtree: Obsoleted 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 library
make-string: String Constructors
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!: SRFI-1 List utilities
map$: Combinators
map$: Mapping over collection
map*: Walking over lists
map-accum: Mapping over collection
map-in-order: SRFI-1 List utilities
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
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: SRFI-1 List utilities
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: Eager comprehensions
not-pair?: SRFI-1 List utilities
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: 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: SRFI-1 List utilities
pair-fold-right: SRFI-1 List utilities
pair-for-each: SRFI-1 List utilities
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-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: SRFI-1 List utilities
partition!: SRFI-1 List utilities
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 library
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
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
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-wait: Process object
process-wait-any: Process object
process?: Process object
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-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
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: Obsoleted modules
rbtree-copy: Obsoleted modules
rbtree-delete!: Obsoleted modules
rbtree-empty?: Obsoleted modules
rbtree-exists?: Obsoleted modules
rbtree-extract-max!: Obsoleted modules
rbtree-extract-min!: Obsoleted modules
rbtree-fold: Obsoleted modules
rbtree-fold-right: Obsoleted modules
rbtree-get: Obsoleted modules
rbtree-keys: Obsoleted modules
rbtree-max: Obsoleted modules
rbtree-min: Obsoleted modules
rbtree-num-entries: Obsoleted modules
rbtree-pop!: Obsoleted modules
rbtree-push!: Obsoleted modules
rbtree-put!: Obsoleted modules
rbtree-update!: Obsoleted modules
rbtree-values: Obsoleted modules
rbtree?: Obsoleted 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: Fundamental sequence accessors
referencer: Fundamental sequence accessors
regexp: Using regular expressions
regexp->string: Using regular expressions
regexp-ast: Inspecting and assembling regular expressions
regexp-compile: Inspecting and assembling 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-quote: Using regular expressions
regexp-replace: Using regular expressions
regexp-replace*: Using regular expressions
regexp-replace-all: Using regular expressions
regexp-replace-all*: Using regular expressions
regexp-unparse: Inspecting and assembling regular expressions
regexp?: Using regular expressions
regmatch: Using regular expressions
regmatch: Using regular expressions
regmatch: Using regular expressions
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
reverse: Other list procedures
reverse!: Other list procedures
reverse-bit-field: Integers as bits
reverse-bits->generator: Generator constructors
reverse-list->string: SRFI-13 String Constructors
reverse-list->vector: Vectors
reverse-vector->generator: Generator constructors
reverse-vector->list: Vector library
rfc822-atom: RFC822 message parsing
rfc822-date->date: RFC822 message parsing
rfc822-dot-atom: RFC822 message parsing
rfc822-field->tokens: RFC822 message parsing
rfc822-header->list: RFC822 message parsing
rfc822-header-ref: RFC822 message parsing
rfc822-next-token: RFC822 message parsing
rfc822-parse-date: RFC822 message parsing
rfc822-quoted-string: RFC822 message parsing
rfc822-read-headers: RFC822 message parsing
rfc822-skip-cfws: RFC822 message parsing
rfc822-write-headers: RFC822 message parsing
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-elements: 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
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-process: Running subprocess
run-process-pipeline: Running multiple processes
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

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-clamp: Uvector numeric operations
s16vector-clamp!: Uvector numeric operations
s16vector-copy: Uvector basic operations
s16vector-copy!: Uvector basic operations
s16vector-dot: Uvector numeric 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-set!: Uvector basic operations
s16vector-sub: Uvector numeric operations
s16vector-sub!: Uvector numeric operations
s16vector-xor: Uvector numeric operations
s16vector-xor!: Uvector numeric operations
s16vector?: 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-clamp: Uvector numeric operations
s32vector-clamp!: Uvector numeric operations
s32vector-copy: Uvector basic operations
s32vector-copy!: Uvector basic operations
s32vector-dot: Uvector numeric 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-set!: Uvector basic operations
s32vector-sub: Uvector numeric operations
s32vector-sub!: Uvector numeric operations
s32vector-xor: Uvector numeric operations
s32vector-xor!: Uvector numeric operations
s32vector?: 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-clamp: Uvector numeric operations
s64vector-clamp!: Uvector numeric operations
s64vector-copy: Uvector basic operations
s64vector-copy!: Uvector basic operations
s64vector-dot: Uvector numeric 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-set!: Uvector basic operations
s64vector-sub: Uvector numeric operations
s64vector-sub!: Uvector numeric operations
s64vector-xor: Uvector numeric operations
s64vector-xor!: Uvector numeric operations
s64vector?: 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-clamp: Uvector numeric operations
s8vector-clamp!: Uvector numeric operations
s8vector-copy: Uvector basic operations
s8vector-copy!: Uvector basic operations
s8vector-dot: Uvector numeric 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-set!: Uvector basic operations
s8vector-sub: Uvector numeric operations
s8vector-sub!: Uvector numeric operations
s8vector-xor: Uvector numeric operations
s8vector-xor!: Uvector numeric operations
s8vector?: Uvector basic operations
samples$: Random data generators
samples-from: Random data generators
save-bundle!: Localization
scheme-report-environment: Eval and repl
second: SRFI-1 List utilities
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: Sets and bags
set!: Assignments
set!: Assignments
set!-values: Assignments
set->bag: Sets and bags
set->bag!: Sets and bags
set->list: Sets and bags
set-adjoin: Sets and bags
set-adjoin!: Sets and bags
set-any?: Sets and bags
set-box!: Boxes
set-car!: List accessors and modifiers
set-cdr!: List accessors and modifiers
set-character-attribute: Text terminal control
set-contains?: Sets and bags
set-copy: Sets and bags
set-count: Sets and bags
set-delete: Sets and bags
set-delete!: Sets and bags
set-delete-all: Sets and bags
set-delete-all!: Sets and bags
set-difference: Sets and bags
set-difference!: Sets and bags
set-disjoint?: Sets and bags
set-element-comparator: Sets and bags
set-empty?: Sets and bags
set-every?: Sets and bags
set-filter: Sets and bags
set-filter!: Sets and bags
set-find: Sets and bags
set-fold: Sets and bags
set-for-each: Sets and bags
set-intersection: Sets and bags
set-intersection!: Sets and bags
set-map: Sets and bags
set-member: Sets and bags
set-partition: Sets and bags
set-partition!: Sets and bags
set-remove: Sets and bags
set-remove!: Sets and bags
set-replace: Sets and bags
set-replace!: Sets and bags
set-search!: Sets and bags
set-signal-handler!: Handling signals
set-signal-pending-limit: Handling signals
set-size: Sets and bags
set-time-nanosecond!: SRFI-19 Time procedures
set-time-second!: SRFI-19 Time procedures
set-time-type!: SRFI-19 Time procedures
set-unfold: Sets and bags
set-union: Sets and bags
set-union!: Sets and bags
set-xor: Sets and bags
set-xor!: Sets and bags
set<=?: Sets and bags
set<?: Sets and bags
set=?: Sets and bags
set>=?: Sets and bags
set>?: Sets and bags
setter: Assignments
seventh: SRFI-1 List utilities
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
sixth: SRFI-1 List utilities
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-accept: Basic 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-close: Basic socket interface
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-input-port: Basic socket interface
socket-listen: Low-level socket interface
socket-merge-flags: Basic socket interface
socket-output-port: High-level network functions
socket-output-port: Basic socket interface
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-shutdown: Basic 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: SRFI-1 List utilities
span!: SRFI-1 List utilities
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
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: Stream library
stream->list: Stream library
stream->string: Stream library
stream-any: Stream library
stream-append: Stream library
stream-break: Stream library
stream-butlast: Stream library
stream-butlast-n: Stream library
stream-caaaar: Stream library
stream-caaadr: Stream library
stream-caaar: Stream library
stream-caadar: Stream library
stream-caaddr: Stream library
stream-caadr: Stream library
stream-caar: Stream library
stream-cadaar: Stream library
stream-cadadr: Stream library
stream-cadar: Stream library
stream-caddar: Stream library
stream-cadddr: Stream library
stream-caddr: Stream library
stream-cadr: Stream library
stream-car: Stream library
stream-cdaaar: Stream library
stream-cdaadr: Stream library
stream-cdaar: Stream library
stream-cdadar: Stream library
stream-cdaddr: Stream library
stream-cdadr: Stream library
stream-cdar: Stream library
stream-cddaar: Stream library
stream-cddadr: Stream library
stream-cddar: Stream library
stream-cdddar: Stream library
stream-cddddr: Stream library
stream-cdddr: Stream library
stream-cddr: Stream library
stream-cdr: Stream library
stream-concatenate: Stream library
stream-cons: Stream library
stream-cons*: Stream library
stream-count: Stream library
stream-delay: Stream library
stream-delete: Stream library
stream-delete-duplicates: Stream library
stream-drop: Stream library
stream-drop-safe: Stream library
stream-drop-while: Stream library
stream-eighth: Stream library
stream-every: Stream library
stream-fifth: Stream library
stream-filter: Stream library
stream-find: Stream library
stream-find-tail: Stream library
stream-first: Stream library
stream-for-each: Stream library
stream-format: Stream library
stream-fourth: Stream library
stream-grep: Stream library
stream-index: Stream library
stream-intersperse: Stream library
stream-last: Stream library
stream-last-n: Stream library
stream-length: Stream library
stream-length>=: Stream library
stream-lines: Stream library
stream-map: Stream library
stream-member: Stream library
stream-memq: Stream library
stream-memv: Stream library
stream-ninth: Stream library
stream-null?: Stream library
stream-pair?: Stream library
stream-partition: Stream library
stream-prefix=: Stream library
stream-ref: Stream library
stream-remove: Stream library
stream-reverse: Stream library
stream-second: Stream library
stream-seventh: Stream library
stream-sixth: Stream library
stream-span: Stream library
stream-split: Stream library
stream-tabulate: Stream library
stream-take: Stream library
stream-take-safe: Stream library
stream-take-while: Stream library
stream-tenth: Stream library
stream-third: Stream library
stream-unfoldn: Stream library
stream-xcons: Stream library
stream=: Stream library
stream?: Stream library
string: String Constructors
string->char-set: SRFI-14 Character-set constructors
string->char-set!: SRFI-14 Character-set constructors
string->date: SRFI-19 Date reader and writer
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 library
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-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-byte-ref: String Accessors & Modifiers
string-byte-set!: String Accessors & Modifiers
string-ci-hash: Hashing
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-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-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: 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-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-replace: SRFI-13 other string operations
string-replace!: Simple adjustable-size strings
string-reverse: SRFI-13 String reverse & append
string-reverse!: SRFI-13 String reverse & append
string-scan: String utilities
string-scan-right: String utilities
string-set!: String Accessors & Modifiers
string-size: String Accessors & Modifiers
string-skip: SRFI-13 String searching
string-skip-right: SRFI-13 String searching
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-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-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 pattern langauge
syntax-rules: Syntax-rules pattern langauge
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-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
sys-gethostbyaddr: Netdb interface
sys-gethostbyname: Netdb interface
sys-gethostname: System inquiry
sys-getlogin: System inquiry
sys-getpgid: System inquiry
sys-getpgrp: System inquiry
sys-getpid: System inquiry
sys-getppid: System inquiry
sys-getprotobyname: Netdb interface
sys-getprotobynumber: Netdb interface
sys-getpwnam: Unix groups and users
sys-getpwuid: Unix groups and users
sys-getrlimit: System inquiry
sys-getservbyname: Netdb interface
sys-getservbyport: Netdb interface
sys-gettimeofday: Time
sys-getuid: System inquiry
sys-gid->group-name: Unix groups and users
sys-glob: Directories
sys-gmtime: Time
sys-group-name->gid: Unix groups and users
sys-htonl: Netdb interface
sys-htons: Netdb interface
sys-isatty: Other file operations
sys-kill: Sending signals
sys-link: Directory manipulation
sys-localeconv: Locale
sys-localtime: Time
sys-logmask: Syslog
sys-lstat: File stats
sys-message-box: Windows dialogs
sys-mkdir: Directory manipulation
sys-mkdtemp: Directory manipulation
sys-mkfifo: Other file operations
sys-mkstemp: Directory manipulation
sys-mktime: Time
sys-nanosleep: Miscellaneous system calls
sys-normalize-pathname: Pathnames
sys-ntohl: Netdb interface
sys-ntohs: Netdb interface
sys-openlog: Syslog
sys-openpty: Posix termios interface
sys-pause: Miscellaneous system calls
sys-peek-console-input: Windows console API
sys-pipe: Other file operations
sys-putenv: Environment Inquiry
sys-random: Miscellaneous system calls
sys-read-console: Windows console API
sys-read-console-input: Windows console API
sys-read-console-output: Windows console API
sys-read-console-output-attribute: Windows console API
sys-read-console-output-character: Windows console API
sys-readdir: Directories
sys-readlink: Directory manipulation
sys-realpath: Pathnames
sys-remove: Directory manipulation
sys-rename: Directory manipulation
sys-rmdir: Directory manipulation
sys-scroll-console-screen-buffer: Windows console API
sys-select: I/O multiplexing
sys-select!: I/O multiplexing
sys-set-console-active-screen-buffer: Windows console API
sys-set-console-cp: Windows console API
sys-set-console-cursor-info: Windows console API
sys-set-console-cursor-position: Windows console API
sys-set-console-mode: Windows console API
sys-set-console-output-cp: Windows console API
sys-set-console-text-attribute: Windows console API
sys-set-console-window-info: Windows console API
sys-set-screen-buffer-size: Windows console API
sys-set-std-handle: Windows console API
sys-setenv: Environment Inquiry
sys-setgid: System inquiry
sys-setgroups: System inquiry
sys-setlocale: Locale
sys-setlogmask: Syslog
sys-setpgid: System inquiry
sys-setrlimit: System inquiry
sys-setsid: System inquiry
sys-setuid: System inquiry
sys-sigmask: Masking and waiting signals
sys-signal-name: Signals and signal sets
sys-sigset: Signals and signal sets
sys-sigset-add!: Signals and signal sets
sys-sigset-delete!: Signals and signal sets
sys-sigset-empty!: Signals and signal sets
sys-sigset-fill!: Signals and signal sets
sys-sigsuspend: Masking and waiting signals
sys-sigwait: Masking and waiting signals
sys-sleep: Miscellaneous system calls
sys-srandom: Miscellaneous system calls
sys-stat: File stats
sys-stat->atime: File stats
sys-stat->ctime: File stats
sys-stat->dev: File stats
sys-stat->file-type: File stats
sys-stat->gid: File stats
sys-stat->ino: File stats
sys-stat->mode: File stats
sys-stat->mtime: File stats
sys-stat->nlink: File stats
sys-stat->rdev: File stats
sys-stat->size: File stats
sys-stat->uid: File stats
sys-strerror: System inquiry
sys-strftime: Time
sys-symbol->errno: System inquiry
sys-symlink: Directory manipulation
sys-system: Process management
sys-tcdrain: Posix termios interface
sys-tcflow: Posix termios interface
sys-tcflush: Posix termios interface
sys-tcgetattr: Posix termios interface
sys-tcgetpgrp: Posix termios interface
sys-tcsendbreak: Posix termios interface
sys-tcsetattr: Posix termios interface
sys-tcsetpgrp: Posix termios interface
sys-time: Time
sys-times: System inquiry
sys-tm->alist: Time
sys-tmpdir: Pathnames
sys-tmpnam: Directory manipulation
sys-truncate: Other file operations
sys-ttyname: Other file operations
sys-uid->user-name: Unix groups and users
sys-umask: Directory manipulation
sys-uname: System inquiry
sys-unlink: Directory manipulation
sys-unsetenv: Environment Inquiry
sys-user-name->uid: Unix groups and users
sys-utime: File stats
sys-wait: Process management
sys-wait-exit-status: Process management
sys-wait-exited?: Process management
sys-wait-signaled?: Process management
sys-wait-stopped?: Process management
sys-wait-stopsig: Process management
sys-wait-termsig: Process management
sys-waitpid: Process management
sys-win-process-pid: Process management
sys-win-process?: Process management
sys-write-console: Windows console API
sys-write-console-output-character: Windows console API

tabulate-array: Arrays
take: List accessors and modifiers
take!: List accessors and modifiers
take*: List accessors and modifiers
take-after: SXPath basic converters and applicators
take-right: List accessors and modifiers
take-right*: List accessors and modifiers
take-until: SXPath basic converters and applicators
take-while: SRFI-1 List utilities
take-while!: SRFI-1 List utilities
tan: Arithmetics
tanh: Arithmetics
temporary-directory: Directory utilities
tenth: SRFI-1 List utilities
terminate-all!: Thread pools
terminated-thread-exception?: Thread exceptions
test: Unit testing
test*: Unit testing
test-check: Unit testing
test-end: Unit testing
test-error: Unit testing
test-log: Unit testing
test-module: Unit testing
test-none-of: Unit testing
test-one-of: Unit testing
test-record-file: Unit testing
test-script: Unit testing
test-section: Unit testing
test-start: Unit testing
test-summary-check: Unit testing
textdomain: Localized messages
textual-port?: R7RS base library
third: SRFI-1 List utilities
thread-cont!: Thread procedures
thread-join!: Thread procedures
thread-name: Thread procedures
thread-pool-results: Thread pools
thread-pool-shut-down?: Thread pools
thread-sleep!: Thread procedures
thread-specific: Thread procedures
thread-specific-set!: Thread procedures
thread-start!: Thread procedures
thread-state: Thread procedures
thread-stop!: Thread procedures
thread-terminate!: Thread procedures
thread-yield!: Thread procedures
thread?: Thread procedures
time: Measure timings
time->seconds: Time
time-counter-reset!: Measure timings
time-counter-start!: Measure timings
time-counter-stop!: Measure timings
time-counter-value: Measure timings
time-difference: SRFI-19 Time procedures
time-difference!: SRFI-19 Time procedures
time-monotonic->date: SRFI-19 Date
time-monotonic->julian-day: SRFI-19 Date
time-monotonic->modified-julian-day: SRFI-19 Date
time-monotonic->time-tai: SRFI-19 Date
time-monotonic->time-tai!: SRFI-19 Date
time-monotonic->time-utc: SRFI-19 Date
time-monotonic->time-utc!: SRFI-19 Date
time-nanosecond: SRFI-19 Time procedures
time-resolution: SRFI-19 Time queries
time-result+: Measure timings
time-result-: Measure timings
time-result-count: Measure timings
time-result-real: Measure timings
time-result-sys: Measure timings
time-result-user: Measure timings
time-result?: Measure timings
time-second: SRFI-19 Time procedures
time-tai->date: SRFI-19 Date
time-tai->julian-day: SRFI-19 Date
time-tai->modified-julian-day: SRFI-19 Date
time-tai->time-monotonic: SRFI-19 Date
time-tai->time-monotonic!: SRFI-19 Date
time-tai->time-utc: SRFI-19 Date
time-tai->time-utc!: SRFI-19 Date
time-these: Measure timings
time-these/report: Measure timings
time-this: Measure timings
time-type: SRFI-19 Time procedures
time-utc->date: SRFI-19 Date
time-utc->julian-day: SRFI-19 Date
time-utc->modified-julian-day: SRFI-19 Date
time-utc->time-monotonic: SRFI-19 Date
time-utc->time-monotonic!: SRFI-19 Date
time-utc->time-tai: SRFI-19 Date
time-utc->time-tai!: SRFI-19 Date
time<=?: SRFI-19 Time procedures
time<?: SRFI-19 Time procedures
time=?: SRFI-19 Time procedures
time>=?: SRFI-19 Time procedures
time>?: SRFI-19 Time procedures
time?: Time
topological-sort: Topological sort
totient: Prime numbers
touch-file: File operations
touch-files: File operations
tr: Transliterate characters
tree->string: Lazy text construction
tree-map->alist: Treemaps
tree-map->imap: Immutable map
tree-map-ceiling: Treemaps
tree-map-ceiling-key: Treemaps
tree-map-ceiling-value: Treemaps
tree-map-clear!: Treemaps
tree-map-comparator: Treemaps
tree-map-copy: Treemaps
tree-map-delete!: Treemaps
tree-map-empty?: Treemaps
tree-map-exists?: Treemaps
tree-map-floor: Treemaps
tree-map-floor-key: Treemaps
tree-map-floor-value: Treemaps
tree-map-fold: Treemaps
tree-map-fold-right: Treemaps
tree-map-for-each: Treemaps
tree-map-get: Treemaps
tree-map-keys: Treemaps
tree-map-map: Treemaps
tree-map-max: Treemaps
tree-map-min: Treemaps
tree-map-num-entries: Treemaps
tree-map-pop!: Treemaps
tree-map-pop-max!: Treemaps
tree-map-pop-min!: Treemaps
tree-map-predecessor: Treemaps
tree-map-predecessor-key: Treemaps
tree-map-predecessor-value: Treemaps
tree-map-push!: Treemaps
tree-map-put!: Treemaps
tree-map-successor: Treemaps
tree-map-successor-key: Treemaps
tree-map-successor-value: Treemaps
tree-map-update!: Treemaps
tree-map-values: Treemaps
trie: Trie
trie->hash-table: Trie
trie->list: Trie
trie-common-prefix: Trie
trie-common-prefix-fold: Trie
trie-common-prefix-for-each: Trie
trie-common-prefix-keys: Trie
trie-common-prefix-map: Trie
trie-common-prefix-values: Trie
trie-delete!: Trie
trie-exists?: Trie
trie-fold: Trie
trie-for-each: Trie
trie-get: Trie
trie-keys: Trie
trie-longest-match: Trie
trie-map: Trie
trie-num-entries: Trie
trie-partial-key?: Trie
trie-put!: Trie
trie-update!: Trie
trie-values: Trie
trie-with-keys: Trie
trie?: Trie
truncate: Arithmetics
truncate->exact: Arithmetics
tuples-of: Random data generators
twos-exponent: Bitwise operations
twos-exponent-factor: Bitwise operations

u16array: Arrays
u16vector: Uvector basic operations
u16vector->list: Uvector conversion operations
u16vector->vector: Uvector conversion operations
u16vector-add: Uvector numeric operations
u16vector-add!: Uvector numeric operations
u16vector-and: Uvector numeric operations
u16vector-and!: Uvector numeric operations
u16vector-append: Uvector basic operations
u16vector-clamp: Uvector numeric operations
u16vector-clamp!: Uvector numeric operations
u16vector-copy: Uvector basic operations
u16vector-copy!: Uvector basic operations
u16vector-dot: Uvector numeric operations
u16vector-fill!: Uvector basic operations
u16vector-ior: Uvector numeric operations
u16vector-ior!: Uvector numeric operations
u16vector-length: Uvector basic operations
u16vector-mul: Uvector numeric operations
u16vector-mul!: Uvector numeric operations
u16vector-multi-copy!: Uvector basic operations
u16vector-range-check: Uvector numeric operations
u16vector-ref: Uvector basic operations
u16vector-set!: Uvector basic operations
u16vector-sub: Uvector numeric operations
u16vector-sub!: Uvector numeric operations
u16vector-xor: Uvector numeric operations
u16vector-xor!: Uvector numeric operations
u16vector?: Uvector basic operations
u32array: Arrays
u32vector: Uvector basic operations
u32vector->list: Uvector conversion operations
u32vector->string: Uvector conversion operations
u32vector->vector: Uvector conversion operations
u32vector-add: Uvector numeric operations
u32vector-add!: Uvector numeric operations
u32vector-and: Uvector numeric operations
u32vector-and!: Uvector numeric operations
u32vector-append: Uvector basic operations
u32vector-clamp: Uvector numeric operations
u32vector-clamp!: Uvector numeric operations
u32vector-copy: Uvector basic operations
u32vector-copy!: Uvector basic operations
u32vector-dot: Uvector numeric operations
u32vector-fill!: Uvector basic operations
u32vector-ior: Uvector numeric operations
u32vector-ior!: Uvector numeric operations
u32vector-length: Uvector basic operations
u32vector-mul: Uvector numeric operations
u32vector-mul!: Uvector numeric operations
u32vector-multi-copy!: Uvector basic operations
u32vector-range-check: Uvector numeric operations
u32vector-ref: Uvector basic operations
u32vector-set!: Uvector basic operations
u32vector-sub: Uvector numeric operations
u32vector-sub!: Uvector numeric operations
u32vector-xor: Uvector numeric operations
u32vector-xor!: Uvector numeric operations
u32vector?: Uvector basic operations
u64array: Arrays
u64vector: Uvector basic operations
u64vector->list: Uvector conversion operations
u64vector->vector: Uvector conversion operations
u64vector-add: Uvector numeric operations
u64vector-add!: Uvector numeric operations
u64vector-and: Uvector numeric operations
u64vector-and!: Uvector numeric operations
u64vector-append: Uvector basic operations
u64vector-clamp: Uvector numeric operations
u64vector-clamp!: Uvector numeric operations
u64vector-copy: Uvector basic operations
u64vector-copy!: Uvector basic operations
u64vector-dot: Uvector numeric operations
u64vector-fill!: Uvector basic operations
u64vector-ior: Uvector numeric operations
u64vector-ior!: Uvector numeric operations
u64vector-length: Uvector basic operations
u64vector-mul: Uvector numeric operations
u64vector-mul!: Uvector numeric operations
u64vector-multi-copy!: Uvector basic operations
u64vector-range-check: Uvector numeric operations
u64vector-ref: Uvector basic operations
u64vector-set!: Uvector basic operations
u64vector-sub: Uvector numeric operations
u64vector-sub!: Uvector numeric operations
u64vector-xor: Uvector numeric operations
u64vector-xor!: Uvector numeric operations
u64vector?: Uvector basic operations
u8-ready?: R7RS base library
u8array: Arrays
u8vector: Uvector basic operations
u8vector->list: Uvector conversion operations
u8vector->string: Uvector conversion operations
u8vector->vector: Uvector conversion operations
u8vector-add: Uvector numeric operations
u8vector-add!: Uvector numeric operations
u8vector-and: Uvector numeric operations
u8vector-and!: Uvector numeric operations
u8vector-append: Uvector basic operations
u8vector-clamp: Uvector numeric operations
u8vector-clamp!: Uvector numeric operations
u8vector-copy: Uvector basic operations
u8vector-copy!: Uvector basic operations
u8vector-dot: Uvector numeric operations
u8vector-fill!: Uvector basic operations
u8vector-ior: Uvector numeric operations
u8vector-ior!: Uvector numeric operations
u8vector-length: Uvector basic operations
u8vector-mul: Uvector numeric operations
u8vector-mul!: Uvector numeric operations
u8vector-multi-copy!: Uvector basic operations
u8vector-range-check: Uvector numeric operations
u8vector-ref: Uvector basic operations
u8vector-set!: Uvector basic operations
u8vector-sub: Uvector numeric operations
u8vector-sub!: Uvector numeric operations
u8vector-xor: Uvector numeric operations
u8vector-xor!: Uvector numeric operations
u8vector?: Uvector basic operations
ucs->char: Characters
ucs-range->char-set: SRFI-14 Character-set constructors
ucs-range->char-set!: SRFI-14 Character-set constructors
ucs4->utf16: Unicode transfer encodings
ucs4->utf8: Unicode transfer encodings
uint16s: Random data generators
uint32s: Random data generators
uint64s: Random data generators
uint8s: Random data generators
unbox: Boxes
uncaught-exception-reason: Thread exceptions
uncaught-exception?: Thread exceptions
undefined: Undefined values
undefined?: Undefined values
unfold: SRFI-1 List utilities
unfold-right: SRFI-1 List utilities
unify: Unification
unify-merge: Unification
unless: Conditionals
unpack: Packing Binary Data
unpack-skip: Packing Binary Data
unquote: Quasiquotation
unquote-splicing: Quasiquotation
until: Iteration
until: Iteration
unwind-protect: Handling exceptions
unwrap-syntax: Macro utilities
unwrap-syntax: Identifiers
unzip1: SRFI-1 List utilities
unzip2: SRFI-1 List utilities
unzip3: SRFI-1 List utilities
unzip4: SRFI-1 List utilities
unzip5: SRFI-1 List utilities
update!: Assignments
uri-compose: URI parsing and construction
uri-compose-data: URI parsing and construction
uri-decode: URI parsing and construction
uri-decode-string: URI parsing and construction
uri-decompose-authority: URI parsing and construction
uri-decompose-data: URI parsing and construction
uri-decompose-hierarchical: URI parsing and construction
uri-encode: URI parsing and construction
uri-encode-string: URI parsing and construction
uri-merge: URI parsing and construction
uri-parse: URI parsing and construction
uri-ref: URI parsing and construction
uri-scheme&specific: URI parsing and construction
use: Using modules
utf16->ucs4: Unicode transfer encodings
utf16-length: Unicode transfer encodings
utf8->string: Unicode transfer encodings
utf8->ucs4: Unicode transfer encodings
utf8-length: Unicode transfer encodings
uvector->generator: Generator constructors
uvector-alias: Uvector conversion operations
uvector-class-element-size: Uvector basic operations
uvector-copy: Uvector basic operations
uvector-copy!: Uvector basic operations
uvector-length: Uvector basic operations
uvector-ref: Uvector basic operations
uvector-set!: Uvector basic operations
uvector-size: Uvector basic operations
uvector?: Uvector basic operations

valid-version-spec?: Comparing version numbers
values: Multiple values
values->list: Multiple values
values-ref: Multiple values
vector: Vectors
vector->f16vector: Uvector conversion operations
vector->f32vector: Uvector conversion operations
vector->f64vector: Uvector conversion operations
vector->generator: Generator constructors
vector->list: Vectors
vector->s16vector: Uvector conversion operations
vector->s32vector: Uvector conversion operations
vector->s64vector: Uvector conversion operations
vector->s8vector: Uvector conversion operations
vector->string: Vectors
vector->u16vector: Uvector conversion operations
vector->u32vector: Uvector conversion operations
vector->u64vector: Uvector conversion operations
vector->u8vector: Uvector conversion operations
vector-any: Vector library
vector-append: Vectors
vector-append-subvectors: Vector library
vector-binary-search: Vector library
vector-concatenate: Vector library
vector-copy: Vectors
vector-copy!: Vectors
vector-count: Vector library (Legacy)
vector-count: Vector library
vector-cumulate: Vector library
vector-ec: Eager comprehensions
vector-empty?: Vector library
vector-every: Vector library
vector-fill!: Vectors
vector-fold: Vector library (Legacy)
vector-fold: Vector library
vector-fold-right: Vector library (Legacy)
vector-fold-right: Vector library
vector-for-each: Vectors
vector-for-each: Vector library (Legacy)
vector-for-each-with-index: Vectors
vector-index: Vector library
vector-index-right: Vector library
vector-length: Vectors
vector-map: Vectors
vector-map: Vector library (Legacy)
vector-map!: Vectors
vector-map!: Vector library (Legacy)
vector-map-with-index: Vectors
vector-map-with-index!: Vectors
vector-of-length-ec: Eager comprehensions
vector-partition: Vector library
vector-ref: Vectors
vector-reverse!: Vector library
vector-reverse-copy: Vector library
vector-reverse-copy!: Vector library
vector-set!: Vectors
vector-skip: Vector library
vector-skip-right: Vector library
vector-swap!: Vector library
vector-tabulate: Vectors
vector-unfold: Vector library
vector-unfold!: Vector library
vector-unfold-right: Vector library
vector-unfold-right!: Vector library
vector=: Vector library
vector?: Vectors
vectors-of: Random data generators
vectors-of: Random data generators
version-compare: Comparing version numbers
version-satisfy?: Comparing version numbers
version<=?: Comparing version numbers
version<?: Comparing version numbers
version=?: Comparing version numbers
version>=?: Comparing version numbers
version>?: Comparing version numbers
vt100-compatible?: Text terminal control

wait-all: Thread pools
weak-vector-length: Weak pointers
weak-vector-ref: Weak pointers
weak-vector-set!: Weak pointers
weighted-samples-from: Random data generators
when: Conditionals
while: Iteration
while: Iteration
while: Iteration
with-builder: Fundamental iterator creators
with-character-attribute: Text terminal control
with-error-handler: Handling exceptions
with-error-to-port: Common port operations
with-exception-handler: Handling exceptions
with-input-conversion: Conversion ports
with-input-from-file: File ports
with-input-from-port: Common port operations
with-input-from-process: Process ports
with-input-from-string: String ports
with-iterator: Fundamental iterator creators
with-lock-file: Lock files
with-locking-mutex: Synchronization primitives
with-module: Defining and selecting modules
with-output-conversion: Conversion ports
with-output-to-file: File ports
with-output-to-port: Common port operations
with-output-to-process: Process ports
with-output-to-string: String ports
with-port-locking: Port and threads
with-ports: Common port operations
with-profiler: Profiler API
with-random-data-seed: Random data generators
with-signal-handlers: Handling signals
with-string-io: String ports
with-time-counter: Measure timings
without-echoing: Common high-level terminal control
wrap-with-input-conversion: Conversion ports
wrap-with-output-conversion: Conversion ports
write: Object output
write*: Object output
write-ber-integer: Binary I/O
write-block: Uvector block I/O
write-byte: Low-level output
write-bytevector: R7RS base library
write-char: Low-level output
write-controls-copy: Output controls
write-f16: Binary I/O
write-f32: Binary I/O
write-f64: Binary I/O
write-gauche-package-description: Package metainformation
write-object: Object output
write-s16: Binary I/O
write-s32: Binary I/O
write-s64: Binary I/O
write-s8: Binary I/O
write-shared: Object output
write-simple: Object output
write-sint: Binary I/O
write-stream: Stream library
write-string: R7RS base library
write-to-string: String ports
write-tree: Lazy text construction
write-tree: Lazy text construction
write-tree: Lazy text construction
write-u16: Binary I/O
write-u32: Binary I/O
write-u64: Binary I/O
write-u8: R7RS base library
write-u8: Binary I/O
write-uint: Binary I/O
write-uvector: Uvector block I/O
write-with-shared-structure: Object output
write/ss: Object output

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

zero?: Numerical predicates
zip: SRFI-1 List utilities
zlib-version: Zlib compression library
zstream-adler32: Zlib compression library
zstream-data-type: Zlib compression library
zstream-dictionary-adler32: Zlib compression library
zstream-params-set!: Zlib compression library
zstream-total-in: Zlib compression library
zstream-total-out: Zlib compression library

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

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