Next: variable index, Previous: concept index, Up: Top [Index]
$ascii-alpha-digit?
$ascii-alphabetic?
$ascii-cased?
$ascii-chi-ampersand?
$ascii-chi-at-sign?
$ascii-chi-bang?
$ascii-chi-close-bracket?
$ascii-chi-close-paren?
$ascii-chi-colon?
$ascii-chi-comma?
$ascii-chi-dash?
$ascii-chi-dollar?
$ascii-chi-dot?
$ascii-chi-equal?
$ascii-chi-minus?
$ascii-chi-number-sign?
$ascii-chi-open-bracket?
$ascii-chi-open-paren?
$ascii-chi-percent?
$ascii-chi-plus?
$ascii-chi-question-mark?
$ascii-chi-quote?
$ascii-chi-semicolon?
$ascii-chi-slash?
$ascii-chi-star?
$ascii-chi-tilde?
$ascii-chi-underscore?
$ascii-chi-V?
$ascii-chi-v?
$ascii-dec->fixnum
$ascii-dec-digit?
$ascii-downcase
$ascii-hex->fixnum
$ascii-hex-digit?
$ascii-lower-case?
$ascii-title-case?
$ascii-titlecase
$ascii-upcase
$ascii-upper-case?
$ascii-uri-gen-delim?
$ascii-uri-pchar-not-percent-encoded?
$ascii-uri-pchar?
$ascii-uri-pct-encoded?
$ascii-uri-reserved?
$ascii-uri-sub-delim?
$ascii-uri-unreserved?
$binary-heap-blend!
$binary-heap-copy
$binary-heap-empty?
$binary-heap-fill!
$binary-heap-fold!
$binary-heap-getprop
$binary-heap-hash
$binary-heap-merge
$binary-heap-not-empty?
$binary-heap-pop!
$binary-heap-property-list
$binary-heap-purge!
$binary-heap-push!
$binary-heap-putprop
$binary-heap-remprop
$binary-heap-size?
$binary-heap-sort-to-list!
$binary-heap-top
$binary-node-depth
$binary-node-leaf?
$binary-node-left
$binary-node-left-set!
$binary-node-parent
$binary-node-parent-and-child?
$binary-node-parent-and-left-child?
$binary-node-parent-and-right-child?
$binary-node-replace-in-parent!
$binary-node-right
$binary-node-right-set!
$binary-node-root?
$binary-tree-begin-breadth-first-backwards
$binary-tree-begin-breadth-first-forwards
$binary-tree-begin-in-order-backwards
$binary-tree-begin-in-order-forwards
$binary-tree-begin-level-order-backwards
$binary-tree-begin-level-order-forwards
$binary-tree-begin-post-order-backwards
$binary-tree-begin-post-order-forwards
$binary-tree-begin-pre-order-backwards
$binary-tree-begin-pre-order-forwards
$binary-tree-deepest-left-leaf
$binary-tree-deepest-right-leaf
$binary-tree-find
$binary-tree-fold-breadth-first-backwards
$binary-tree-fold-breadth-first-forwards
$binary-tree-fold-in-order-backwards
$binary-tree-fold-in-order-forwards
$binary-tree-fold-level-order-backwards
$binary-tree-fold-level-order-forwards
$binary-tree-fold-post-order-backwards
$binary-tree-fold-post-order-forwards
$binary-tree-fold-pre-order-backwards
$binary-tree-fold-pre-order-forwards
$binary-tree-maximum
$binary-tree-minimum
$binary-tree-root
$binary-tree-step-breadth-first-backwards
$binary-tree-step-breadth-first-forwards
$binary-tree-step-in-order-backwards
$binary-tree-step-in-order-forwards
$binary-tree-step-level-order-backwards
$binary-tree-step-level-order-forwards
$binary-tree-step-post-order-backwards
$binary-tree-step-post-order-forwards
$binary-tree-step-pre-order-backwards
$binary-tree-step-pre-order-forwards
$binary-tree-valid?
$bytevector-absolute?
$bytevector-append
$bytevector-dirname
$bytevector-extension
$bytevector-normalise
$bytevector-pathname?
$bytevector-prefix?
$bytevector-prepend
$bytevector-relative?
$bytevector-replace-extension
$bytevector-rootname
$bytevector-segment?
$bytevector-split
$bytevector-strip-trailing-slashes
$bytevector-suffix?
$bytevector-tailname
$bytevector-uri-representation
$callable-object
$chain->list
$chain->vector
$chain-append-forwards
$chain-backwards-length?
$chain-copy-forwards
$chain-exists-forwards
$chain-find-forwards
$chain-fold-left-backwards
$chain-fold-left-forwards
$chain-fold-right-backwards
$chain-fold-right-forwards
$chain-for-all-forwards
$chain-for-each-forwards
$chain-forwards-length?
$chain-front
$chain-index-backwards!
$chain-index-forwards!
$chain-length?
$chain-link-getprop
$chain-link-hash
$chain-link-next
$chain-link-next-set!
$chain-link-prev
$chain-link-prev-set!
$chain-link-property-list
$chain-link-putprop
$chain-link-ref
$chain-link-remove!
$chain-link-remprop
$chain-link-set!
$chain-map-forwards
$chain-pop-front!
$chain-pop-rear!
$chain-push-front!
$chain-push-rear!
$chain-rear
$chain-reverse-forwards
$chain-sort-forwards
$define-variable-alias
$deque->list
$deque->vector
$deque-copy!
$deque-empty?
$deque-exists
$deque-exists-left
$deque-exists-right
$deque-filter
$deque-find
$deque-find-left
$deque-find-right
$deque-fold-left
$deque-fold-right
$deque-for-all
$deque-for-each
$deque-for-each-left
$deque-for-each-right
$deque-front
$deque-getprop
$deque-hash
$deque-map
$deque-map-left
$deque-map-right
$deque-not-empty?
$deque-partition
$deque-pop-front!
$deque-pop-rear!
$deque-property-list
$deque-purge!
$deque-push-front!
$deque-push-rear!
$deque-putprop
$deque-rear
$deque-remprop
$deque-reverse!
$deque-size?
$dynamic-array->list
$dynamic-array->vector
$dynamic-array-copy!
$dynamic-array-empty?
$dynamic-array-exists
$dynamic-array-exists-left
$dynamic-array-exists-right
$dynamic-array-filter
$dynamic-array-find
$dynamic-array-find-left
$dynamic-array-find-right
$dynamic-array-fold-left
$dynamic-array-fold-right
$dynamic-array-for-all
$dynamic-array-for-each
$dynamic-array-for-each-left
$dynamic-array-for-each-right
$dynamic-array-front
$dynamic-array-getprop
$dynamic-array-hash
$dynamic-array-insert!
$dynamic-array-length
$dynamic-array-map
$dynamic-array-map-left
$dynamic-array-map-right
$dynamic-array-not-empty?
$dynamic-array-partition
$dynamic-array-pop-front!
$dynamic-array-pop-rear!
$dynamic-array-property-list
$dynamic-array-purge!
$dynamic-array-push-front!
$dynamic-array-push-rear!
$dynamic-array-putprop
$dynamic-array-rear
$dynamic-array-ref
$dynamic-array-remove!
$dynamic-array-remprop
$dynamic-array-reverse!
$dynamic-array-set!
$dynamic-array-size
$dynamic-array-sort
$dynamic-array-sort!
$fixnum->ascii-dec
$fixnum->ascii-hex
$fixnum-in-ascii-range?
$fixnum-in-base10-range?
$fixnum-in-base16-range?
$iteration-thunk-exists
$iteration-thunk-filter
$iteration-thunk-find
$iteration-thunk-fold
$iteration-thunk-for-all
$iteration-thunk-for-each
$iteration-thunk-map
$iteration-thunk-partition
$list->chain
$list->deque
$list->dynamic-array
$list->position
$list->queue
$list->stack
$make-position
$position
$position-copy
$position-dimension
$position-index?
$position-ref
$position-set!
$position=?
$queue->list
$queue->vector
$queue-copy!
$queue-empty?
$queue-exists
$queue-exists-left
$queue-exists-right
$queue-filter
$queue-find
$queue-find-left
$queue-find-right
$queue-fold-left
$queue-fold-right
$queue-for-all
$queue-for-each
$queue-for-each-left
$queue-for-each-right
$queue-front
$queue-getprop
$queue-hash
$queue-map
$queue-map-left
$queue-map-right
$queue-not-empty?
$queue-partition
$queue-pop!
$queue-property-list
$queue-purge!
$queue-push!
$queue-putprop
$queue-rear
$queue-remprop
$queue-reverse!
$queue-size?
$stack->list
$stack->vector
$stack-copy!
$stack-empty?
$stack-exists
$stack-exists-left
$stack-exists-right
$stack-filter
$stack-find
$stack-find-left
$stack-find-right
$stack-fold-left
$stack-fold-right
$stack-for-all
$stack-for-each
$stack-for-each-left
$stack-for-each-right
$stack-getprop
$stack-hash
$stack-map
$stack-map-left
$stack-map-right
$stack-not-empty?
$stack-partition
$stack-pop!
$stack-property-list
$stack-purge!
$stack-push!
$stack-putprop
$stack-remprop
$stack-reverse!
$stack-size?
$stack-top
$string-absolute?
$string-append
$string-dirname
$string-extension
$string-normalise
$string-pathname?
$string-prefix?
$string-prepend
$string-relative?
$string-replace-extension
$string-rootname
$string-segment?
$string-split
$string-strip-trailing-slashes
$string-suffix?
$string-tailname
$string-uri-representation
$unbalanced-tree-insert!
$unbalanced-tree-remove!
$variable-ref
$variable-set!
$vector->chain
$vector->deque
$vector->dynamic-array
$vector->position
$vector->queue
$vector->stack
%and/or-eq?
%and/or-null?
%bytevector->s8-list*
%bytevector->u8-list*
%bytevector-s8-any
%bytevector-s8-ci<
%bytevector-s8-ci<=
%bytevector-s8-ci<>
%bytevector-s8-ci=
%bytevector-s8-ci>
%bytevector-s8-ci>=
%bytevector-s8-compare
%bytevector-s8-compare-ci
%bytevector-s8-concatenate-reverse
%bytevector-s8-contains
%bytevector-s8-contains-ci
%bytevector-s8-copy*
%bytevector-s8-copy*!
%bytevector-s8-count
%bytevector-s8-delete
%bytevector-s8-dictionary-ci<=?
%bytevector-s8-dictionary-ci<>?
%bytevector-s8-dictionary-ci<?
%bytevector-s8-dictionary-ci=?
%bytevector-s8-dictionary-ci>=?
%bytevector-s8-dictionary-ci>?
%bytevector-s8-dictionary-compare
%bytevector-s8-dictionary-compare-ci
%bytevector-s8-dictionary<=?
%bytevector-s8-dictionary<>?
%bytevector-s8-dictionary<?
%bytevector-s8-dictionary=?
%bytevector-s8-dictionary>=?
%bytevector-s8-dictionary>?
%bytevector-s8-drop
%bytevector-s8-drop-right
%bytevector-s8-every
%bytevector-s8-fill*!
%bytevector-s8-filter
%bytevector-s8-index
%bytevector-s8-index-right
%bytevector-s8-join
%bytevector-s8-pad
%bytevector-s8-pad-right
%bytevector-s8-prefix-ci?
%bytevector-s8-prefix-length
%bytevector-s8-prefix-length-ci
%bytevector-s8-prefix?
%bytevector-s8-replace
%bytevector-s8-reverse
%bytevector-s8-reverse!
%bytevector-s8-reverse-copy*
%bytevector-s8-reverse-copy*!
%bytevector-s8-skip
%bytevector-s8-skip-right
%bytevector-s8-suffix-ci?
%bytevector-s8-suffix-length
%bytevector-s8-suffix-length-ci
%bytevector-s8-suffix?
%bytevector-s8-take
%bytevector-s8-take-right
%bytevector-s8-titlecase*!
%bytevector-s8-tokenise
%bytevector-s8-tokenize
%bytevector-s8-trim
%bytevector-s8-trim-both
%bytevector-s8-trim-right
%bytevector-s8/numbers-ci<=?
%bytevector-s8/numbers-ci<>?
%bytevector-s8/numbers-ci<?
%bytevector-s8/numbers-ci=?
%bytevector-s8/numbers-ci>=?
%bytevector-s8/numbers-ci>?
%bytevector-s8/numbers-compare
%bytevector-s8/numbers-compare-ci
%bytevector-s8/numbers-dictionary-ci<=?
%bytevector-s8/numbers-dictionary-ci<>?
%bytevector-s8/numbers-dictionary-ci<?
%bytevector-s8/numbers-dictionary-ci=?
%bytevector-s8/numbers-dictionary-ci>=?
%bytevector-s8/numbers-dictionary-ci>?
%bytevector-s8/numbers-dictionary-compare
%bytevector-s8/numbers-dictionary-compare-ci
%bytevector-s8/numbers-dictionary<=?
%bytevector-s8/numbers-dictionary<>?
%bytevector-s8/numbers-dictionary<?
%bytevector-s8/numbers-dictionary=?
%bytevector-s8/numbers-dictionary>=?
%bytevector-s8/numbers-dictionary>?
%bytevector-s8/numbers<=?
%bytevector-s8/numbers<>?
%bytevector-s8/numbers<?
%bytevector-s8/numbers=?
%bytevector-s8/numbers>=?
%bytevector-s8/numbers>?
%bytevector-s8<
%bytevector-s8<=
%bytevector-s8<>
%bytevector-s8=
%bytevector-s8>
%bytevector-s8>=
%bytevector-u8-any
%bytevector-u8-ci<
%bytevector-u8-ci<=
%bytevector-u8-ci<>
%bytevector-u8-ci=
%bytevector-u8-ci>
%bytevector-u8-ci>=
%bytevector-u8-compare
%bytevector-u8-compare-ci
%bytevector-u8-concatenate-reverse
%bytevector-u8-contains
%bytevector-u8-contains-ci
%bytevector-u8-copy*
%bytevector-u8-copy*!
%bytevector-u8-count
%bytevector-u8-delete
%bytevector-u8-dictionary-ci<=?
%bytevector-u8-dictionary-ci<>?
%bytevector-u8-dictionary-ci<?
%bytevector-u8-dictionary-ci=?
%bytevector-u8-dictionary-ci>=?
%bytevector-u8-dictionary-ci>?
%bytevector-u8-dictionary-compare
%bytevector-u8-dictionary-compare-ci
%bytevector-u8-dictionary<=?
%bytevector-u8-dictionary<>?
%bytevector-u8-dictionary<?
%bytevector-u8-dictionary=?
%bytevector-u8-dictionary>=?
%bytevector-u8-dictionary>?
%bytevector-u8-drop
%bytevector-u8-drop-right
%bytevector-u8-every
%bytevector-u8-fill*!
%bytevector-u8-filter
%bytevector-u8-index
%bytevector-u8-index-right
%bytevector-u8-join
%bytevector-u8-pad
%bytevector-u8-pad-right
%bytevector-u8-prefix-ci?
%bytevector-u8-prefix-length
%bytevector-u8-prefix-length-ci
%bytevector-u8-prefix?
%bytevector-u8-replace
%bytevector-u8-reverse
%bytevector-u8-reverse!
%bytevector-u8-reverse-copy*
%bytevector-u8-reverse-copy*!
%bytevector-u8-skip
%bytevector-u8-skip-right
%bytevector-u8-suffix-ci?
%bytevector-u8-suffix-length
%bytevector-u8-suffix-length-ci
%bytevector-u8-suffix?
%bytevector-u8-take
%bytevector-u8-take-right
%bytevector-u8-titlecase*!
%bytevector-u8-tokenise
%bytevector-u8-tokenize
%bytevector-u8-trim
%bytevector-u8-trim-both
%bytevector-u8-trim-right
%bytevector-u8/numbers-ci<=?
%bytevector-u8/numbers-ci<>?
%bytevector-u8/numbers-ci<?
%bytevector-u8/numbers-ci=?
%bytevector-u8/numbers-ci>=?
%bytevector-u8/numbers-ci>?
%bytevector-u8/numbers-compare
%bytevector-u8/numbers-compare-ci
%bytevector-u8/numbers-dictionary-ci<=?
%bytevector-u8/numbers-dictionary-ci<>?
%bytevector-u8/numbers-dictionary-ci<?
%bytevector-u8/numbers-dictionary-ci=?
%bytevector-u8/numbers-dictionary-ci>=?
%bytevector-u8/numbers-dictionary-ci>?
%bytevector-u8/numbers-dictionary-compare
%bytevector-u8/numbers-dictionary-compare-ci
%bytevector-u8/numbers-dictionary<=?
%bytevector-u8/numbers-dictionary<>?
%bytevector-u8/numbers-dictionary<?
%bytevector-u8/numbers-dictionary=?
%bytevector-u8/numbers-dictionary>=?
%bytevector-u8/numbers-dictionary>?
%bytevector-u8/numbers<=?
%bytevector-u8/numbers<>?
%bytevector-u8/numbers<?
%bytevector-u8/numbers=?
%bytevector-u8/numbers>=?
%bytevector-u8/numbers>?
%bytevector-u8<
%bytevector-u8<=
%bytevector-u8<>
%bytevector-u8=
%bytevector-u8>
%bytevector-u8>=
%cars
%cars*
%cars+cdrs*/no-test
%cars+knil
%cars+knil*
%cars+knil/cdrs
%cars+knil/cdrs*
%cars/cdrs
%cars/cdrs*
%cdrs
%cdrs*
%domain->list
%domain-add-item
%domain-add-range
%domain-any
%domain-complement
%domain-contains?
%domain-copy
%domain-difference
%domain-empty?
%domain-every
%domain-fold
%domain-for-each
%domain-intersection
%domain-size
%domain-subset?
%domain-subset?/strict
%domain-superset?
%domain-superset?/strict
%domain-union
%domain<?
%domain=?
%domain?
%kmp-make-restart-vector
%kmp-partial-search
%kmp-search
%kmp-step
%knil+cars
%knil+cars*
%knil+cars/cdrs
%knil+cars/cdrs*
%list->queue
%make-domain
%make-queue
%make-range
%make-type-descriptor
%queue-last-pair-ref
%queue-list-ref
%random-bytevector
%random-bytevector!
%random-string-sample
%random-string-sample-population
%random-string-shuffle
%random-string-shuffle!
%random-vector-sample
%random-vector-sample-population
%random-vector-shuffle
%random-vector-shuffle!
%range->list
%range-any
%range-concatenate
%range-contains?
%range-contiguous?
%range-copy
%range-difference
%range-every
%range-fold
%range-for-each
%range-in-first-only
%range-intersection
%range-last<=?
%range-last<?
%range-length
%range-overlapping?
%range-past<=?
%range-past<?
%range-start<=?
%range-start<?
%range-subset?
%range-subset?/strict
%range-superset?
%range-superset?/strict
%range-union
%range<=?
%range<?
%range=?
%range?
%reverse-bytevector->s8-list
%reverse-bytevector->u8-list
%reverse-string->list
%reverse-vector->list
%string->list*
%string-any
%string-ci<
%string-ci<=
%string-ci<>
%string-ci=
%string-ci>
%string-ci>=
%string-compare
%string-compare-ci
%string-concatenate-reverse
%string-contains
%string-contains-ci
%string-copy*
%string-copy*!
%string-count
%string-delete
%string-dictionary-ci<=?
%string-dictionary-ci<>?
%string-dictionary-ci<?
%string-dictionary-ci=?
%string-dictionary-ci>=?
%string-dictionary-ci>?
%string-dictionary-compare
%string-dictionary-compare-ci
%string-dictionary<=?
%string-dictionary<>?
%string-dictionary<?
%string-dictionary=?
%string-dictionary>=?
%string-dictionary>?
%string-drop
%string-drop-right
%string-every
%string-fill*!
%string-filter
%string-index
%string-index-right
%string-join
%string-pad
%string-pad-right
%string-prefix-ci?
%string-prefix-length
%string-prefix-length-ci
%string-prefix?
%string-replace
%string-reverse
%string-reverse!
%string-reverse-copy*
%string-reverse-copy*!
%string-search-and-replace
%string-search-and-replace-ci
%string-skip
%string-skip-right
%string-suffix-ci?
%string-suffix-length
%string-suffix-length-ci
%string-suffix?
%string-take
%string-take-right
%string-titlecase*!
%string-tokenise
%string-tokenize
%string-trim
%string-trim-both
%string-trim-right
%string/numbers-ci<=?
%string/numbers-ci<>?
%string/numbers-ci<?
%string/numbers-ci=?
%string/numbers-ci>=?
%string/numbers-ci>?
%string/numbers-compare
%string/numbers-compare-ci
%string/numbers-dictionary-ci<=?
%string/numbers-dictionary-ci<>?
%string/numbers-dictionary-ci<?
%string/numbers-dictionary-ci=?
%string/numbers-dictionary-ci>=?
%string/numbers-dictionary-ci>?
%string/numbers-dictionary-compare
%string/numbers-dictionary-compare-ci
%string/numbers-dictionary<=?
%string/numbers-dictionary<>?
%string/numbers-dictionary<?
%string/numbers-dictionary=?
%string/numbers-dictionary>=?
%string/numbers-dictionary>?
%string/numbers<=?
%string/numbers<>?
%string/numbers<?
%string/numbers=?
%string/numbers>=?
%string/numbers>?
%string<
%string<=
%string<>
%string=
%string>
%string>=
%subbytevector-s8-fold-left
%subbytevector-s8-fold-right
%subbytevector-s8-for-each
%subbytevector-s8-for-each-index
%subbytevector-s8-map
%subbytevector-s8-map!
%subbytevector-u8-fold-left
%subbytevector-u8-fold-right
%subbytevector-u8-for-each
%subbytevector-u8-for-each-index
%subbytevector-u8-map
%subbytevector-u8-map!
%substring-fold-left
%substring-fold-right
%substring-for-each
%substring-for-each-index
%substring-map
%substring-map!
%subvector-fold-left
%subvector-fold-right
%subvector-for-each
%subvector-for-each-index
%subvector-for-each/with-index
%subvector-map
%subvector-map!
%subvector-map!/with-index
%subvector-map/with-index
%vector->list*
%vector-any
%vector-binary-search
%vector-compare
%vector-concatenate-reverse
%vector-contains
%vector-copy
%vector-copy!
%vector-count
%vector-delete
%vector-drop
%vector-drop-right
%vector-every
%vector-fill*!
%vector-filter
%vector-index
%vector-index-right
%vector-pad
%vector-pad-right
%vector-prefix-length
%vector-prefix?
%vector-replace
%vector-reverse
%vector-reverse!
%vector-reverse-copy
%vector-reverse-copy!
%vector-skip
%vector-skip-right
%vector-suffix-length
%vector-suffix?
%vector-take
%vector-take-right
%vector-trim
%vector-trim-both
%vector-trim-right
%vector<
%vector<=
%vector<>
%vector=
%vector>
%vector>=
%xsubbytevector-s8
%xsubbytevector-u8
%xsubstring
%xsubvector
(max-compare
(min-compare
->char-set
...
…
:
:after
:around
:before
:char-range
:dispatched
:do
:end-of-input
:generate-delimiter-test
:generate-end-of-input-or-char-tests
:integers
:introduce-device-arguments
:invalid-input-char
:let
:list
:parallel
:port
:primary
:range
:real-range
:string
:unexpected-end-of-input
:until
:vector
:while
</<=?
</<?
<=/<=?
<=/<?
<=?
<?
<bitvector> on <bitvector>
=>
=?
>/>=?
>/>?
>=/>=?
>=/>?
>=?
>?
?generator
_
~!
~%
~&
~( ~)
~*
~/
~?
~a
~b
~c
~d
~e
~f
~i
~k
~o
~p
~r
~s
~t
~x
~y
~[ ~; ~]
~\n
~^
~_
~{
~|
~~
abort-restart
absolute?
accept
access
acosh
action
add-duration
add-duration!
add-hook!
add-method
add-result
address-family
address-info
after-fork/prepare-child-binary-input/output-ports
after-fork/prepare-child-file-descriptors
after-fork/prepare-child-textual-input/output-ports
after-fork/prepare-parent-binary-input/output-ports
after-fork/prepare-parent-textual-input/output-ports
alarm
alist->bag
alist->hash-table
alist-cons
alist-copy
alist-delete
alist-delete!
amb
amb-assert
amb-backtrack-log
amb-exhaustion?
amb-not-initialised?
amb-permute
amb-random-fixnum-maker
amb-thunk
and
and on <bitvector>
and! on <bitvector>
and-fold-left*
and-fold-left*/stx
and-fold-right*
and-fold-right*/stx
and-let*
and-null?
and-null?/stx
and/or-null?
and/or-null?/stx
any
any*
any?-ec
append
append!
append-ec
append-map
append-map!
append-reverse
append-reverse!
append-reverse!/stx
append-reverse/stx
apply
args-fold
argument-condition?
arguments-validation-forms
array
array-end
array-rank
array-ref
array-set!
array-start
array?
ascii-alpha-digit?
ascii-alphabetic?
ascii-cased?
ascii-dec->fixnum
ascii-dec-digit?
ascii-downcase
ascii-hex->fixnum
ascii-hex-digit?
ascii-lower-case?
ascii-title-case?
ascii-titlecase
ascii-upcase
ascii-upper-case?
asinh
assert-general-c-buffer-and-length
assert-general-c-string-and-length
assoc
assoc*
assq
assv
atanh
bag
bag->alist
bag->list
bag->set
bag-adjoin
bag-adjoin!
bag-any?
bag-comparator
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-sum
bag-sum!
bag-unfold
bag-union
bag-union!
bag-unique-size
bag-xor
bag-xor!
bag<=?
bag<?
bag=?
bag>=?
bag>?
bag?
beg-size
begin
begin0-let
big
bignum
binary-heap-blend!
binary-heap-copy
binary-heap-empty?
binary-heap-fill!
binary-heap-fold!
binary-heap-getprop
binary-heap-hash
binary-heap-merge
binary-heap-not-empty?
binary-heap-pop!
binary-heap-property-list
binary-heap-purge!
binary-heap-push!
binary-heap-putprop
binary-heap-remprop
binary-heap-size?
binary-heap-sort-to-list!
binary-heap-top
binary-heap?
binary-node-leaf?
binary-node-left
binary-node-left-set!
binary-node-parent
binary-node-parent-and-child?
binary-node-parent-and-left-child?
binary-node-parent-and-right-child?
binary-node-replace-in-parent!
binary-node-right
binary-node-right-set!
binary-node-root?
binary-node?
binary-port
binary-port/false
binary-tree-begin-breadth-first-backwards
binary-tree-begin-breadth-first-forwards
binary-tree-begin-in-order-backwards
binary-tree-begin-in-order-forwards
binary-tree-begin-level-order-backwards
binary-tree-begin-level-order-forwards
binary-tree-begin-post-order-backwards
binary-tree-begin-post-order-forwards
binary-tree-begin-pre-order-backwards
binary-tree-begin-pre-order-forwards
binary-tree-deepest-left-leaf
binary-tree-deepest-right-leaf
binary-tree-depth
binary-tree-find
binary-tree-fold-breadth-first-backwards
binary-tree-fold-breadth-first-forwards
binary-tree-fold-in-order-backwards
binary-tree-fold-in-order-forwards
binary-tree-fold-level-order-backwards
binary-tree-fold-level-order-forwards
binary-tree-fold-post-order-backwards
binary-tree-fold-post-order-forwards
binary-tree-fold-pre-order-backwards
binary-tree-fold-pre-order-forwards
binary-tree-maximum
binary-tree-minimum
binary-tree-root
binary-tree-step-breadth-first-backwards
binary-tree-step-breadth-first-forwards
binary-tree-step-in-order-backwards
binary-tree-step-in-order-forwards
binary-tree-step-level-order-backwards
binary-tree-step-level-order-forwards
binary-tree-step-post-order-backwards
binary-tree-step-post-order-forwards
binary-tree-step-pre-order-backwards
binary-tree-step-pre-order-forwards
binary-tree-valid?
bind
bindresvport
bindresvport6
bit-count on <bitvector>
bit-ref on <bitvector>
bit-set! on <bitvector>
boolean
boolean-compare
box
box?
brace
break
break!
brief
brief/long-condition?
busy?
byte
byte/octet
byte/octet/false
bytevector
bytevector->s8-list*
bytevector->u8-list*
bytevector-compound
bytevector-compound-data
bytevector-compound-dequeue!
bytevector-compound-empty?
bytevector-compound-enqueue!
bytevector-compound-filled?
bytevector-compound-length
bytevector-compound-s8-ref
bytevector-compound-s8-set!
bytevector-compound-total-length
bytevector-compound-u8-ref
bytevector-compound-u8-set!
bytevector-compound/filled
bytevector-compound?
bytevector-ieee-double-bigend-ref
bytevector-ieee-double-bigend-scaled-ref
bytevector-ieee-double-bigend-scaled-set!
bytevector-ieee-double-bigend-set!
bytevector-ieee-double-litend-ref
bytevector-ieee-double-litend-scaled-ref
bytevector-ieee-double-litend-scaled-set!
bytevector-ieee-double-litend-set!
bytevector-ieee-double-native-scaled-ref
bytevector-ieee-double-native-scaled-set!
bytevector-ieee-single-bigend-ref
bytevector-ieee-single-bigend-scaled-ref
bytevector-ieee-single-bigend-scaled-set!
bytevector-ieee-single-bigend-set!
bytevector-ieee-single-litend-ref
bytevector-ieee-single-litend-scaled-ref
bytevector-ieee-single-litend-scaled-set!
bytevector-ieee-single-litend-set!
bytevector-ieee-single-native-scaled-ref
bytevector-ieee-single-native-scaled-set!
bytevector-length
bytevector-pathname?
bytevector-s16-bigend-ref
bytevector-s16-bigend-scaled-ref
bytevector-s16-bigend-scaled-set!
bytevector-s16-bigend-set!
bytevector-s16-litend-ref
bytevector-s16-litend-scaled-ref
bytevector-s16-litend-scaled-set!
bytevector-s16-litend-set!
bytevector-s16-native-scaled-ref
bytevector-s16-native-scaled-set!
bytevector-s32-bigend-ref
bytevector-s32-bigend-scaled-ref
bytevector-s32-bigend-scaled-set!
bytevector-s32-bigend-set!
bytevector-s32-litend-ref
bytevector-s32-litend-scaled-ref
bytevector-s32-litend-scaled-set!
bytevector-s32-litend-set!
bytevector-s32-native-scaled-ref
bytevector-s32-native-scaled-set!
bytevector-s64-bigend-ref
bytevector-s64-bigend-scaled-ref
bytevector-s64-bigend-scaled-set!
bytevector-s64-bigend-set!
bytevector-s64-litend-ref
bytevector-s64-litend-scaled-ref
bytevector-s64-litend-scaled-set!
bytevector-s64-litend-set!
bytevector-s64-native-scaled-ref
bytevector-s64-native-scaled-set!
bytevector-s8-any
bytevector-s8-append
bytevector-s8-bigend-ref
bytevector-s8-bigend-scaled-ref
bytevector-s8-bigend-scaled-set!
bytevector-s8-bigend-set!
bytevector-s8-ci<
bytevector-s8-ci<=
bytevector-s8-ci<>
bytevector-s8-ci=
bytevector-s8-ci>
bytevector-s8-ci>=
bytevector-s8-compare
bytevector-s8-compare-ci
bytevector-s8-concatenate
bytevector-s8-concatenate-reverse
bytevector-s8-contains
bytevector-s8-contains-ci
bytevector-s8-copy*
bytevector-s8-copy*!
bytevector-s8-count
bytevector-s8-delete
bytevector-s8-dictionary-ci<=?
bytevector-s8-dictionary-ci<>?
bytevector-s8-dictionary-ci<?
bytevector-s8-dictionary-ci=?
bytevector-s8-dictionary-ci>=?
bytevector-s8-dictionary-ci>?
bytevector-s8-dictionary-compare
bytevector-s8-dictionary-compare-ci
bytevector-s8-dictionary<=?
bytevector-s8-dictionary<>?
bytevector-s8-dictionary<?
bytevector-s8-dictionary=?
bytevector-s8-dictionary>=?
bytevector-s8-dictionary>?
bytevector-s8-downcase*
bytevector-s8-downcase*!
bytevector-s8-drop
bytevector-s8-drop-right
bytevector-s8-every
bytevector-s8-fill*!
bytevector-s8-filter
bytevector-s8-fold
bytevector-s8-fold-left
bytevector-s8-fold-left*
bytevector-s8-fold-right
bytevector-s8-fold-right*
bytevector-s8-for-each*
bytevector-s8-index
bytevector-s8-index-right
bytevector-s8-join
bytevector-s8-litend-ref
bytevector-s8-litend-scaled-ref
bytevector-s8-litend-scaled-set!
bytevector-s8-litend-set!
bytevector-s8-map
bytevector-s8-map!
bytevector-s8-map*!
bytevector-s8-native-scaled-ref
bytevector-s8-native-scaled-set!
bytevector-s8-pad
bytevector-s8-pad-right
bytevector-s8-prefix-ci?
bytevector-s8-prefix-length
bytevector-s8-prefix-length-ci
bytevector-s8-prefix?
bytevector-s8-replace
bytevector-s8-reverse
bytevector-s8-reverse!
bytevector-s8-reverse-copy*
bytevector-s8-reverse-copy*!
bytevector-s8-skip
bytevector-s8-skip-right
bytevector-s8-suffix-ci?
bytevector-s8-suffix-length
bytevector-s8-suffix-length-ci
bytevector-s8-suffix?
bytevector-s8-swap!
bytevector-s8-tabulate
bytevector-s8-take
bytevector-s8-take-right
bytevector-s8-titlecase*
bytevector-s8-titlecase*!
bytevector-s8-tokenise
bytevector-s8-tokenize
bytevector-s8-trim
bytevector-s8-trim-both
bytevector-s8-trim-right
bytevector-s8-unfold
bytevector-s8-unfold-right
bytevector-s8-upcase*
bytevector-s8-upcase*!
bytevector-s8-xcopy!
bytevector-s8/numbers-ci<=?
bytevector-s8/numbers-ci<>?
bytevector-s8/numbers-ci<?
bytevector-s8/numbers-ci=?
bytevector-s8/numbers-ci>=?
bytevector-s8/numbers-ci>?
bytevector-s8/numbers-compare
bytevector-s8/numbers-compare-ci
bytevector-s8/numbers-dictionary-ci<=?
bytevector-s8/numbers-dictionary-ci<>?
bytevector-s8/numbers-dictionary-ci<?
bytevector-s8/numbers-dictionary-ci=?
bytevector-s8/numbers-dictionary-ci>=?
bytevector-s8/numbers-dictionary-ci>?
bytevector-s8/numbers-dictionary-compare
bytevector-s8/numbers-dictionary-compare-ci
bytevector-s8/numbers-dictionary<=?
bytevector-s8/numbers-dictionary<>?
bytevector-s8/numbers-dictionary<?
bytevector-s8/numbers-dictionary=?
bytevector-s8/numbers-dictionary>=?
bytevector-s8/numbers-dictionary>?
bytevector-s8/numbers<=?
bytevector-s8/numbers<>?
bytevector-s8/numbers<?
bytevector-s8/numbers=?
bytevector-s8/numbers>=?
bytevector-s8/numbers>?
bytevector-s8<
bytevector-s8<=
bytevector-s8<>
bytevector-s8=
bytevector-s8>
bytevector-s8>=
bytevector-segment?
bytevector-u16-bigend-ref
bytevector-u16-bigend-scaled-ref
bytevector-u16-bigend-scaled-set!
bytevector-u16-bigend-set!
bytevector-u16-litend-ref
bytevector-u16-litend-scaled-ref
bytevector-u16-litend-scaled-set!
bytevector-u16-litend-set!
bytevector-u16-native-scaled-ref
bytevector-u16-native-scaled-set!
bytevector-u32-bigend-ref
bytevector-u32-bigend-scaled-ref
bytevector-u32-bigend-scaled-set!
bytevector-u32-bigend-set!
bytevector-u32-litend-ref
bytevector-u32-litend-scaled-ref
bytevector-u32-litend-scaled-set!
bytevector-u32-litend-set!
bytevector-u32-native-scaled-ref
bytevector-u32-native-scaled-set!
bytevector-u64-bigend-ref
bytevector-u64-bigend-scaled-ref
bytevector-u64-bigend-scaled-set!
bytevector-u64-bigend-set!
bytevector-u64-litend-ref
bytevector-u64-litend-scaled-ref
bytevector-u64-litend-scaled-set!
bytevector-u64-litend-set!
bytevector-u64-native-scaled-ref
bytevector-u64-native-scaled-set!
bytevector-u8-any
bytevector-u8-append
bytevector-u8-bigend-ref
bytevector-u8-bigend-scaled-ref
bytevector-u8-bigend-scaled-set!
bytevector-u8-bigend-set!
bytevector-u8-ci<
bytevector-u8-ci<=
bytevector-u8-ci<>
bytevector-u8-ci=
bytevector-u8-ci>
bytevector-u8-ci>=
bytevector-u8-compare
bytevector-u8-compare-ci
bytevector-u8-concatenate
bytevector-u8-concatenate-reverse
bytevector-u8-contains
bytevector-u8-contains-ci
bytevector-u8-copy*
bytevector-u8-copy*!
bytevector-u8-count
bytevector-u8-delete
bytevector-u8-dictionary-ci<=?
bytevector-u8-dictionary-ci<>?
bytevector-u8-dictionary-ci<?
bytevector-u8-dictionary-ci=?
bytevector-u8-dictionary-ci>=?
bytevector-u8-dictionary-ci>?
bytevector-u8-dictionary-compare
bytevector-u8-dictionary-compare-ci
bytevector-u8-dictionary<=?
bytevector-u8-dictionary<>?
bytevector-u8-dictionary<?
bytevector-u8-dictionary=?
bytevector-u8-dictionary>=?
bytevector-u8-dictionary>?
bytevector-u8-downcase*
bytevector-u8-downcase*!
bytevector-u8-drop
bytevector-u8-drop-right
bytevector-u8-every
bytevector-u8-fill*!
bytevector-u8-filter
bytevector-u8-fold
bytevector-u8-fold-left
bytevector-u8-fold-left*
bytevector-u8-fold-right
bytevector-u8-fold-right*
bytevector-u8-for-each*
bytevector-u8-index
bytevector-u8-index-right
bytevector-u8-join
bytevector-u8-litend-ref
bytevector-u8-litend-scaled-ref
bytevector-u8-litend-scaled-set!
bytevector-u8-litend-set!
bytevector-u8-map
bytevector-u8-map!
bytevector-u8-map*!
bytevector-u8-native-scaled-ref
bytevector-u8-native-scaled-set!
bytevector-u8-null?
bytevector-u8-pad
bytevector-u8-pad-right
bytevector-u8-prefix-ci?
bytevector-u8-prefix-length
bytevector-u8-prefix-length-ci
bytevector-u8-prefix?
bytevector-u8-replace
bytevector-u8-reverse
bytevector-u8-reverse!
bytevector-u8-reverse-copy*
bytevector-u8-reverse-copy*!
bytevector-u8-skip
bytevector-u8-skip-right
bytevector-u8-suffix-ci?
bytevector-u8-suffix-length
bytevector-u8-suffix-length-ci
bytevector-u8-suffix?
bytevector-u8-swap!
bytevector-u8-tabulate
bytevector-u8-take
bytevector-u8-take-right
bytevector-u8-titlecase*
bytevector-u8-titlecase*!
bytevector-u8-tokenise
bytevector-u8-tokenize
bytevector-u8-trim
bytevector-u8-trim-both
bytevector-u8-trim-right
bytevector-u8-unfold
bytevector-u8-unfold-right
bytevector-u8-upcase*
bytevector-u8-upcase*!
bytevector-u8-xcopy!
bytevector-u8/numbers-ci<=?
bytevector-u8/numbers-ci<>?
bytevector-u8/numbers-ci<?
bytevector-u8/numbers-ci=?
bytevector-u8/numbers-ci>=?
bytevector-u8/numbers-ci>?
bytevector-u8/numbers-compare
bytevector-u8/numbers-compare-ci
bytevector-u8/numbers-dictionary-ci<=?
bytevector-u8/numbers-dictionary-ci<>?
bytevector-u8/numbers-dictionary-ci<?
bytevector-u8/numbers-dictionary-ci=?
bytevector-u8/numbers-dictionary-ci>=?
bytevector-u8/numbers-dictionary-ci>?
bytevector-u8/numbers-dictionary-compare
bytevector-u8/numbers-dictionary-compare-ci
bytevector-u8/numbers-dictionary<=?
bytevector-u8/numbers-dictionary<>?
bytevector-u8/numbers-dictionary<?
bytevector-u8/numbers-dictionary=?
bytevector-u8/numbers-dictionary>=?
bytevector-u8/numbers-dictionary>?
bytevector-u8/numbers<=?
bytevector-u8/numbers<>?
bytevector-u8/numbers<?
bytevector-u8/numbers=?
bytevector-u8/numbers>=?
bytevector-u8/numbers>?
bytevector-u8<
bytevector-u8<=
bytevector-u8<>
bytevector-u8=
bytevector-u8>
bytevector-u8>=
bytevector/false
c-callback
c-callback/false
c...r
caar
cacos
cacosh
cadr
call-next-method
call-with-socket
callable
callable-object
callable?
callet
callet*
car
car+cdr
case-endianness
case-errno
case-lambda
case-word-size
casin
casinh
catan
catanh
ccos
ccosh
cdddar
cddddr
cdr
cexp
CFLAGS
cflonum
chain
chain->list
chain->vector
chain-append-forwards
chain-backwards-length?
chain-copy-forwards
chain-exists-forwards
chain-filter-forwards
chain-find-forwards
chain-fold-left-backwards
chain-fold-left-forwards
chain-fold-right-backwards
chain-fold-right-forwards
chain-for-all-forwards
chain-for-each-forwards
chain-forwards-length?
chain-front
chain-index-backwards!
chain-index-forwards!
chain-length?
chain-link-getprop
chain-link-hash
chain-link-next
chain-link-next-set!
chain-link-prev
chain-link-prev-set!
chain-link-property-list
chain-link-putprop
chain-link-ref
chain-link-remove!
chain-link-remprop
chain-link-set!
chain-link?
chain-map-forwards
chain-partition-forwards
chain-pop-front!
chain-pop-rear!
chain-push-front!
chain-push-rear!
chain-rear
chain-reverse-forwards
chain-sort-forwards
chain<=?
chain<?
chain=?
chain>=?
chain>?
chain?
char
char-compare
char-compare-ci
char-in-ascii-range
char-in-ascii-range/false
char-set
char-set->list
char-set->sre
char-set->string
char-set-add
char-set-add!
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-difference+intersection
char-set-empty?
char-set-every
char-set-filter
char-set-filter!
char-set-fold
char-set-for-each
char-set-hash
char-set-intersection
char-set-intersection!
char-set-map
char-set-ref
char-set-size
char-set-subset?
char-set-subset?/strict
char-set-superset?
char-set-superset?/strict
char-set-unfold
char-set-unfold!
char-set-union
char-set-union!
char-set-write
char-set-xor
char-set-xor!
char-set<=
char-set<=?
char-set<?
char-set=
char-set=?
char-set?
char-set?/internals
char/false
chdir
check
check-display
check-ec
check-for-assertion-violation
check-for-expression-return-value-violation
check-for-false
check-for-procedure-argument-violation
check-for-procedure-arguments-consistency-violation
check-for-procedure-signature-argument-violation
check-for-procedure-signature-return-value-violation
check-for-true
check-newline
check-passed?
check-pretty-print
check-report
check-reset!
check-set-mode!
check-test-name
check-write
chmod
chown
circular-list
circular-list->list!
circular-list->list!/stx
circular-list-copy
circular-list-copy/stx
circular-list-length
circular-list-length/stx
circular-list/stx
circular-list=
circular-list=/stx
circular-list?
circular-list?/or-null
clear-all! on <bitvector>
clearenv
clock
clock-getcpuclockid
clock-getres
clock-gettime
clock-settime
clog
clog10
clone on <bitvector>
close
close-logging
close-master-sock
close-ports-in-close-on-exec-mode
close-server-port
closedir
command-line-option-action
command-line-option-brief
command-line-option-description
command-line-option-long
command-line-option-requires-argument?
command-line-option?
comparator-check-type
comparator-check-type-procedure
comparator-compare
comparator-comparison-procedure
comparator-comparison-procedure?
comparator-debug-error.comparator
comparator-debug-error.debug-comparator
comparator-debug-error?
comparator-equal?
comparator-equality-predicate
comparator-error?
comparator-hash
comparator-hash-function
comparator-hash-function?
comparator-max
comparator-min
comparator-nan-comparison-error.comparator
comparator-register-default!
comparator-test-type
comparator-test-type-procedure
comparator-type-check-procedure
comparator-type-error.comparator
comparator-type-error.objects
comparator-type-error?
comparator-type-test-procedure
comparator?
compare-by<
compare-by<=
compare-by=/<
compare-by=/>
compare-by>
compare-by>=
COMPILE-FLAGS
complex
complex-compare
compnum
compute-restarts
concatenate
concatenate!
concatenate!/stx
concatenate/stx
cond
cond-compare
cond-expand
condition-argument
condition-brief/long
condition-comparator-nan-comparison-error?
condition-errno
condition-h_errno
condition-inexact-real-comparator-with-ignored-epsilon?
condition-message
condition-option
confstr
confstr/string
connect
connect-in-port on <binary-input-only-channel>
connect-in-port on <textual-input-only-channel>
connect-ou-port on <binary-output-only-channel>
cons
cons*
continue-restart
coordinate
coordinate/false
coordinate?
copy-time
cosh
count
count/stx
counters:
cpow
cpu-architecture
create-pid-file
csin
csinh
csqrt
ctan
ctanh
ctermid
ctermid/string
curl
current-date
current-julian-day
current-message-size on <<channel>>
current-message-size on <channel>
current-modified-julian-day
current-time
cut
cute
daemon
daemonise
date->julian-day
date->modified-julian-day
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?
debug-compare
default-comparator
default-compare
define-argument-validation
define-c-flags
define-c-function
define-c-ior-flags
define-command-line-option
define-cond-expand
define-cond-expand-identifiers-helper
define-exact-integer->symbol-function
define-generic
define-generic*
define-generic*-definer
define-generic-definer
define-instantiable-body
define-list-tuple-type
define-maker
define-method
define-parser-logic
define-record-type
define-stream
define-variable
define-variable-alias
define-vector-tuple-type
delay
delete
delete!
delete-duplicates
delete-duplicates!
delivery-timeout-expired? on <<channel>>
delivery-timeout-expired? on <channel>
deque
deque->list
deque->vector
deque-copy!
deque-empty?
deque-exists
deque-exists-left
deque-exists-right
deque-filter
deque-find
deque-find-left
deque-find-right
deque-fold-left
deque-fold-right
deque-for-all
deque-for-each
deque-for-each-left
deque-for-each-right
deque-front
deque-getprop
deque-hash
deque-map
deque-map-left
deque-map-right
deque-not-empty?
deque-partition
deque-pop-front!
deque-pop-rear!
deque-property-list
deque-purge!
deque-push-front!
deque-push-rear!
deque-putprop
deque-rear
deque-remprop
deque-reverse!
deque-size?
deque?
description
directory-stream-closed?
directory-stream-fd
directory-stream-pathname
directory-stream-pointer
directory-stream?
dirfd
dirname
do-ec
do-one-event
do-one-fd-event
do-one-task-event
dotted-ilist?
dotted-list?
dotted-list?/or-null
drop
drop-left
drop-left/stx
drop-right
drop-right!
drop-right!/stx
drop-right/stx
drop-while
dup
dup2
dynamic-array
dynamic-array->list
dynamic-array->vector
dynamic-array-copy!
dynamic-array-empty?
dynamic-array-exists
dynamic-array-exists-left
dynamic-array-exists-right
dynamic-array-filter
dynamic-array-find
dynamic-array-find-left
dynamic-array-find-right
dynamic-array-fold-left
dynamic-array-fold-right
dynamic-array-for-all
dynamic-array-for-each
dynamic-array-for-each-left
dynamic-array-for-each-right
dynamic-array-front
dynamic-array-getprop
dynamic-array-hash
dynamic-array-insert!
dynamic-array-length
dynamic-array-map
dynamic-array-map-left
dynamic-array-map-right
dynamic-array-not-empty?
dynamic-array-partition
dynamic-array-pop-front!
dynamic-array-pop-rear!
dynamic-array-property-list
dynamic-array-purge!
dynamic-array-push-front!
dynamic-array-push-rear!
dynamic-array-putprop
dynamic-array-rear
dynamic-array-ref
dynamic-array-remove!
dynamic-array-remprop
dynamic-array-reverse!
dynamic-array-set!
dynamic-array-size
dynamic-array-sort
dynamic-array-sort!
dynamic-array?
eager
eighth
eighth/stx
else
end-of-char-set?
enqueue!
enter
enum-set
enum-set/false
environ
environ->table
environ-table
epoll-create
epoll-create1
epoll-ctl
epoll-event-alloc
epoll-event-ref-data-fd
epoll-event-ref-data-ptr
epoll-event-ref-data-u32
epoll-event-ref-data-u64
epoll-event-ref-events
epoll-event-set-data-fd!
epoll-event-set-data-ptr!
epoll-event-set-data-u32!
epoll-event-set-data-u64!
epoll-event-set-events!
epoll-event-size
epoll-wait
eq-comparator
equal-comparator
equal?
eqv-comparator
erf
erfc
errno-code
errno-code->symbol
errno-condition?
error
ether-aton
ether-aton-r
ether-hostton
ether-line
ether-line/string
ether-ntoa
ether-ntoa-r
ether-ntoa-r/string
ether-ntoa/string
ether-ntohost
ether-ntohost/string
eval
even-exact-integer
even-fixnum
even-signed-int
every
every*
every?-ec
exact-integer
exact-integer-in-exclusive-range
exact-integer-in-inclusive-range
exact-integer/false
exception
execl
execle
execlp
execv
execve
execvp
expiration-time on <<channel>>
expiration-time on <channel>
extension
false-if-exception
false-or-byte
false-or-bytevector-compound
false-or-octet
false-or-promise
fchdir
fchmod
fchown
fcntl
fd-in-close-on-exec-mode?
fd-in-non-blocking-mode?
fd-set-close-on-exec-mode!
fd-set-inspection
fd-set-non-blocking-mode!
fd-unset-close-on-exec-mode!
fd-unset-non-blocking-mode!
fdatasync
fdopendir
FD_CLR
FD_ISSET
FD_SET
FD_ZERO
fields
fifth
fifth/stx
file-absolute-pathname?
file-atime
file-bytevector-colon-search-path
file-bytevector-colon-search-path?
file-bytevector-pathname
file-bytevector-pathname?
file-colon-search-path
file-colon-search-path?
file-ctime
file-descriptor
file-descriptor/false
file-descriptor?
file-executable?
file-existence-procedure
file-is-block-device?
file-is-char-device?
file-is-directory?
file-is-fifo?
file-is-message-queue?
file-is-regular-file?
file-is-semaphore?
file-is-shared-memory?
file-is-socket?
file-is-symbolic-link?
file-mtime
file-pathname
file-pathname?
file-readable?
file-relative-pathname?
file-removal-procedure
file-size
file-string-colon-search-path
file-string-colon-search-path?
file-string-pathname
file-string-pathname?
file-writable?
filter
filter!
filter-map
filter-map*
filter-map*/stx
filter-map/stx
finalise
find
find-executable-as-bytevector
find-executable-as-string
find-restart
find-tail
first
first-bit-set on <bitvector>
first-ec
fixnum
fixnum->ascii-dec
fixnum->ascii-hex
fixnum-aligned-to-2?
fixnum-aligned-to-4?
fixnum-aligned-to-8?
fixnum-aligned-to?
fixnum-in-ascii-range?
fixnum-in-base10-range?
fixnum-in-base16-range?
fixnum-in-exclusive-range
fixnum-in-inclusive-range
fixnum-index
fixnum/false
flonum
flush on <<binary-output-channel>>
flush on <<textual-output-channel>>
flush on <binary-output-only-channel>
flush on <textual-output-only-channel>
flush-ports-in-close-on-exec-mode
fnmatch
fold
fold*
fold*/stx
fold-ec
fold-left*
fold-left*/stx
fold-left/pred
fold-left/stx
fold-right
fold-right*
fold-right*/stx
fold-right/stx
fold/stx
fold3-ec
for-each
for-each*
for-each*/stx
force
forget-fd
fork
fork-with-binary-ports
fork-with-fds
fork-with-textual-ports
format
format-flonum
format-output-column
fourth
fpathconf
fstat
fsync
ftruncate
futimes
gai-strerror
general-c-buffer
general-c-buffer*
general-c-buffer*/false
general-c-buffer-len
general-c-buffer.len
general-c-buffer/false
general-c-buffer?
general-c-sticky-buffer
general-c-sticky-buffer*
general-c-sticky-buffer*/false
general-c-sticky-buffer/false
general-c-sticky-buffer?
general-c-string
general-c-string*
general-c-string*/false
general-c-string.len
general-c-string/false
general-c-string?
generator
get-environment-variable
get-environment-variables
get-output-string
get-result
getaddrinfo
getcwd
getcwd/string
getegid
getenv
geteuid
getgid
getgrgid
getgrnam
getgroups
gethostbyaddr
gethostbyname
gethostbyname2
getitimer
getlogin
getlogin/string
getnetbyaddr
getnetbyname
getopts
getopts-condition?
getopts-options
getpeername
getpgrp
getpid
getppid
getprotobyname
getprotobynumber
getpwnam
getpwuid
getrlimit
getrusage
getservbyname
getservbynumber
getsid
getsockname
getsockopt
getsockopt/int
getsockopt/linger
getsockopt/size_t
gettimeofday
getuid
getumask
glob
glob/string
gmtime
greatest-c-off_t
greatest-c-off_t*
greatest-c-pointer
greatest-c-pointer*
greatest-c-ptrdiff_t
greatest-c-ptrdiff_t*
greatest-c-signed-char
greatest-c-signed-char*
greatest-c-signed-int
greatest-c-signed-int*
greatest-c-signed-long
greatest-c-signed-long*
greatest-c-signed-long-long
greatest-c-signed-long-long*
greatest-c-signed-short
greatest-c-signed-short*
greatest-c-size_t
greatest-c-size_t*
greatest-c-ssize_t
greatest-c-ssize_t*
greatest-c-unsigned-char
greatest-c-unsigned-char*
greatest-c-unsigned-int
greatest-c-unsigned-int*
greatest-c-unsigned-long
greatest-c-unsigned-long*
greatest-c-unsigned-long-long
greatest-c-unsigned-long-long*
greatest-c-unsigned-short
greatest-c-unsigned-short*
greatest-machine-word
greatest-machine-word*
greatest-s128
greatest-s128*
greatest-s16
greatest-s16*
greatest-s256
greatest-s256*
greatest-s32
greatest-s32*
greatest-s64
greatest-s64*
greatest-s8
greatest-s8*
greatest-u128
greatest-u128*
greatest-u16
greatest-u16*
greatest-u256
greatest-u256*
greatest-u32
greatest-u32*
greatest-u64
greatest-u64*
greatest-u8
greatest-u8*
group-entries
gtree->itree
gtree->tree
handler-bind
handler-case
hash
hash on <bitvector>
hash-by-identity
hash-table->alist
hash-table-copy
hash-table-delete!
hash-table-equivalence-function
hash-table-exists?
hash-table-fold
hash-table-hash-function
hash-table-keys
hash-table-merge!
hash-table-ref
hash-table-ref/default
hash-table-set!
hash-table-size
hash-table-update!
hash-table-update!/default
hash-table-values
hash-table-walk
hash-table?
hook->list
hook-empty?
hook?
host-entries
htonl
htons
h_errno->string
h_errno-condition?
h_strerror
ialist-cons
ialist-copy
ialist-delete
iany
iappend
iappend-map
iappend-reverse
iapply
iassoc
iassq
iassv
ibreak
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
iconcatenate
iconv!
iconv-close
iconv-closed?
iconv-encoding
iconv-encoding-aliases?
iconv-encoding=?
iconv-open
iconv?
icount
idelete
idelete-duplicates
identifier
identifier/false
ideque-chain-first-link
ideque-chain-last-link
ideque-chain?
ideque-deque?
ideque-dynamic-array?
ideque-empty?
ideque-front
ideque-pop-front!
ideque-pop-rear!
ideque-push-front!
ideque-push-rear!
ideque-rear
ideque?
idrop
idrop-left
idrop-right
idrop-while
ieighth
ievery
if
if-nameindex
if-nametoindex
if-not=?
if3
if<=?
if<?
if=?
if>=?
if>?
ififth
ifilter
ifilter-map
ifind
ifind-tail
ifirst
ifold
ifold-right
ifor-each
ifourth
ignore-errors
iiota
ikptr
ilast
ilength
ilist
ilist->list
ilist-copy
ilist-index
ilist-ref
ilist-tabulate
ilist-tail
ilist=
ilist?
imap
imap-in-order
imember
imemq
imemv
implementation-name
implementation-version
in-closed-interval?
in-closed-open-interval?
in-open-closed-interval?
in-open-interval?
in6addr_any
in6addr_loopback
IN6_ARE_ADDR_EQUAL
IN6_IS_ADDR_LINKLOCAL
IN6_IS_ADDR_LOOPBACK
IN6_IS_ADDR_MC_GLOBAL
IN6_IS_ADDR_MC_LINKLOCAL
IN6_IS_ADDR_MC_NODELOCAL
IN6_IS_ADDR_MC_ORGLOCAL
IN6_IS_ADDR_MC_SITELOCAL
IN6_IS_ADDR_MULTICAST
IN6_IS_ADDR_SITELOCAL
IN6_IS_ADDR_UNSPECIFIED
IN6_IS_ADDR_V4COMPAT
IN6_IS_ADDR_V4MAPPED
inactive? on <<channel>>
inactive? on <channel>
include
include/lexical-context
index-and-count-for-bytevector
index-and-count-for-string
index-and-count-for-vector
index-for-bytevector
index-for-string
index-for-vector
inet-aton
inet-ntoa
inet-ntoa/string
inet-ntop
inet-ntop/string
inet-pton
inexact-real-comparator-with-ignored-epsilon.epsilon
inexact-real-comparator-with-ignored-epsilon.rounding
ininth
initialise
inotify-add-watch
inotify-init
inotify-init1
inotify-rm-watch
input-file:
input-port
input-port/false
input-port:
input-string:
input/output-port
input/output-port/false
integer-compare
invalid-option-condition?
invoke-restart
IN_BADCLASS
IN_CLASSA
IN_CLASSB
IN_CLASSC
IN_CLASSD
IN_EXPERIMENTAL
IN_MULTICAST
ioctl
ior on <bitvector>
ior! on <bitvector>
iota
iota/stx
ip-protocol
ipair
ipair*
ipair->pair
ipair-fold
ipair-fold-right
ipair-for-each
ipair?
ipartition
iq
iquasiquote
iqueue-chain-first-link
iqueue-chain-last-link
iqueue-chain?
iqueue-deque?
iqueue-dynamic-array?
iqueue-empty?
iqueue-pop!
iqueue-push!
iqueue-queue?
iqueue-top
iqueue?
iquote
ireduce
ireduce-right
iremove
ireverse
irregex
irregex-extract
irregex-fold
irregex-fold/chunked
irregex-match
irregex-match-data?
irregex-match-end-index
irregex-match-start-index
irregex-match-subchunk
irregex-match-substring
irregex-match/chunked
irregex-opt
irregex-quote
irregex-replace
irregex-replace/all
irregex-search
irregex-search/chunked
irregex-split
irregex?
isecond
iseventh
isixth
ispan
isplit-at
istack-chain-first-pair
istack-chain?
istack-deque?
istack-dynamic-array?
istack-empty?
istack-ilist-first-pair
istack-ilist?
istack-list-first-pair
istack-list?
istack-pop!
istack-push!
istack-ralist-first-pair
istack-ralist?
istack-stack?
istack-top
istack?
itake
itake-left
itake-right
itake-while
itenth
iteration-thunk-exists
iteration-thunk-filter
iteration-thunk-find
iteration-thunk-fold
iteration-thunk-for-all
iteration-thunk-for-each
iteration-thunk-map
iteration-thunk-partition
ithird
itree->tree
iunfold
iunfold-right
iunquote
iunquote-splicing
iunzip1
iunzip2
iunzip3
iunzip4
iunzip5
izip
j0
j1
jn
julian-day->date
julian-day->time-monotonic
julian-day->time-tai
julian-day->time-utc
keyword
kill
kth-largest
last
last-ec
last-ipair
last-pair
last-pair/stx
last/stx
lazy
LDFLAGS
least-c-off_t
least-c-off_t*
least-c-pointer
least-c-pointer*
least-c-ptrdiff_t
least-c-ptrdiff_t*
least-c-signed-char
least-c-signed-char*
least-c-signed-int
least-c-signed-int*
least-c-signed-long
least-c-signed-long*
least-c-signed-long-long
least-c-signed-long-long*
least-c-signed-short
least-c-signed-short*
least-c-size_t
least-c-size_t*
least-c-ssize_t
least-c-ssize_t*
least-c-unsigned-char
least-c-unsigned-char*
least-c-unsigned-int
least-c-unsigned-int*
least-c-unsigned-long
least-c-unsigned-long*
least-c-unsigned-long-long
least-c-unsigned-long-long*
least-c-unsigned-short
least-c-unsigned-short*
least-machine-word
least-machine-word*
least-s128
least-s128*
least-s16
least-s16*
least-s256
least-s256*
least-s32
least-s32*
least-s64
least-s64*
least-s8
least-s8*
least-u128
least-u128*
least-u16
least-u16*
least-u256
least-u256*
least-u32
least-u32*
least-u64
least-u64*
least-u8
least-u8*
leave-asap
length
length on <bitvector>
length+
length<=?
let
let*-inline
let*-keywords
let*-values
let-inline
let-keywords
let-values
letrec*-keywords
letrec-keywords
levenshtein
levenshtein/predicate
lex
lexer-format:
lexer-get-func-column
lexer-get-func-getc
lexer-get-func-line
lexer-get-func-offset
lexer-get-func-ungetc
lexer-input-system?
lgamma
library-imports:
library-language:
library-spec:
linear-access-list->random-access-list
link
LINK-FLAGS
list
list on <bitvector>
list->bag
list->bag!
list->bitvector
list->chain
list->char-set
list->char-set!
list->circular-list!
list->circular-list!/stx
list->deque
list->dynamic-array
list->ilist
list->position
list->queue
list->set
list->set!
list->stack
list->stream
list->string
list->vector
list-compare
list-compare-as-vector
list-copy
list-copy/stx
list-ec
list-index
list-index*
list-levenshtein
list-levenshtein/eq
list-levenshtein/equal
list-levenshtein/eqv
list-levenshtein/predicate
list-of-bytevectors
list-of-coordinates
list-of-positions
list-of-segments?
list-of-strings
list-of-symbols
list-ref
list-ref/update
list-set
list-tabulate
list-tabulate/reverse
list-tabulate/reverse/stx
list-tabulate/stx
list-tail
list=
list=?
list?
listen
little
localtime
lock-pid-file-condition?
lockf
log
log-condition-message
log-pathname
log-port
log-prefix
log-procedure
logging-enabled?
long
lseek
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<=?
lset=
lset=?
lstat
lutimes
machine-name
machine-word
machine-word/false
machine-word?
madvise
mailx
make-amb-exhaustion
make-amb-not-initialised
make-argument-condition
make-array
make-binary-heap
make-binary-heap-iteration-thunk
make-binary-node
make-binary-tree-backwards-breadth-first-iteration-thunk
make-binary-tree-backwards-in-order-iteration-thunk
make-binary-tree-backwards-level-order-iteration-thunk
make-binary-tree-backwards-post-order-iteration-thunk
make-binary-tree-backwards-pre-order-iteration-thunk
make-binary-tree-forwards-breadth-first-iteration-thunk
make-binary-tree-forwards-in-order-iteration-thunk
make-binary-tree-forwards-level-order-iteration-thunk
make-binary-tree-forwards-post-order-iteration-thunk
make-binary-tree-forwards-pre-order-iteration-thunk
make-brief/long-condition
make-bytevector-comparator
make-bytevector-s8-iteration-thunk
make-bytevector-u8-iteration-thunk
make-car-comparator
make-cdr-comparator
make-chain-backwards-iteration-thunk
make-chain-forwards-iteration-thunk
make-chain-link
make-char-lexer
make-client-socket
make-code-lexer
make-command-line-option
make-comparator
make-comparator-debug-error
make-comparator-error
make-comparator-hashtable
make-comparator-nan-comparison-error-condition
make-comparator-type-error
make-comparison<
make-comparison<=
make-comparison=/<
make-comparison=/>
make-comparison>
make-comparison>=
make-date
make-debug-comparator
make-deque
make-deque-front-iteration-thunk
make-deque-rear-iteration-thunk
make-directory-stream
make-dynamic-array
make-dynamic-array-front-iteration-thunk
make-dynamic-array-rear-iteration-thunk
make-errno-condition
make-fd-set-bytevector
make-fd-set-memory-block
make-fd-set-pointer
make-getopts-condition
make-hash-table
make-hook
make-h_errno-condition
make-icar-comparator
make-icdr-comparator
make-ideque on <ideque>
make-ideque-chain
make-ideque-deque
make-ideque-dynamic-array
make-ilist
make-ilist-comparator
make-ilist-iteration-thunk
make-improper-ilist-comparator
make-improper-list-comparator
make-inexact-real-comparator
make-inexact-real-comparator-with-ignored-epsilon-condition
make-invalid-option-condition
make-iqueue on <iqueue>
make-iqueue-chain
make-iqueue-deque
make-iqueue-dynamic-array
make-iqueue-queue
make-irregex-chunker
make-IS
make-istack on <istack>
make-istack-chain
make-istack-deque
make-istack-dynamic-array
make-istack-ilist
make-istack-list
make-istack-ralist
make-istack-stack
make-lexer
make-list
make-list-comparator
make-list-iteration-thunk
make-list/stx
make-listwise-comparator
make-lock-pid-file-condition
make-master-sock
make-max-count-lexer
make-object-property
make-option-condition
make-option-requires-no-value-condition
make-option-requires-value-condition
make-pair-comparator
make-parameter
make-pid-file-already-exists-condition
make-pid-file-creation-condition
make-pid-file-error-condition
make-pid-file-invalid-contents-condition
make-pid-file-missing-condition
make-pid-file-removal-condition
make-position
make-queue
make-queue-iteration-thunk
make-rabin-karp
make-random-source
make-random-source/blum-blum-shub
make-random-source/borosh
make-random-source/cmrg
make-random-source/device
make-random-source/marsaglia/cong
make-random-source/marsaglia/fib
make-random-source/marsaglia/kiss
make-random-source/marsaglia/lfib4
make-random-source/marsaglia/mwc
make-random-source/marsaglia/shr3
make-random-source/marsaglia/swb
make-random-source/mersenne
make-random-source/mrg32k3a
make-refining-comparator
make-restarts-control-error
make-restarts-error
make-reverse-comparator
make-rtd
make-selecting-comparator
make-server-sock-and-port
make-server-socket
make-sockaddr_in
make-sockaddr_in6
make-sockaddr_un
make-spine-iteration-thunk
make-stack
make-stack-iteration-thunk
make-string
make-string-iteration-thunk
make-struct-addrinfo
make-struct-group
make-struct-hostent
make-struct-inotify-event
make-struct-itimerspec
make-struct-itimerval
make-struct-mq-attr
make-struct-netent
make-struct-passwd
make-struct-protoent
make-struct-rlimit
make-struct-rusage
make-struct-servent
make-struct-siginfo_t
make-struct-stat
make-struct-timespec
make-struct-timeval
make-struct-tm
make-struct-tms
make-time
make-traced-procedure
make-tree-lexer
make-unbalanced-binary-node
make-undefined-restart-error
make-unix-pathname-normalisation-error
make-unix-pathname-parser-error
make-unknown-option-condition
make-unsupported-comparator-operation-error
make-variable
make-vector
make-vector-comparator
make-vector-iteration-thunk
make-vectorwise-comparator
make-weak-hashtable
make<
make<=
make=
make>
make>=
mandatory
map
map!
map!/stx
map*
map*!
map*!/stx
map*/stx
map-in-order
map-in-order*
map-in-order*/stx
match
max-compare
max-ec
maximum-message-portion-size on <binary-input-only-channel>
maximum-message-portion-size on <textual-input-only-channel>
maximum-message-size on <<channel>>
maximum-message-size on <channel>
member
member*
memory-block
memory-block/false
memq
memv
merge-with-multimethods
message-terminators on <<binary-input-channel>>
message-terminators on <<textual-input-channel>>
message-terminators on <binary-input-only-channel>
message-terminators on <textual-input-only-channel>
message-type
min-compare
min-ec
mkdir
mkdir/parents
mkdtemp
mkfifo
mkstemp
mlock
mlockall
mmap
modified-julian-day->date
modified-julian-day->time-monotonic
modified-julian-day->time-tai
modified-julian-day->time-utc
mq-close
mq-getattr
mq-open
mq-receive
mq-send
mq-setattr
mq-timedreceive
mq-timedsend
mq-unlink
mremap
msync
munlock
munlockall
munmap
nanosleep
negative-exact-integer
negative-fixnum
negative-off_t?
negative-ptrdiff_t?
negative-signed-char?
negative-signed-int
negative-signed-int?
negative-signed-long-long?
negative-signed-long?
negative-ssize_t?
negative-word-s128?
negative-word-s16?
negative-word-s256?
negative-word-s32?
negative-word-s64?
negative-word-s8?
nested
network-entries
network-port-number
network-port-number/false
network-port-number?
next-method?
ninth
ninth/stx
non-empty-bytevector
non-empty-bytevector/false
non-empty-string
non-empty-string/false
non-empty-vector
non-empty-vector/false
non-negative-exact-integer
non-negative-exact-integer on <bitvector>
non-negative-exact-integer->bitvector
non-negative-fixnum
non-negative-fixnum/false
non-negative-off_t?
non-negative-ptrdiff_t?
non-negative-signed-char?
non-negative-signed-int
non-negative-signed-int?
non-negative-signed-long-long?
non-negative-signed-long?
non-negative-ssize_t?
non-negative-word-s128?
non-negative-word-s16?
non-negative-word-s256?
non-negative-word-s32?
non-negative-word-s64?
non-negative-word-s8?
non-null-pointer
non-positive-exact-integer
non-positive-fixnum
non-positive-fixnum/false
non-positive-off_t?
non-positive-ptrdiff_t?
non-positive-signed-char?
non-positive-signed-int
non-positive-signed-int?
non-positive-signed-long-long?
non-positive-signed-long?
non-positive-ssize_t?
non-positive-word-s128?
non-positive-word-s16?
non-positive-word-s256?
non-positive-word-s32?
non-positive-word-s64?
non-positive-word-s8?
non-zero-fixnum
non-zero-fixnum/false
normalise
normalise-segments
not
not on <bitvector>
not! on <bitvector>
not-ipair?
not-pair?
not=?
ntohl
ntohs
null-ilist?
null-list?
null?
number
number-compare
number-of-dimensions
object->string
object-property-default-value
object-property-initial-capacity
octet
odd-exact-integer
odd-fixnum
odd-signed-int
off_t
off_t/false
off_t?
on-bad-count-function
on-bad-end-name-function
on-final-function
on-group-begin-function
on-group-end-function
on-test-begin-function
on-test-end-function
one-off-index-for-string
open
open-binary-input-port-pair
open-binary-input/output-port-pair
open-binary-output-port-pair
open-input-string
open-logging
open-output-string
open-port
open-textual-input-port-pair
open-textual-input/output-port-pair
open-textual-output-port-pair
opendir
operand-processor
operand-type-inspector
option
option-condition?
option-names
option-optional-arg?
option-processor
option-required-arg?
option-requires-no-value-condition?
option-requires-value-condition?
optional
or
or-null?
or-null?/stx
os-name
os-version
output-file:
output-port
output-port/false
output-port:
output-value:
pair
pair->ipair
pair-compare
pair-compare-car
pair-compare-cdr
pair-fold
pair-fold*
pair-fold-right
pair-for-each
pair-for-each*
pair-for-each*/stx
pair-for-each/stx
pair?
pairwise-not=?
parameterize
parse-flonum
parse-pathname
parse-segment
parse-segment-nz
parse-slash-and-segment
partition
partition!
pathconf
pathname-bytevector->string
pathname?
pause
pclose
pid-file-already-exists-condition?
pid-file-creation-condition?
pid-file-error-condition?
pid-file-invalid-contents-condition?
pid-file-missing-condition?
pid-file-removal-condition?
pid-pathname
pipe
pipeline
pointer
pointer-integer
pointer-integer/false
pointer-integer?
pointer/false
poll
popen
port
port->stream
port-in-close-on-exec-mode?
port-set-close-on-exec-mode!
port-unset-close-on-exec-mode!
port/false
port:
position
position-copy
position-dimension
position-index
position-index?
position-ref
position-set!
position/false
position/stx
position=?
position?
positive-exact-integer
positive-fixnum
positive-off_t?
positive-ptrdiff_t?
positive-signed-char?
positive-signed-int
positive-signed-int?
positive-signed-long-long?
positive-signed-long?
positive-ssize_t?
positive-word-s128?
positive-word-s16?
positive-word-s256?
positive-word-s32?
positive-word-s64?
positive-word-s8?
posix-signal->symbol
pread
prefix?
pregexp
pregexp-match
pregexp-match-positions
pregexp-quote
pregexp-replace
pregexp-replace*
pregexp-split
prepend
pretty-print:
prlimit
procedure
procedure/false
procedure:
product-ec
promise
proper-ilist?
proper-list?
protocol-entries
ptrdiff_t
ptrdiff_t/false
ptrdiff_t?
pwrite
quasiquote
queue
queue->list
queue->vector
queue-copy!
queue-empty?
queue-exists
queue-exists-left
queue-exists-right
queue-filter
queue-find
queue-find-left
queue-find-right
queue-fold-left
queue-fold-right
queue-for-all
queue-for-each
queue-for-each-left
queue-for-each-right
queue-front
queue-getprop
queue-hash
queue-map
queue-map-left
queue-map-right
queue-not-empty?
queue-partition
queue-pop!
queue-property-list
queue-purge!
queue-push!
queue-putprop
queue-rear
queue-remprop
queue-reverse!
queue-size?
queue?
quote
rabin-karp
rabin-karp-search
rabin-karp?
raise
raise-comparator-argument-type-error
raise-comparator-debug-error
raise-comparator-nan-comparison-error
raise-comparator-type-error
raise-invalid-option
raise-option-requires-no-value
raise-option-requires-value
raise-unix-pathname-normalisation-error
raise-unix-pathname-parser-error
raise-unknown-option
raise-unsupported-comparator-operation-error
rand
random-access-list->linear-access-list
random-bytevector
random-bytevector!
random-device-cache-length
random-exponentials-maker
random-integer
random-integers-with-sum
random-list-sample
random-list-sample-population
random-list-shuffle
random-list-unfold-numbers
random-normals-maker
random-permutations-maker
random-real
random-reals-with-sum
random-source-integers-maker
random-source-integers-maker-from-range
random-source-jumpahead!
random-source-make-integers