Next: Module Index, Previous: C to Scheme mapping, Up: Top [Contents][Index]
!=
$
$->rope
$->string
$->symbol
$.
$any
$assert
$between
$bind
$binding
$chain-left
$chain-right
$char
$char-ci
$cut
$debug
$end-by
$eos
$expect
$fail
$fold-parsers
$fold-parsers-right
$lazy
$lbinding
$let
$let*
$lift
$lift*
$list
$list*
$many
$many-till
$many-till_
$many1
$many1_
$many_
$match1
$match1*
$none-of
$not
$one-of
$optional
$or
$parameterize
$raise
$repeat
$repeat_
$return
$satisfy
$sep-by
$sep-end-by
$seq
$seq0
$string
$string-ci
$try
%
%=
%acos
%asin
%atan
%cos
%cosh
%cospi
%exp
%expt
%log
%macroexpand
%macroexpand-1
%sin
%sinh
%sinpi
%sqrt
%tan
%tanh
%tanpi
&
(setter cgi-test-environment-ref)
(setter dict-get)
(setter object-apply)
(setter port-buffering)
(setter ref)
(setter subseq)
(setter ~)
*
*.
*=
+
+.
+=
-
-.
-=
->
->char-set
.$
.array
.cond
.define
.function
.if
.include
.raw-c-code
.static-decls
.struct
.type
.undef
.union
.unless
.when
/
/.
/=
:
:char-range
:collection
:dispatched
:do
:generator
:integers
:let
:list
:parallel
:port
:range
:real-range
:string
:until
:uvector
:vector
:while
<
<<
<<=
<=
<=?
<?
<gauche-package-description>
=
==
=?
>
>=
>=?
>>
>>=
>?
?:
@?
@vector
@vector->list
@vector->vector
@vector-add
@vector-add!
@vector-and
@vector-and!
@vector-any
@vector-append
@vector-append-subvectors
@vector-clamp
@vector-clamp!
@vector-compare
@vector-concatenate
@vector-copy
@vector-copy!
@vector-count
@vector-cumulate
@vector-div
@vector-div!
@vector-dot
@vector-drop
@vector-drop-right
@vector-drop-while
@vector-drop-while-right
@vector-empty?
@vector-every
@vector-fill!
@vector-filter
@vector-fold
@vector-fold-right
@vector-for-each
@vector-index
@vector-index-right
@vector-ior
@vector-ior!
@vector-length
@vector-map
@vector-map!
@vector-mul
@vector-mul!
@vector-multi-copy!
@vector-partition
@vector-range-check
@vector-ref
@vector-remove
@vector-reverse!
@vector-reverse-copy
@vector-reverse-copy!
@vector-segment
@vector-set!
@vector-skip
@vector-skip-right
@vector-sub
@vector-sub!
@vector-swap!
@vector-take
@vector-take-right
@vector-take-while
@vector-take-while-right
@vector-unfold
@vector-unfold!
@vector-unfold-right
@vector-unfold-right!
@vector-xor
@vector-xor!
@vector=
@vector=?
@vector?
^
^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
^_
~
abandoned-mutex-exception?
abort-current-continuation
abs
absolute-path?
absolute-time
accumulate-generated-values
acons
acos
acosh
add-duration
add-duration!
add-hook!
add-inlet-input-port!
add-job!
add-load-path
add-outlet-output-port!
address-family
address-info
adler32
alist->bag
alist->hash-table
alist->hashmap
alist->hashmap!
alist->imap
alist->mapping
alist->mapping!
alist->mapping/ordered
alist->mapping/ordered!
alist->priority-map
alist->rbtree
alist->tree-map
alist-adjoin
alist-cons
alist-copy
alist-delete
alist-delete!
alist-key
alist-merge
alist-ref
alist-set!
alist-update-in
all-modules
all-of
allocate-instance
always
and
and-let*
and-let1
and-procedure
angle
any
any$
any-bit-set?
any-bits-set?
any-in-queue
any-of
any-pred
any?-ec
append
append!
append-ec
append-map
append-map!
append-reverse
append-reverse!
applicable?
apply
apply$
apply-chain
apply-generic
apply-method
apply-methods
apply/mv
approx=?
apropos
aref
args-fold
arguments-drop
arguments-drop-right
arguments-take
arguments-take-right
arithmetic-shift
arity
arity-at-least-value
arity-at-least?
array
array->list
array->vector
array-add-elements
array-add-elements!
array-concatenate
array-copy
array-div-elements
array-div-elements!
array-div-left
array-div-right
array-end
array-expt
array-flip
array-flip!
array-for-each-index
array-inverse
array-length
array-map
array-map!
array-mul
array-mul-elements
array-mul-elements!
array-negate-elements
array-negate-elements!
array-rank
array-reciprocate-elements
array-reciprocate-elements!
array-ref
array-retabulate!
array-rotate-90
array-set!
array-shape
array-size
array-start
array-sub-elements
array-sub-elements!
array-transpose
array?
as-black
as-blue
as-bold
as-cyan
as-green
as-magenta
as-nodeset
as-red
as-underline
as-unicode
as-white
as-yellow
ascii-alphabetic?
ascii-alphanumeric?
ascii-bytevecotr?
ascii-char?
ascii-ci<=?
ascii-ci<?
ascii-ci=?
ascii-ci>=?
ascii-ci>?
ascii-codepoint?
ascii-control->graphic
ascii-control?
ascii-digit-value
ascii-downcase
ascii-graphic->control
ascii-lower-case-value
ascii-lower-case?
ascii-mirror-bracket
ascii-non-control?
ascii-nth-digit
ascii-nth-lower-case
ascii-nth-upper-case
ascii-numeric?
ascii-other-graphic?
ascii-space-or-tab?
ascii-string-ci<=?
ascii-string-ci<?
ascii-string-ci=?
ascii-string-ci>=?
ascii-string-ci>?
ascii-string?
ascii-upcase
ascii-upper-case-value
ascii-upper-case?
ascii-whitespace?
ash
asin
asinh
assert-curr-char
assoc
assoc$
assoc-adjoin
assoc-ref
assoc-set!
assoc-update-in
assq
assq-ref
assq-set!
assume
assume-type
assv
assv-ref
assv-set!
atan
atanh
atom
atom-ref
atom?
atomic
atomic-update!
attlist->alist
attlist-add
attlist-fold
attlist-null?
attlist-remove-top
autoload
bag
bag->alist
bag->list
bag->set
bag-adjoin
bag-adjoin!
bag-any?
bag-contains?
bag-copy
bag-count
bag-decrement!
bag-delete
bag-delete!
bag-delete-all
bag-delete-all!
bag-difference
bag-difference!
bag-disjoint?
bag-element-comparator
bag-element-count
bag-empty?
bag-every?
bag-filter
bag-filter!
bag-find
bag-fold
bag-fold-unique
bag-for-each
bag-for-each-unique
bag-increment!
bag-intersection
bag-intersection!
bag-map
bag-member
bag-partition
bag-partition!
bag-product
bag-product!
bag-remove
bag-remove!
bag-replace
bag-replace!
bag-search!
bag-size
bag-sum
bag-sum!
bag-unfold
bag-union
bag-union!
bag-unique-size
bag-xor
bag-xor!
bag<=?
bag<?
bag=?
bag>=?
bag>?
balanced-quotient
balanced-remainder
balanced/
barrier-await
barrier-broken?
barrier-reset!
barrier?
base16-decode
base16-decode-string-to
base16-encode
base16-encode-message
base32-decode
base32-decode-string-to
base32-encode
base32-encode-message
base32hex-decode
base32hex-decode-string-to
base32hex-encode
base32hex-encode-message
base64->bytevector
base64-decode
base64-decode-bytevector
base64-decode-string
base64-decode-string-to
base64-encode
base64-encode-bytevector
base64-encode-message
base64-encode-string
bcrypt-gensalt
bcrypt-hashpw
beep
begin
begin-procedure
begin0
bignum?
bimap-left
bimap-left-delete!
bimap-left-exists?
bimap-left-get
bimap-put!
bimap-right
bimap-right-delete!
bimap-right-exists?
bimap-right-get
binary-heap-clear!
binary-heap-copy
binary-heap-delete!
binary-heap-empty?
binary-heap-find
binary-heap-find-max
binary-heap-find-min
binary-heap-num-entries
binary-heap-pop-max!
binary-heap-pop-min!
binary-heap-push!
binary-heap-remove!
binary-heap-swap-max!
binary-heap-swap-min!
binary-port?
bind
bind/box
bind/list
bind/mv
bindtextdomain
bit->boolean
bit->integer
bit-count
bit-field
bit-field-any?
bit-field-clear
bit-field-every?
bit-field-replace
bit-field-replace-same
bit-field-reverse
bit-field-rotate
bit-field-set
bit-set?
bit-swap
bits
bits->generator
bits->list
bits->vector
bitvector
bitvector->bool-generator
bitvector->index-generator
bitvector->int-generator
bitvector->integer
bitvector->list/bool
bitvector->list/int
bitvector->string
bitvector->vector/bool
bitvector->vector/int
bitvector-and
bitvector-and!
bitvector-andc1
bitvector-andc1!
bitvector-andc2
bitvector-andc2!
bitvector-any-value?
bitvector-append
bitvector-append-subbitvectors
bitvector-concatenate
bitvector-copy
bitvector-copy!
bitvector-count
bitvector-count-run
bitvector-drop
bitvector-drop-right
bitvector-emtpy?
bitvector-eqv
bitvector-eqv!
bitvector-every-value?
bitvector-field-any?
bitvector-field-clear
bitvector-field-clear!
bitvector-field-every?
bitvector-field-flip
bitvector-field-flip!
bitvector-field-replace
bitvector-field-replace!
bitvector-field-replace-same
bitvector-field-replace-same!
bitvector-field-rotate
bitvector-field-set
bitvector-field-set!
bitvector-first-bit
bitvector-fold-right/bool
bitvector-fold-right/int
bitvector-fold/bool
bitvector-fold/int
bitvector-for-each/bool
bitvector-for-each/int
bitvector-if
bitvector-ior
bitvector-ior!
bitvector-logical-shift
bitvector-map!/bool
bitvector-map!/int
bitvector-map->list/bool
bitvector-map->list/int
bitvector-map/bool
bitvector-map/int
bitvector-nand
bitvector-nand!
bitvector-nor
bitvector-nor!
bitvector-not
bitvector-not!
bitvector-orc1
bitvector-orc1!
bitvector-orc2
bitvector-orc2!
bitvector-pad
bitvector-pad-right
bitvector-prefix-length
bitvector-prefix?
bitvector-ref/bool
bitvector-ref/int
bitvector-reverse!
bitvector-reverse-copy
bitvector-reverse-copy!
bitvector-segment
bitvector-set!
bitvector-suffix-length
bitvector-suffix?
bitvector-swap!
bitvector-take
bitvector-take-right
bitvector-trim
bitvector-trim-both
bitvector-trim-right
bitvector-unfold
bitvector-unfold-right
bitvector-value-for-each-index
bitvector-value-map-index->list
bitvector-xor
bitvector-xor!
bitvector/bool-range
bitvector/int-range
bitvector=?
bitvector?
bitwise-and
bitwise-andc1
bitwise-andc2
bitwise-eqv
bitwise-fold
bitwise-for-each
bitwise-if
bitwise-ior
bitwise-merge
bitwise-nand
bitwise-nor
bitwise-not
bitwise-orc1
bitwise-orc2
bitwise-unfold
bitwise-xor
blob->sint-list
blob->u8-list
blob->uint-list
blob-copy
blob-copy!
blob-length
blob-s16-native-ref
blob-s16-native-set!
blob-s16-ref
blob-s16-set!
blob-s32-native-ref
blob-s32-native-set!
blob-s32-ref
blob-s32-set!
blob-s64-native-ref
blob-s64-native-set!
blob-s64-ref
blob-s64-set!
blob-s8-ref
blob-s8-set!
blob-sint-ref
blob-sint-set!
blob-u16-native-ref
blob-u16-native-set!
blob-u16-ref
blob-u16-set!
blob-u32-native-ref
blob-u32-native-set!
blob-u32-ref
blob-u32-set!
blob-u64-native-ref
blob-u64-native-set!
blob-u64-ref
blob-u64-set!
blob-u8-ref
blob-u8-set!
blob-uint-ref
blob-uint-set!
blob=?
blob?
boolean
boolean-hash
boolean=?
boolean?
booleans
booleans$
booleans->integer
box
box-arity
box-values
box/mv
box?
bpsw-prime?
break
break!
break-list-by-sequence
break-list-by-sequence!
build-binary-heap
build-path
build-transliterator
byte-ready?
bytestring
bytestring->list
bytestring-break
bytestring-error?
bytestring-index
bytestring-index-right
bytestring-join
bytestring-pad
bytestring-pad-right
bytestring-span
bytestring-split
bytestring-trim
bytestring-trim-both
bytestring-trim-right
bytestring<=?
bytestring<?
bytestring>=?
bytestring>?
bytevector
bytevector->base64
bytevector->generator
bytevector->hex-string
bytevector->sint-list
bytevector->string
bytevector->u8-list
bytevector->uint-list
bytevector->ulid
bytevector-accumulator
bytevector-accumulator!
bytevector-append
bytevector-copy
bytevector-copy!
bytevector-copy!-r6
bytevector-ieee-double-native-ref
bytevector-ieee-double-native-set!
bytevector-ieee-double-ref
bytevector-ieee-double-set!
bytevector-ieee-single-native-ref
bytevector-ieee-single-native-set!
bytevector-ieee-single-ref
bytevector-ieee-single-set!
bytevector-length
bytevector-s16-native-ref
bytevector-s16-native-set!
bytevector-s16-ref
bytevector-s16-set!
bytevector-s32-native-ref
bytevector-s32-native-set!
bytevector-s32-ref
bytevector-s32-set!
bytevector-s64-native-ref
bytevector-s64-native-set!
bytevector-s64-ref
bytevector-s64-set!
bytevector-s8-ref
bytevector-s8-set!
bytevector-sint-ref
bytevector-sint-set!
bytevector-u16-native-ref
bytevector-u16-native-set!
bytevector-u16-ref
bytevector-u16-set!
bytevector-u32-native-ref
bytevector-u32-native-set!
bytevector-u32-ref
bytevector-u32-set!
bytevector-u64-native-ref
bytevector-u64-native-set!
bytevector-u64-ref
bytevector-u64-set!
bytevector-u8-ref
bytevector-u8-set!
bytevector-uint-ref
bytevector-uint-set!
bytevector=?
bytevector?
bytrestring-replace
c128?
c128ite-u8vector
c128ke-u8vector-generator
c128vector
c128vector->list
c128vector->vector
c128vector-add
c128vector-add!
c128vector-any
c128vector-append
c128vector-append-subvectors
c128vector-compare
c128vector-concatenate
c128vector-copy
c128vector-copy!
c128vector-count
c128vector-cumulate
c128vector-div
c128vector-div!
c128vector-dot
c128vector-drop
c128vector-drop-right
c128vector-drop-while
c128vector-drop-while-right
c128vector-empty?
c128vector-every
c128vector-fill!
c128vector-filter
c128vector-fold
c128vector-for-each
c128vector-index
c128vector-index-right
c128vector-length
c128vector-map
c128vector-map!
c128vector-mul
c128vector-mul!
c128vector-multi-copy!
c128vector-partition
c128vector-ref
c128vector-remove
c128vector-reverse!
c128vector-reverse-copy
c128vector-reverse-copy!
c128vector-segment
c128vector-set!
c128vector-skip
c128vector-skip-right
c128vector-sub
c128vector-sub!
c128vector-swap!
c128vector-take
c128vector-take-right
c128vector-take-while
c128vector-take-while-right
c128vector-unfod-right!
c128vector-unfold
c128vector-unfold!
c128vector-unfold-right
c128vector-unfold-right!
c128vector=
c128vector=?
c128vector?
c32?
c32ite-u8vector
c32ke-u8vector-generator
c32vector
c32vector->list
c32vector->vector
c32vector-add
c32vector-add!
c32vector-any
c32vector-append
c32vector-append-subvectors
c32vector-compare
c32vector-concatenate
c32vector-copy
c32vector-copy!
c32vector-count
c32vector-cumulate
c32vector-div
c32vector-div!
c32vector-dot
c32vector-drop
c32vector-drop-right
c32vector-drop-while
c32vector-drop-while-right
c32vector-empty?
c32vector-every
c32vector-fill!
c32vector-filter
c32vector-fold
c32vector-for-each
c32vector-index
c32vector-index-right
c32vector-length
c32vector-map
c32vector-map!
c32vector-mul
c32vector-mul!
c32vector-multi-copy!
c32vector-partition
c32vector-ref
c32vector-remove
c32vector-reverse!
c32vector-reverse-copy
c32vector-reverse-copy!
c32vector-segment
c32vector-set!
c32vector-skip
c32vector-skip-right
c32vector-sub
c32vector-sub!
c32vector-swap!
c32vector-take
c32vector-take-right
c32vector-take-while
c32vector-take-while-right
c32vector-unfod-right!
c32vector-unfold
c32vector-unfold!
c32vector-unfold-right
c32vector-unfold-right!
c32vector=
c32vector=?
c32vector?
c64?
c64ite-u8vector
c64ke-u8vector-generator
c64vector
c64vector->list
c64vector->vector
c64vector-add
c64vector-add!
c64vector-any
c64vector-append
c64vector-append-subvectors
c64vector-compare
c64vector-concatenate
c64vector-copy
c64vector-copy!
c64vector-count
c64vector-cumulate
c64vector-div
c64vector-div!
c64vector-dot
c64vector-drop
c64vector-drop-right
c64vector-drop-while
c64vector-drop-while-right
c64vector-empty?
c64vector-every
c64vector-fill!
c64vector-filter
c64vector-fold
c64vector-for-each
c64vector-index
c64vector-index-right
c64vector-length
c64vector-map
c64vector-map!
c64vector-mul
c64vector-mul!
c64vector-multi-copy!
c64vector-partition
c64vector-ref
c64vector-remove
c64vector-reverse!
c64vector-reverse-copy
c64vector-reverse-copy!
c64vector-segment
c64vector-set!
c64vector-skip
c64vector-skip-right
c64vector-sub
c64vector-sub!
c64vector-swap!
c64vector-take
c64vector-take-right
c64vector-take-while
c64vector-take-while-right
c64vector-unfod-right!
c64vector-unfold
c64vector-unfold!
c64vector-unfold-right
c64vector-unfold-right!
c64vector=
c64vector=?
c64vector?
caaaar
caaadr
caaar
caadar
caaddr
caadr
caar
cache-check!
cache-clear!
cache-compact-queue!
cache-comparator
cache-evict!
cache-lookup!
cache-populate-queue!
cache-register!
cache-renumber-entries!
cache-storage
cache-through!
cache-write!
cadaar
cadadr
cadar
caddar
cadddr
caddr
cadr
calculate-dominators
call-with-builder
call-with-cgi-script
call-with-client-socket
call-with-console
call-with-continuation-prompt
call-with-current-continuation
call-with-ftp-connection
call-with-immediate-continuation-mark
call-with-input-conversion
call-with-input-file
call-with-input-process
call-with-input-string
call-with-iterator
call-with-iterators
call-with-output
call-with-output-conversion
call-with-output-file
call-with-output-process
call-with-output-string
call-with-parameterization
call-with-port
call-with-process-io
call-with-string-io
call-with-temporary-directory
call-with-temporary-file
call-with-temporary-filename
call-with-values
call/cc
call/mv
call/pc
car
car+cdr
car-sxpath
cartesian-product
cartesian-product-right
case
case-lambda
case-lambda/tag
case-procedure
case-receive
case/fallthrough
cast
cdaaar
cdaadr
cdaar
cdadar
cdaddr
cdadr
cdar
cddaar
cddadr
cddar
cdddar
cddddr
cdddr
cddr
cdr
ceiling
ceiling->exact
ceiling-quotient
ceiling-remainder
ceiling/
ces-conversion-supported?
ces-convert
ces-convert-to
ces-equivalent?
ces-guess-from-string
ces-upper-compatible?
cf$
cf-arg-enable
cf-arg-var
cf-arg-with
cf-check-decl
cf-check-decls
cf-check-func
cf-check-funcs
cf-check-header
cf-check-headers
cf-check-lib
cf-check-member
cf-check-members
cf-check-prog
cf-check-type
cf-check-types
cf-config-headers
cf-decl-available?
cf-define
cf-defined?
cf-echo
cf-feature-ref
cf-func-available?
cf-have-subst?
cf-header-available?
cf-help-string
cf-includes-default
cf-init
cf-init-gauche-extension
cf-lang
cf-lang-call
cf-lang-io-program
cf-lang-program
cf-lib-available?
cf-make-gpd
cf-member-available?
cf-msg-checking
cf-msg-error
cf-msg-notice
cf-msg-result
cf-msg-warn
cf-output
cf-output-default
cf-package-ref
cf-path-prog
cf-prog-cxx
cf-ref
cf-search-libs
cf-show-substs
cf-subst
cf-subst-append
cf-subst-prepend
cf-try-compile
cf-try-compile-and-link
cf-type-available?
cgen-add!
cgen-body
cgen-box-expr
cgen-cexpr
cgen-current-unit
cgen-decl
cgen-emit-body
cgen-emit-c
cgen-emit-decl
cgen-emit-h
cgen-emit-init
cgen-emit-xtrn
cgen-extern
cgen-init
cgen-literal
cgen-pred-expr
cgen-safe-comment
cgen-safe-name
cgen-safe-name-friendly
cgen-safe-string
cgen-type-from-name
cgen-unbox-expr
cgen-unit-c-file
cgen-unit-h-file
cgen-unit-init-name
cgen-with-cpp-condition
cgi-add-temporary-file
cgi-get-metavariable
cgi-get-parameter
cgi-header
cgi-main
cgi-metavariables
cgi-output-character-encoding
cgi-parse-parameters
cgi-temporary-files
cgi-test-environment-ref
chain
chain-and
chain-lambda
chain-when
change-class
change-object-class
char->integer
char->ucs
char-alphabetic?
char-ci-hash
char-ci<=?
char-ci<?
char-ci=?
char-ci>=?
char-ci>?
char-downcase
char-east-asian-width
char-foldcase
char-general-category
char-hash
char-lower-case?
char-numeric?
char-ready?
char-set
char-set->list
char-set->sre
char-set->string
char-set-adjoin
char-set-adjoin!
char-set-any
char-set-complement
char-set-complement!
char-set-contains?
char-set-copy
char-set-count
char-set-cursor
char-set-cursor-next
char-set-delete
char-set-delete!
char-set-diff+intersection
char-set-diff+intersection!
char-set-difference
char-set-difference!
char-set-every
char-set-filter
char-set-filter!
char-set-fold
char-set-for-each
char-set-hash
char-set-immutable?
char-set-intersection
char-set-intersection!
char-set-map
char-set-ref
char-set-size
char-set-unfold
char-set-unfold!
char-set-union
char-set-union!
char-set-xor
char-set-xor!
char-set<=
char-set=
char-set?
char-title-case?
char-titlecase
char-upcase
char-upper-case?
char-whitespace?
char-word-constituent?
char<=?
char<?
char=?
char>=?
char>?
char?
chars$
check
check-directory-tree
check-ec
check-passed?
check-report
check-reset!
check-set-mode!
check-substring-spec
chibi-test
chready?
circular-generator
circular-list
circular-list?
cise-ambient
cise-ambient-copy
cise-ambient-decl-strings
cise-default-ambient
cise-emit-source-line
cise-lookup-macro
cise-register-macro!
cise-render
cise-render-rec
cise-render-to-string
cise-translate
clamp
clamp-real-number
class-direct-methods
class-direct-slots
class-direct-subclasses
class-direct-supers
class-name
class-of
class-post-initialize
class-precedence-list
class-redefinition
class-slot-accessor
class-slot-bound?
class-slot-definition
class-slot-ref
class-slot-set!
class-slots
clear-screen
clear-to-eol
clear-to-eos
close-directory
close-input-port
close-output-port
close-port
coarity
code
codepoints->grapheme-clusters
codepoints->words
codepoints-downcase
codepoints-foldcase
codepoints-titlecase
codepoints-upcase
codeset-message
codeset-number
codeset-symbol
codeset-symbols
codeset?
coerce-to
columnar
combinations
combinations*
combinations*-for-each
combinations-for-each
combinations-of
combine-hash-value
command-args
command-line
command-name
common-prefix
common-prefix-to
comparator-check-type
comparator-compare
comparator-comparison-procedure
comparator-comparison-procedure?
comparator-equal?
comparator-equality-predicate
comparator-flavor
comparator-hash
comparator-hash-function
comparator-hash-function?
comparator-hashable?
comparator-max
comparator-min
comparator-min-in-list
comparator-ordered?
comparator-ordering-predicate
comparator-register-default!
comparator-test-type
comparator-type-test-procedure
comparator?
compare
complement
complete-sexp?
complex?
complexes-polar$
complexes-rectangular$
compose
compose-left
compose-right
compound-access
compound-filter
compound-length
compound-map
compound-map->list
compound-predicate
compound-ref
compound-subobjects
compound?
compute-cpl
compute-get-n-set
compute-slot-accessor
compute-slots
concatenate
concatenate!
concurrent-modification-violation?
cond
cond-expand
cond-list
condition
condition-has-type?
condition-message
condition-ref
condition-type?
condition-variable-broadcast!
condition-variable-name
condition-variable-signal!
condition-variable-specific
condition-variable-specific-set!
condition-variable?
condition?
conjoin
connection-address-name
connection-close
connection-input-port
connection-output-port
connection-peer-address
connection-self-address
connection-shutdown
cons
cons*
cons-stream
console-device
constantly
construct-cookie-string
construct-css
construct-edn
construct-edn-string
construct-json
construct-json-string
consume-trailing-whitespaces
continuation-mark-key?
continuation-mark-set->list
continuation-mark-set-first
continuation-mark-set?
continuation-marks
continuation-prompt-tag?
continuation-violation-prompt-tag
continuation-violation?
continue
continued-fraction
copy-bit
copy-bit-field
copy-directory*
copy-file
copy-port
copy-queue
copy-time
coroutine->cseq
coroutine->lseq
cos
cosh
count
count$
count-accumulator
cpu-architecture
crc32
create-directory
create-directory*
create-directory-tree
create-fifo
create-hard-link
create-symlink
create-temp-file
csv-rows->tuples
current-class-of
current-continuation-marks
current-country
current-date
current-directory
current-dynamic-extent
current-error-port
current-exception-handler
current-input-port
current-jiffy
current-julian-day
current-language
current-load-history
current-load-next
current-load-path
current-load-port
current-locale-details
current-log-callback
current-log-fields
current-modified-julian-day
current-module
current-output-port
current-parameterization
current-random-source
current-second
current-thread
current-time
current-trace-port
curried
cursor-down/scroll-up
cursor-up/scroll-down
cut
cute
d
date->julian-day
date->modified-julian-day
date->rfc822-date
date->string
date->time-monotonic
date->time-tai
date->time-utc
date-day
date-hour
date-minute
date-month
date-nanosecond
date-second
date-week-day
date-week-number
date-year
date-year-day
date-zone-offset
date?
dbi-close
dbi-connect
dbi-do
dbi-escape-sql
dbi-execute
dbi-execute-using-connection
dbi-list-drivers
dbi-make-connection
dbi-make-driver
dbi-open?
dbi-parse-dsn
dbi-prepare
dbi-prepare-sql
dbm-close
dbm-closed?
dbm-db-copy
dbm-db-exists?
dbm-db-move
dbm-db-remove
dbm-delete!
dbm-exists?
dbm-fold
dbm-for-each
dbm-get
dbm-map
dbm-open
dbm-put!
dbm-type->class
dcgettext
debug-funcall
debug-funcall-conditionally
debug-label
debug-print
debug-print-conditionally
debug-print-width
debug-source-info
dec!
declare-bundle!
declare-cfn
declare-cvar
declcode
decode-float
decompose-path
default-continuation-prompt-tag
default-endian
default-file-encoding
default-hash
default-mapper
default-sizer
default-tls-class
define
define-cclass
define-cfn
define-cgeneric
define-cise-expr
define-cise-macro
define-cise-stmt
define-cise-toplevel
define-class
define-cmethod
define-condition-type
define-constant
define-cproc
define-cptr
define-ctype
define-curried
define-cvar
define-dict-interface
define-enum
define-enum-conditionally
define-enumeration
define-gauche-package
define-generic
define-hybrid-syntax
define-in-module
define-inline
define-library
define-macro
define-method
define-module
define-optionals
define-optionals*
define-reader-ctor
define-record-type
define-stream
define-stub-type
define-symbol
define-syntactic-monad
define-syntax
define-values
define-variable
deflate-string
deflating-port-full-flush
degrees->radians
delay
delay-force
delete
delete!
delete$
delete-directory
delete-directory*
delete-duplicates
delete-duplicates!
delete-environment-variable!
delete-file
delete-files
delete-hook!
delete-keyword
delete-keyword!
delete-keywords
delete-keywords!
delete-neighbor-dups
delete-neighbor-dups!
delete-neighbor-dups-squeeze!
denominator
dequeue!
dequeue-all!
dequeue/wait!
describe
determinant
determinant!
dgettext
dict->alist
dict->priority-map
dict-clear!
dict-comparator
dict-delete!
dict-exists?
dict-fold
dict-fold-right
dict-for-each
dict-get
dict-keys
dict-map
dict-pop!
dict-push!
dict-put!
dict-update!
dict-values
diff
diff-report
diff-report/context
diff-report/unified
digest
digest-final!
digest-hexify
digest-message-to
digest-string
digest-to
digest-update!
digit->integer
digit-value
directory-files
directory-fold
directory-list
directory-list2
disasm
disjoin
display
display-multicolumn
display/pager
displayed
div
div-and-mod
div0
div0-and-mod0
dl-distance
dl-distances
do
do-ec
do-generator
do-pipeline
do-process
do-process!
dolist
dopairs
dotimes
dotted-ilist?
dotted-list?
drop
drop*
drop-right
drop-right!
drop-right*
drop-while
dynamic-extent?
dynamic-lambda
dynamic-load
dynamic-wind
each
each-in-list
each-of
eager
eager-and-procedure
eager-or-procedure
ecase
ed
ed-pick-file
ed-string
edn-equal?
edn-map
edn-object-handler
edn-object-payload
edn-object-tag
edn-object?
edn-set
edn-symbol-basename
edn-symbol-prefix
edn-valid-symbol-name?
edn-write
eighth
either->generation
either->list
either->list-truth
either->maybe
either->truth
either->values
either-and
either-bind
either-compose
either-filter
either-fold
either-for-each
either-guard
either-join
either-length
either-let*
either-let*-values
either-map
either-or
either-ref
either-ref/default
either-remove
either-sequence
either-swap
either-unfold
either=
either?
emergency-exit
encode-float
end-of-char-set?
endianness
enqueue!
enqueue-unique!
enqueue/wait!
enum-empty-set
enum-max
enum-min
enum-name
enum-name->enum
enum-name->ordinal
enum-name->value
enum-next
enum-ordinal
enum-ordinal->enum
enum-ordinal->name
enum-ordinal->value
enum-prev
enum-set
enum-set->enum-list
enum-set->list
enum-set-adjoin
enum-set-adjoin!
enum-set-any?
enum-set-complement
enum-set-complement!
enum-set-contains?
enum-set-copy
enum-set-costructor
enum-set-count
enum-set-delete
enum-set-delete!
enum-set-delete-all
enum-set-delete-all!
enum-set-difference
enum-set-difference!
enum-set-disjoint?
enum-set-empty?
enum-set-every?
enum-set-filter
enum-set-fold
enum-set-for-each
enum-set-indexer
enum-set-intersection
enum-set-intersection!
enum-set-map->list
enum-set-member?
enum-set-projection
enum-set-remove
enum-set-size
enum-set-subset?
enum-set-type
enum-set-union
enum-set-union!
enum-set-universe
enum-set-xor
enum-set-xor!
enum-set<=?
enum-set<?
enum-set=?
enum-set>=?
enum-set>?
enum-set?
enum-type
enum-type->enum-set
enum-type-contains?
enum-type-enums
enum-type-names
enum-type-size
enum-type-values
enum-type?
enum-value
enum<=?
enum<?
enum=?
enum>=?
enum>?
enum?
environment
eof-object
eof-object?
ephemeron-broken?
ephemeron-datum
ephemeron-key
ephemeron?
eq-compare
eq-hash
eq?
equal?
eqv-hash
eqv?
er-macro-transformer
error
error-object-irritants
error-object-message
error-object?
error?
errorf
escaped
etypecase
euclidean-quotient
euclidean-remainder
euclidean/
eval
even?
every
every$
every-bit-set?
every-in-queue
every-pred
every?-ec
exact
exact->inexact
exact-integer-sqrt
exact-integer?
exact?
exception->either
exception-handler-stack
exit
exit-handler
exp
expand-path
expand-template-file
expand-template-string
export
export-all
expt
expt-mod
extend
extended-cons
extended-list
extended-pair?
external-conversion-library
extract-condition
f16?
f16array
f16ite-u8vector
f16ke-u8vector-generator
f16vector
f16vector->list
f16vector->vector
f16vector-add
f16vector-add!
f16vector-any
f16vector-append
f16vector-append-subvectors
f16vector-clamp!
f16vector-compare
f16vector-concatenate
f16vector-copy
f16vector-copy!
f16vector-count
f16vector-cumulate
f16vector-div
f16vector-div!
f16vector-dot
f16vector-drop
f16vector-drop-right
f16vector-drop-while
f16vector-drop-while-right
f16vector-empty?
f16vector-every
f16vector-fill!
f16vector-filter
f16vector-fold
f16vector-for-each
f16vector-index
f16vector-index-right
f16vector-length
f16vector-map
f16vector-map!
f16vector-mul
f16vector-mul!
f16vector-multi-copy!
f16vector-partition
f16vector-range-check
f16vector-ref
f16vector-remove
f16vector-reverse!
f16vector-reverse-copy
f16vector-reverse-copy!
f16vector-segment
f16vector-set!
f16vector-skip
f16vector-skip-right
f16vector-sub
f16vector-sub!
f16vector-swap!
f16vector-take
f16vector-take-right
f16vector-take-while
f16vector-take-while-right
f16vector-unfod-right!
f16vector-unfold
f16vector-unfold!
f16vector-unfold-right
f16vector-unfold-right!
f16vector=
f16vector=?
f16vector?
f32?
f32array
f32ite-u8vector
f32ke-u8vector-generator
f32vector
f32vector->list
f32vector->vector
f32vector-add
f32vector-add!
f32vector-any
f32vector-append
f32vector-append-subvectors
f32vector-clamp
f32vector-clamp!
f32vector-compare
f32vector-concatenate
f32vector-copy
f32vector-copy!
f32vector-count
f32vector-cumulate
f32vector-div
f32vector-div!
f32vector-dot
f32vector-drop
f32vector-drop-right
f32vector-drop-while
f32vector-drop-while-right
f32vector-empty?
f32vector-every
f32vector-fill!
f32vector-filter
f32vector-fold
f32vector-for-each
f32vector-index
f32vector-index-right
f32vector-length
f32vector-map
f32vector-map!
f32vector-mul
f32vector-mul!
f32vector-multi-copy!
f32vector-partition
f32vector-range-check
f32vector-ref
f32vector-remove
f32vector-reverse!
f32vector-reverse-copy
f32vector-reverse-copy!
f32vector-segment
f32vector-set!
f32vector-skip
f32vector-skip-right
f32vector-sub
f32vector-sub!
f32vector-swap!
f32vector-take
f32vector-take-right
f32vector-take-while
f32vector-take-while-right
f32vector-unfod-right!
f32vector-unfold
f32vector-unfold!
f32vector-unfold-right
f32vector-unfold-right!
f32vector=
f32vector=?
f32vector?
f64?
f64array
f64ite-u8vector
f64ke-u8vector-generator
f64vector
f64vector->list
f64vector->vector
f64vector-add
f64vector-add!
f64vector-any
f64vector-append
f64vector-append-subvectors
f64vector-clamp
f64vector-clamp!
f64vector-compare
f64vector-concatenate
f64vector-copy
f64vector-copy!
f64vector-count
f64vector-cumulate
f64vector-div
f64vector-div!
f64vector-dot
f64vector-drop
f64vector-drop-right
f64vector-drop-while
f64vector-drop-while-right
f64vector-empty?
f64vector-every
f64vector-fill!
f64vector-filter
f64vector-fold
f64vector-for-each
f64vector-index
f64vector-index-right
f64vector-length
f64vector-map
f64vector-map!
f64vector-mul
f64vector-mul!
f64vector-multi-copy!
f64vector-partition
f64vector-range-check
f64vector-ref
f64vector-remove
f64vector-reverse!
f64vector-reverse-copy
f64vector-reverse-copy!
f64vector-segment
f64vector-set!
f64vector-skip
f64vector-skip-right
f64vector-sub
f64vector-sub!
f64vector-swap!
f64vector-take
f64vector-take-right
f64vector-take-while
f64vector-take-while-right
f64vector-unfod-right!
f64vector-unfold
f64vector-unfold!
f64vector-unfold-right
f64vector-unfold-right!
f64vector=
f64vector=?
f64vector?
fd->port
feature-cond
features
fifth
file->byte-generator
file->char-generator
file->generator
file->line-generator
file->list
file->sexp-generator
file->sexp-list
file->string
file->string-list
file-atime
file-atime<=?
file-atime<?
file-atime=?
file-atime>=?
file-atime>?
file-ctime
file-ctime<=?
file-ctime<?
file-ctime=?
file-ctime>=?
file-ctime>?
file-dev
file-eq?
file-equal?
file-eqv?
file-error?
file-exists?
file-filter
file-filter-fold
file-filter-for-each
file-filter-map
file-gid
file-info
file-info-device?
file-info-directory?
file-info-fifo?
file-info-regular?
file-info-socket?
file-info-symlink?
file-info:atime
file-info:blksize
file-info:blocks
file-info:ctime
file-info:device
file-info:gid
file-info:inode
file-info:mode
file-info:mtime
file-info:nlinks
file-info:rdev
file-info:size
file-info:uid
file-info?
file-ino
file-is-directory?
file-is-executable?
file-is-readable?
file-is-regular?
file-is-symlink?
file-is-writable?
file-mode
file-mtime
file-mtime<=?
file-mtime<?
file-mtime=?
file-mtime>=?
file-mtime>?
file-nlink
file-perm
file-rdev
file-size
file-space
file-type
file-uid
files
filter
filter!
filter$
filter-map
filter-to
find
find$
find-file-in-paths
find-gauche-package-description
find-in-queue
find-index
find-max
find-min
find-min&max
find-module
find-string-from-port?
find-tail
find-tail$
find-with-index
finite-flonums$
finite?
first
first-ec
first-set-bit
fitted
fitted/both
fitted/right
fixnum-width
fixnum?
fixnums
fixnums$
fl*
fl+
fl+*
fl-
fl<=?
fl<?
fl=?
fl>=?
fl>?
flabs
flabsdiff
flacos
flacosh
fladjacent
flasin
flasinh
flatan
flatanh
flcbrt
flceiling
flcopysign
flcos
flcosh
fldenominator
fldenormalized?
flerf
flerfc
fleven?
flexp
flexp-1
flexp2
flexponent
flexpt
flfinite?
flfirst-bessel
flfloor
flgamma
flhypot
flinfinite?
flinteger-exponent
flinteger-fraction
flinteger?
flip
fllog
fllog1+
fllog10
fllog2
flloggamma
flmax
flmin
flnan?
flnevative?
flnormalized-fraction-exponent
flnormalized?
flnumerator
flodd?
flonum
flonum-epsilon
flonum-min-denormalized
flonum-min-normalized
flonum?
floor
floor->exact
floor-quotient
floor-remainder
floor/
flposdiff
flpositive?
flquotient
flremainder
flremquo
flround
flsecond-bessel
flsgn
flsign-bit
flsin
flsinh
flsqrt
flsquare
fltan
fltanh
fltruncate
fluid-let
flunordered?
flush
flush-all-ports
flush-output-port
flzero?
fmod
fn
fold
fold$
fold-ec
fold-left
fold-right
fold-right$
fold-with-index
fold2
fold3
fold3-ec
for
for-each
for-each$
for-each-with-index
force
forked
format
fourth
free-identifier=?
fresh-line
frexp
from-file
ftp-chdir
ftp-current-directory
ftp-get
ftp-help
ftp-list
ftp-login
ftp-ls
ftp-mdtm
ftp-mkdir
ftp-mtime
ftp-name-list
ftp-noop
ftp-passive?
ftp-put
ftp-put-unique
ftp-quit
ftp-remove
ftp-rename
ftp-rmdir
ftp-site
ftp-size
ftp-stat
ftp-system
ftp-transfer-type
funcall-procedure
future
future-done?
future-get
future?
fx*
fx*/carry
fx+
fx+/carry
fx-
fx-/carry
fx<=?
fx<?
fx=?
fx>=?
fx>?
fxabs
fxand
fxarithmetic-shift
fxbit-count
fxbit-field
fxbit-field-rotate
fxbit-set?
fxcopy-bit
fxeven?
fxfirst-set-bit
fxif
fxior
fxlength
fxmax
fxmin
fxneg
fxnegative?
fxnot
fxodd?
fxpositive?
fxquotient
fxremainder
fxsqrt
fxsquare
fxxor
fxzero?
gamma
gap-buffer->generator
gap-buffer->string
gap-buffer-capacity
gap-buffer-clear!
gap-buffer-contains
gap-buffer-content-length
gap-buffer-copy
gap-buffer-delete!
gap-buffer-edit!
gap-buffer-gap-at?
gap-buffer-insert!
gap-buffer-looking-at?
gap-buffer-move!
gap-buffer-pos
gap-buffer-pos-at-end?
gap-buffer-ref
gap-buffer-replace!
gap-buffer-set!
gap-buffer?
gappend
gauche-architecture
gauche-architecture-directory
gauche-character-encoding
gauche-config
gauche-library-directory
gauche-package-description-paths
gauche-site-architecture-directory
gauche-site-library-directory
gauche-thread-type
gauche-version
gbuffer-filter
gc
gc-stat
gcd
gchoice
gcombine
gcompose-left
gcompose-right
gconcatenate
gcons*
gdbm-close
gdbm-closed?
gdbm-delete
gdbm-errno
gdbm-exists?
gdbm-fetch
gdbm-firstkey
gdbm-nextkey
gdbm-open
gdbm-reorganize
gdbm-setopt
gdbm-store
gdbm-strerror
gdbm-sync
gdbm-version
gdelete
gdelete-neighbor-dups
gdrop
gdrop-while
generate
generation->either
generation->maybe
generator
generator->bytevector
generator->bytevector!
generator->cseq
generator->ideque
generator->list
generator->lseq
generator->lseq/position
generator->reverse-list
generator->stream
generator->string
generator->uvector
generator->uvector!
generator->vector
generator->vector!
generator-any
generator-count
generator-every
generator-find
generator-fold
generator-fold-right
generator-for-each
generator-map
generator-map->list
generator-unfold
gensym
genumerate
get-environment-variable
get-environment-variables
get-f16
get-f16be
get-f16le
get-f32
get-f32be
get-f32le
get-f64
get-f64be
get-f64le
get-keyword
get-keyword*
get-optional
get-output-bytevector
get-output-string
get-output-uvector
get-remaining-input-generator
get-remaining-input-list
get-remaining-input-string
get-s16
get-s16be
get-s16le
get-s32
get-s32be
get-s32le
get-s64
get-s64be
get-s64le
get-s8
get-signal-handler
get-signal-handler-mask
get-signal-handlers
get-signal-pending-limit
get-sint
get-u16
get-u16be
get-u16le
get-u32
get-u32be
get-u32le
get-u64
get-u64be
get-u64le
get-u8
get-uint
getch
getter-with-setter
gettext
gfilter
gfilter-map
gflatten
ggroup
gindex
giota
giterate
giterate1
glet*
glet1
glob
glob-fold
global-variable-bound?
global-variable-ref
gmap
gmap-accum
gmerge
goto
grange
greatest-fixnum
greatest-positive-flonum
gremove
group-by
group-collection
group-collection->alist
group-contiguous-sequence
group-info
group-info:gid
group-info:name
group-info?
group-sequence
grxmatch
gsampling
gselect
gslices
gstate-filter
gtake
gtake*
gtake-while
guard
gunfold
gzip-decode-string
gzip-encode-string
has-setter?
has-windows-console?
hash
hash-bound
hash-by-identity
hash-salt
hash-table
hash-table->alist
hash-table-clear!
hash-table-comparator
hash-table-compare-as-sets
hash-table-contains?
hash-table-copy
hash-table-count
hash-table-delete!
hash-table-delete!-r7
hash-table-difference!
hash-table-empty-copy
hash-table-equivalence-function
hash-table-exists?
hash-table-find
hash-table-fold
hash-table-for-each
hash-table-from-pairs
hash-table-get
hash-table-hash-function
hash-table-intern!
hash-table-intern!-r7
hash-table-intersection!
hash-table-keys
hash-table-map
hash-table-map!
hash-table-map->list
hash-table-merge!
hash-table-mutable?
hash-table-num-entries
hash-table-pop!
hash-table-pop!-r7
hash-table-prune!
hash-table-push!
hash-table-put!
hash-table-r7
hash-table-ref
hash-table-ref/default
hash-table-set!
hash-table-size
hash-table-type
hash-table-unfold
hash-table-union!
hash-table-update!
hash-table-update!-r7
hash-table-update!/default
hash-table-values
hash-table-walk
hash-table-xor!
hash-table=?
hash-table?
hashmap
hashmap->alist
hashmap-adjoin
hashmap-adjoin!
hashmap-any?
hashmap-contains?
hashmap-copy
hashmap-count
hashmap-delete
hashmap-delete!
hashmap-delete-all
hashmap-delete-all!
hashmap-difference
hashmap-difference!
hashmap-disjoint?
hashmap-empty?
hashmap-entries
hashmap-every?
hashmap-filter
hashmap-filter!
hashmap-find
hashmap-fold
hashmap-for-each
hashmap-intern
hashmap-intern!
hashmap-intersection
hashmap-intersection!
hashmap-key-comparator
hashmap-keys
hashmap-map
hashmap-map->list
hashmap-partition
hashmap-partition!
hashmap-pop
hashmap-pop!
hashmap-ref
hashmap-ref/default
hashmap-remove
hashmap-remove!
hashmap-replace
hashmap-replace!
hashmap-search
hashmap-search!
hashmap-set
hashmap-set!
hashmap-size
hashmap-unfold
hashmap-union
hashmap-union!
hashmap-update
hashmap-update!
hashmap-update!/default
hashmap-update/default
hashmap-values
hashmap-xor
hashmap-xor!
hashmap<=?
hashmap<?
hashmap=?
hashmap>=?
hashmap>?
hashmap?
hex-string->bytevector
hide-cursor
hmac-digest
hmac-digest-string
hmac-final!
hmac-message
hmac-message-to
hmac-to
hmac-update!
hmac-verify
home-directory
hook->list
hook-add!
hook-delete!
hook-empty?
hook-reset!
hook-run
hook?
html-doctype
html-escape
html-escape-string
html:a
html:abbr
html:acronym
html:address
html:area
html:b
html:base
html:bdo
html:big
html:blockquote
html:body
html:br
html:button
html:caption
html:cite
html:code
html:col
html:colgroup
html:dd
html:del
html:dfn
html:div
html:dl
html:dt
html:em
html:fieldset
html:form
html:frame
html:frameset
html:h1
html:h2
html:h3
html:h4
html:h5
html:h6
html:head
html:hr
html:html
html:i
html:iframe
html:img
html:input
html:ins
html:kbd
html:label
html:legend
html:li
html:link
html:map
html:meta
html:noframes
html:noscript
html:object
html:ol
html:optgroup
html:option
html:p
html:param
html:pre
html:q
html:samp
html:script
html:select
html:small
html:span
html:strong
html:style
html:sub
html:sup
html:table
html:tbody
html:td
html:textarea
html:tfoot
html:th
html:thead
html:title
html:tr
html:tt
html:ul
html:var
http-compose-form-data
http-compose-query
http-default-redirect-handler
http-delete
http-get
http-head
http-post
http-proxy
http-put
http-secure-connection-available?
http-status-code->description
http-user-agent
i/o-decoding-error?
i/o-encoding-error-char
i/o-encoding-error?
i/o-invalid-position-error?
iany
iapply
iassoc
iassq
iassv
icaaaar
icaaadr
icaaar
icaadar
icaaddr
icaadr
icaar
icadaar
icadadr
icadar
icaddar
icadddr
icaddr
icadr
icar
icar+icdr
icdaaar
icdaadr
icdaar
icdadar
icdaddr
icdadr
icdar
icddaar
icddadr
icddar
icdddar
icddddr
icdddr
icddr
icdr
icmp-packet-code
icmp-packet-ident
icmp-packet-sequence
icmp-packet-type
icmp4-describe-packet
icmp4-exceeded-code->string
icmp4-fill-checksum!
icmp4-fill-echo!
icmp4-message-type->string
icmp4-parameter-code->string
icmp4-redirect-code->string
icmp4-router-code->string
icmp4-security-code->string
icmp4-unreach-code->string
icmp6-describe-packet
icmp6-exceeded-code->string
icmp6-fill-echo!
icmp6-message-type->string
icmp6-parameter-code->string
icmp6-unreach-code->string
icount
identifier->symbol
identifier?
identity
identity-array
ideque
ideque->generator
ideque->list
ideque-add-back
ideque-add-front
ideque-any
ideque-append
ideque-append-map
ideque-back
ideque-break
ideque-drop
ideque-drop-right
ideque-drop-while
ideque-drop-while-right
ideque-empty?
ideque-every
ideque-filter
ideque-filter-map
ideque-find
ideque-find-right
ideque-fold
ideque-fold-right
ideque-for-each
ideque-for-each-right
ideque-front
ideque-length
ideque-map
ideque-partition
ideque-ref
ideque-remove
ideque-remove-back
ideque-remove-front
ideque-reverse
ideque-span
ideque-split-at
ideque-tabulate
ideque-take
ideque-take-right
ideque-take-while
ideque-take-while-right
ideque-unfold
ideque-unfold-right
ideque-zip
ideque=
ideque?
idrop
idrop-while
ieighth
ievery
if
if-car-sxpath
if-let1
if-not=?
if-procedure
if-sxpath
if3
if<=?
if<?
if=?
if>=?
if>?
ififth
ifind-tail
ifirst
ifold
ifold-right
ifor-each
ifourth
ilast
ilength
ilist
ilist-index
ilist-ref
ilist-tail
ilist=
ilist?
imag-part
imap-delete
imap-empty?
imap-exists?
imap-get
imap-max
imap-min
imap-put
imap?
imember
imemq
imemv
implementation-name
implementation-version
import
in-closed-interval?
in-closed-open-interval?
in-open-closed-interval?
in-open-interval?
inc!
include
include-ci
independently
inet-address->string
inet-checksum
inet-string->address
inet-string->address!
inexact
inexact->exact
inexact->timespec
inexact?
infinite?
inflate-string
inflate-sync
info
info-extract-definition
info-get-node
info-index->alist
info-index-add!
info-index-keys
info-index-ref
info-parse-menu
info-search
ininth
initcode
initialize
input-port-open?
input-port?
instance-of
instance-pool->list
instance-pool-find
instance-pool-fold
instance-pool-for-each
instance-pool-map
instance-pool-remove!
int16s
int16s$
int32s
int32s$
int64s
int64s$
int8s
int8s$
integer->bitvector
integer->char
integer->digit
integer->list
integer->ulid
integer-length
integer-range->char-set
integer-range->char-set!
integer-valued?
integer?
integers$
integers-between$
integers-geometric$
integers-poisson$
interaction-environment
intersperse
inverse
iota
iota-range
ip-destination-address
ip-header-length
ip-protocol
ip-source-address
ip-version
ipair
ipair-fold
ipair-fold-right
ipair-for-each
ipair?
ireduce
ireduce-right
is-a?
isecond
iset
iset->list
iset-adjoin
iset-adjoin!
iset-any?
iset-closed-interval
iset-closed-open-interval
iset-contains?
iset-copy
iset-count
iset-delete
iset-delete!
iset-delete-all
iset-delete-all!
iset-delete-max
iset-delete-max!
iset-delete-min
iset-delete-min!
iset-difference
iset-difference!
iset-disjoint?
iset-empty?
iset-every?
iset-filter
iset-filter!
iset-find
iset-fold
iset-fold-right
iset-for-each
iset-intersection
iset-intersection!
iset-map
iset-max
iset-member
iset-min
iset-open-closed-interval
iset-open-interval
iset-partition
iset-partition!
iset-remove
iset-remove!
iset-search
iset-search!
iset-size
iset-unfold
iset-union
iset-union!
iset-xor
iset-xor!
iset<=?
iset<?
iset=?
iset>=?
iset>?
iset?
iseventh
isixth
isomorphic?
isubset<
isubset<=
isubset=
isubset>
isubset>=
itake-right
itenth
iterator->stream
ithird
jacobi
jiffies-per-second
job-acknowledge-time
job-finish-time
job-result
job-start-time
job-status
job-wait
job?
join-timeout-exception?
joined
joined/dot
joined/last
joined/prefix
joined/range
joined/suffix
json-accumulator
json-array-handler
json-error-reason
json-error?
json-fold
json-generator
json-lines-read
json-nesting-depth-limit
json-null?
json-number-of-character-limit
json-object-handler
json-read
json-sequence-read
json-special-handler
json-write
julian-day->date
julian-day->time-monotonic
julian-day->time-tai
julian-day->time-utc
just
just?
justified
keyword->string
keyword?
kmp-step
l-distance
l-distances
label
lambda
lambda/tag
lappend
lappend-map
last
last-ec
last-ipair
last-pair
latch-await
latch-clear!
latch-dec!
latch?
latin-1-codec
layout-multicolumn
lazy
lazy-size-of
lcm
lconcatenate
lcons
lcons*
lcs
lcs-edit-list
lcs-edit-list/context
lcs-edit-list/unified
lcs-fold
lcs-with-positions
ldexp
least-fixnum
least-positive-flonum
least-positive-normalized-flonum
left
left-section
left?
legacy-hash
length
length+
length<=?
length<?
length=?
length>=?
length>?
let
let*
let*-values
let-args
let-keywords
let-keywords*
let-optionals
let-optionals*
let-string-start+end
let-syntax
let-values
let/cc
let1
letrec
letrec*
letrec-syntax
lfilter
lfilter-map
lgamma
library-exists?
library-fold
library-for-each
library-has-module?
library-map
line-numbers
linear-access-list->random-access-list
linterweave
liota
list
list*
list*->skew-list
list->@vector
list->bag
list->bag!
list->bits
list->bitvector
list->c128vector
list->c32vector
list->c64vector
list->char-set
list->char-set!
list->either
list->enum-set
list->f16vector
list->f32vector
list->f64vector
list->file
list->generator
list->hook
list->hook!
list->ideque
list->integer
list->iset
list->iset!
list->just
list->left
list->maybe
list->queue
list->right
list->s16vector
list->s32vector
list->s64vector
list->s8vector
list->set
list->set!
list->skew-list
list->stream
list->string
list->sys-fdset
list->text
list->u16vector
list->u32vector
list->u64vector
list->u8vector
list->vector
list-accumulator
list-case
list-copy
list-delete-neighbor-dups
list-delete-neighbor-dups!
list-ec
list-index
list-merge
list-merge!
list-queue
list-queue-add-back!
list-queue-add-front!
list-queue-append
list-queue-append!
list-queue-back
list-queue-concatenate
list-queue-copy
list-queue-empty?
list-queue-fist-last
list-queue-for-each
list-queue-front
list-queue-list
list-queue-map
list-queue-map!
list-queue-remove-all!
list-queue-remove-back!
list-queue-remove-front!
list-queue-set-list!
list-queue-unfold
list-queue-unfold-right
list-queue?
list-ref
list-ref/update
list-set
list-set!
list-sort
list-sort!
list-sorted?
list-stable-sort
list-stable-sort!
list-tabulate
list-tail
list-truth->either
list-truth->maybe
list-values
list/mv
list=
list?
listener-read-handler
listener-show-prompt
lists-of
literate
llist*
lmap
lmap-accum
load
load-bundle!
load-from-port
localized-template
log
log-default-drain
log-format
log-open
log2-binary-factors
logand
logand=
logbit?
logcount
logior
logior=
lognot
logset+clear
logtest
logxor
logxor=
loop
loop-procedure
lrange
lrxmatch
lseq->generator
lseq->list
lseq-any
lseq-append
lseq-car
lseq-cdr
lseq-drop
lseq-drop-while
lseq-every
lseq-filter
lseq-find
lseq-find-tail
lseq-first
lseq-for-each
lseq-index
lseq-length
lseq-map
lseq-member
lseq-memq
lseq-memv
lseq-position
lseq-realize
lseq-remove
lseq-rest
lseq-take
lseq-take-while
lseq-zip
lseq=?
lseq?
lset-adjoin
lset-diff+intersection
lset-diff+intersection!
lset-difference
lset-difference!
lset-intersection
lset-intersection!
lset-union
lset-union!
lset-xor
lset-xor!
lset<=
lset=
lslices
lstate-filter
ltake
ltake-while
lunfold
machine-name
macroexpand
macroexpand-1
macroexpand-all
magnitude
make
make-@vector-generator
make-accumulator
make-array
make-ball-generator
make-barrier
make-bernoulli-generator
make-bimap
make-binary-heap
make-binomial-generator
make-bitvector
make-bitvector-accumulator
make-bitvector/bool-generator
make-bitvector/int-generator
make-bitwise-generator
make-blob
make-byte-string
make-bytestring
make-bytestring!
make-bytestring-generator
make-bytevector
make-bytevector-comparator
make-c128vector
make-c32vector
make-c64vector
make-car-comparator
make-categorical-generator
make-cdr-comparator
make-client-socket
make-codec
make-comparator
make-comparator/compare
make-comparison<
make-comparison<=
make-comparison=/<
make-comparison=/>
make-comparison>
make-comparison>=
make-compound
make-compound-condition
make-concurrent-modification-violation
make-condition
make-condition-type
make-condition-variable
make-continuation-mark-key
make-continuation-prompt-tag
make-continuation-violation
make-coroutine-generator
make-csv-header-parser
make-csv-reader
make-csv-record-parser
make-csv-writer
make-custom-binary-input-port
make-custom-binary-input/output-port
make-custom-binary-output-port
make-custom-textual-input-port
make-custom-textual-output-port
make-date
make-debug-comparator
make-default-comparator
make-default-console
make-directory*
make-directory-files-generator
make-edn-object
make-ellipsoid-generator
make-empty-attlist
make-enum-comparator
make-enum-type
make-enumeration
make-ephemeron
make-eq-comparator
make-eqv-comparator
make-exponential-generator
make-f16array
make-f16vector
make-f32array
make-f32vector
make-f64array
make-f64vector
make-fifo-cache
make-fllog-base
make-flonum
make-for-each-generator
make-fully-concurrent-mapper
make-future
make-gap-buffer
make-gauche-package-description
make-geometric-generator
make-gettext
make-glob-fs-fold
make-grapheme-cluster-breaker
make-grapheme-cluster-reader
make-hash-table
make-hashmap-comparator
make-hmac
make-hook
make-i/o-invalid-position-error
make-icar-comparator
make-icdr-comparator
make-ideque
make-ilist-comparator
make-imap
make-improper-ilist-comparator
make-improper-list-comparator
make-inexact-real-comparator
make-interval-protocol
make-iota-generator
make-ipair-comparator
make-key-comparator
make-keyword
make-kmp-restart-vector
make-latch
make-legacy-parameter
make-list
make-list-comparator
make-list-queue
make-listwise-comparator
make-lru-cache
make-mapping-comparator
make-mersenne-twister
make-module
make-mtqueue
make-mutex
make-normal-generator
make-option-parser
make-overflow-doubler
make-packer
make-pair-comparator
make-parameter
make-pipe
make-plumbing
make-poisson-geneartor
make-polar
make-pool-mapper
make-priority-map
make-process-connection
make-product-comparator
make-promise
make-pump
make-queue
make-random-boolean-generator
make-random-char-generator
make-random-integer-generator
make-random-polar-generator
make-random-real-generator
make-random-rectangular-generator
make-random-s16-generator
make-random-s32-generator
make-random-s64-generator
make-random-s8-generator
make-random-source
make-random-source-generator
make-random-string-generator
make-random-u1-generator
make-random-u16-generator
make-random-u32-generator
make-random-u64-generator
make-random-u8-generator
make-range-generator
make-range-iset
make-rbtree
make-record-type
make-rectangular
make-refining-comparator
make-reverse-comparator
make-ring-buffer
make-rtd
make-s16array
make-s16vector
make-s32array
make-s32vector
make-s64array
make-s64vector
make-s8array
make-s8vector
make-segmented-prefix-matcher
make-selecting-comparator
make-semaphore
make-server-socket
make-server-sockets
make-shared-parameter
make-sockaddrs
make-socket
make-sparse-matrix
make-sparse-table
make-sparse-vector
make-sphere-generator
make-stacked-map
make-static-mapper
make-stream
make-string
make-sum-comparator
make-template-environment
make-text
make-text-progress-bar
make-thread
make-thread-abandoned-mutex
make-thread-condition
make-thread-local
make-thread-parameter
make-thread-pool
make-thread-timeout-condition
make-time
make-time-result
make-timer
make-timer-delta
make-tls
make-transcoder
make-tree-map
make-trie
make-ttl-cache
make-ttlr-cache
make-tuple-comparator
make-u16array
make-u16vector
make-u32array
make-u32vector
make-u64array
make-u64vector
make-u8array
make-u8vector
make-u8vector-generator
make-ulid-generator
make-unfold-generator
make-uvector
make-vector
make-vector-comparator
make-vectorwise-comparator
make-view-uvector
make-weak-vector
make-word-breaker
make-word-reader
make-wrapper-comparator
make-write-controls
make-xml-token
make-zipf-generator
make<=?
make<?
make=?
make>=?
make>?
map
map!
map$
map*
map-accum
map-in-order
map-to
map-to-with-index
map-union
map-values
map-with-index
mapping
mapping->alist
mapping-adjoin
mapping-adjoin!
mapping-any?
mapping-catenate
mapping-catenate!
mapping-contains?
mapping-copy
mapping-count
mapping-delete
mapping-delete!
mapping-delete-all
mapping-delete-all!
mapping-difference
mapping-difference!
mapping-disjoint?
mapping-empty?
mapping-entries
mapping-every?
mapping-filter
mapping-filter!
mapping-find
mapping-fold
mapping-fold/reverse
mapping-for-each
mapping-intern
mapping-intern!
mapping-intersection
mapping-intersection!
mapping-key-comparator
mapping-key-predecessor
mapping-key-successor
mapping-keys
mapping-map
mapping-map->list
mapping-map/monotone
mapping-map/monotone!
mapping-max-entry
mapping-max-key
mapping-max-value
mapping-min-entry
mapping-min-key
mapping-min-value
mapping-partition
mapping-partition!
mapping-pop
mapping-pop!
mapping-range<
mapping-range<!
mapping-range<=
mapping-range<=!
mapping-range=
mapping-range=!
mapping-range>
mapping-range>!
mapping-range>=
mapping-range>=!
mapping-ref
mapping-ref/default
mapping-remove
mapping-remove!
mapping-replace
mapping-replace!
mapping-search
mapping-search!
mapping-set
mapping-set!
mapping-size
mapping-split
mapping-split!
mapping-unfold
mapping-unfold/ordered
mapping-union
mapping-union!
mapping-update
mapping-update!
mapping-update!/default
mapping-update/default
mapping-values
mapping-xor
mapping-xor!
mapping/ordered
mapping<=?
mapping<?
mapping=?
mapping>=?
mapping>?
mapping?
match
match-define
match-lambda
match-lambda*
match-let
match-let*
match-let1
match-letrec
max
max-ec
maybe->either
maybe->generation
maybe->list
maybe->list-truth
maybe->truth
maybe->two-values
maybe->values
maybe-and
maybe-bind
maybe-compose
maybe-escaped
maybe-filter
maybe-fold
maybe-for-each
maybe-if
maybe-join
maybe-length
maybe-let*
maybe-let*-values
maybe-map
maybe-or
maybe-ref
maybe-ref/default
maybe-remove
maybe-sequence
maybe-unfold
maybe=
maybe?
mc-factorize
md5-digest
md5-digest-string
member
member$
memq
memv
merge
merge!
message-condition?
message-type
method-more-specific?
miller-rabin-prime?
mime-body->file
mime-body->string
mime-compose-message
mime-compose-message-string
mime-compose-parameters
mime-decode-text
mime-decode-word
mime-encode-text
mime-encode-word
mime-make-boundary
mime-parse-content-disposition
mime-parse-content-type
mime-parse-message
mime-parse-parameters
mime-parse-version
mime-retrieve-body
min
min&max
min-ec
mod
mod0
modf
modified-julian-day->date
modified-julian-day->time-monotonic
modified-julian-day->time-tai
modified-julian-day->time-utc
modifier
module-binding-ref
module-binds?
module-exports
module-exports?
module-imports
module-name
module-name->path
module-parents
module-precedence-list
module-reload-rules
module-table
module?
modulo
monotonic-time
move-cursor-to
move-file
mt-random-fill-f32vector!
mt-random-fill-f64vector!
mt-random-fill-u32vector!
mt-random-get-seed
mt-random-get-state
mt-random-integer
mt-random-real
mt-random-real0
mt-random-set-seed!
mt-random-set-state!
mtqueue-max-length
mtqueue-num-waiting-readers
mtqueue-room
mtqueue?
mutex-lock!
mutex-locker
mutex-name
mutex-specific
mutex-specific-set!
mutex-state
mutex-unlock!
mutex-unlocker
mutex?
naive-factorize
nan?
native-endian
native-endianness
native-eol-style
native-transcoder
ndbm-clear-error
ndbm-close
ndbm-closed?
ndbm-delete
ndbm-error
ndbm-fetch
ndbm-firstkey
ndbm-nextkey
ndbm-open
ndbm-store
negative-zero?
negative?
nest
nest-reverse
nested
never
new
newline
next-method
next-token
next-token-of
ngettext
nice
nil-uuid
ninth
node-closure
node-eq?
node-equal?
node-join
node-or
node-pos
node-reduce
node-reverse
node-self
node-trace
nodeset?
not
not-ipair?
not-pair?
nothing
nothing?
ntype-names??
ntype-namespace-id??
ntype??
null-device
null-environment
null-generator
null-ilist?
null-list?
null?
num-pairs
number->string
number-hash
number?
numerator
numeric
numeric-range
numeric/comma
numeric/fitted
numeric/si
object-apply
object-compare
object-equal?
object-hash
object-isomorphic?
odbm-close
odbm-delete
odbm-fetch
odbm-firstkey
odbm-init
odbm-nextkey
odbm-store
odd?
of-type?
on
on-left
on-right
open-binary-input-file
open-binary-output-file
open-broadcast-output-port
open-coding-aware-port
open-deflating-port
open-directory
open-file
open-inflating-port
open-info-document
open-inlet-output-port
open-input-byte-generator
open-input-byte-list
open-input-bytevector
open-input-char-generator
open-input-char-list
open-input-conversion-port
open-input-fd-port
open-input-file
open-input-process-port
open-input-string
open-input-uvector
open-outlet-input-port
open-output-accumulator
open-output-bytevector
open-output-char-accumulator
open-output-conversion-port
open-output-fd-port
open-output-file
open-output-process-port
open-output-string
open-output-uvector
open-tapping-input-port
opt*-lambda
opt-labmda
opt-substring
option
option-names
option-optional-arg?
option-processor
option-required-arg?
option?
or
or-procedure
os-name
os-version
output-port-open?
output-port?
pa$
pack
padded
padded/both
padded/right
pager-program
pair-attribute-get
pair-attribute-set!
pair-attributes
pair-fold
pair-fold-right
pair-for-each
pair?
pairs-of
pany
parallel-execute
parameter-observer-add!
parameter-observer-delete!
parameter-post-observers
parameter-pre-observers
parameter?
parameterization?
parameterize
parameterize/dynwind
parse-cookie-string
parse-css
parse-css-file
parse-css-selector-string
parse-edn
parse-edn*
parse-edn-string
parse-json
parse-json*
parse-json-string
parse-options
parse-success?
parse-uuid
partition
partition!
partition$
partition-to
path->gauche-package-description
path->module-name
path-extension
path-sans-extension
path-swap-extension
peek-byte
peek-char
peek-next-char
peek-u8
peg-parse-port
peg-parse-string
peg-parser->generator
peg-run-parser
permutations
permutations*
permutations*-for-each
permutations-for-each
permutations-of
permute
permute!
permute-to
pfind
pid
plumbing
plumbing-get-port
plumbing-inlet-ports
plumbing-outlet-ports
plumbing?
pmap
pop!
port->byte-generator
port->byte-lseq
port->char-generator
port->char-lseq
port->char-lseq/position
port->line-generator
port->list
port->sexp-generator
port->sexp-list
port->sexp-lseq
port->stream
port->string
port->string-list
port->string-lseq
port->uvector
port-buffering
port-closed?
port-current-line
port-fd-dup!
port-file-number
port-fold
port-fold-right
port-for-each
port-has-port-position?
port-has-set-port-position!?
port-link!
port-map
port-name
port-plumbing
port-position
port-seek
port-tell
port-type
port-unlink!
port?
portable-hash
positive?
posix-error-message
posix-error-name
posix-error?
posix-time
post++
post--
power-set
power-set*
power-set*-for-each
power-set-binary
power-set-for-each
pprint
pre++
pre--
pretty