Function and Syntax Index (Gauche Users’ Reference)

Next: Module Index, Previous: C to Scheme mapping, Up: Top [Contents][Index]

Appendix B Function and Syntax Index ¶

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

-
	Index Entry	Section

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

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

!
	`!=`	CiSE syntax

?
	`?:`	CiSE syntax

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

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

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

*
	`*`	Arithmetics
	`*`	CiSE syntax
	`*`	CiSE syntax
	`*.`	Arithmetics
	`*=`	CiSE syntax

/
	`/`	Arithmetics
	`/`	CiSE syntax
	`/.`	Arithmetics
	`/=`	CiSE syntax

&
	`&`	CiSE syntax

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

^
	`^`	Making procedures
	`^_`	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

+
	`+`	Arithmetics
	`+`	CiSE syntax
	`+.`	Arithmetics
	`+=`	CiSE syntax

<
	`<`	Numerical comparison
	`<`	CiSE syntax
	`<?`	Comparator predicates and accessors
	`<<`	CiSE syntax
	`<<=`	CiSE syntax
	`<=`	Numerical comparison
	`<=`	CiSE syntax
	`<=?`	Comparator predicates and accessors

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

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

~
	`~`	Universal accessor

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Y
	`yield`	Coroutine generators

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

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