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