Next: , Previous: , Up: MIT/GNU Scheme   [Contents][Index]

Appendix B Binding Index

Jump to:   "   #   '   (   )   *   +   ,   -   .   /   1   2   8   <   =   >   ?   \   _   `  
A   B   C   D   E   F   G   H   I   J   K   L   M   N   O   P   Q   R   S   T   U   V   W   X   Y   Z  
Index Entry  Section

": Strings

#: Syntax of numerical constants
#!optional: Additional Notations
#!optional: Lambda Expressions
#!rest: Additional Notations
#!rest: Lambda Expressions
#(: Vectors
#b: Syntax of numerical constants
#d: Syntax of numerical constants
#e: Syntax of numerical constants
#f: True and False
#f: Conditionals
#f: Booleans
#i: Syntax of numerical constants
#o: Syntax of numerical constants
#t: True and False
#t: Conditionals
#t: Booleans
#x: Syntax of numerical constants
#\: Characters
#\alarm: Characters
#\backspace: Characters
#\delete: Characters
#\escape: Characters
#\newline: Characters
#\null: Characters
#\return: Characters
#\space: Characters
#\space: Strings
#\tab: Characters

': Quoting
': Lists

(: Lists
(): Lists

): Lists

*: Procedure Call Syntax
*: Numerical operations
*: Regular S-Expressions
*: *Matcher
*: *Parser
*: R7RS
**: Regular S-Expressions
**: Regular S-Expressions
**?: Regular S-Expressions
*?: Regular S-Expressions
*default-pathname-defaults*: Operations on Pathnames
*matcher: *Matcher
*parser: *Parser
*parser-canonicalize-symbols?*: Input Procedures
*parser-radix*: Input Procedures
*random-state*: Random Number Generation
*unparse-with-maximum-readability?*: Output Procedures
*unparser-list-breadth-limit*: Output Procedures
*unparser-list-depth-limit*: Output Procedures
*unparser-radix*: Output Procedures
*unparser-string-length-limit*: Output Procedures

+: Procedure Call Syntax
+: Exactness
+: Numerical operations
+: Regular S-Expressions
+: *Matcher
+: *Parser
+: R7RS
+?: Regular S-Expressions
+inf.0: Flonum Operations
+nan.0: Flonum Operations
+snan.1: Flonum Operations

,: Quoting
,: Lists
,@: Quoting
,@: Lists

-: Numerical operations
-: R7RS
-1+: Numerical operations
->char-set: SRFI 14
->namestring: Filenames and Pathnames
->pathname: Filenames and Pathnames
->pathname: Working Directory
->truename: File Manipulation
-inf.0: Flonum Operations
-nan.0: Flonum Operations
-snan.1: Flonum Operations

.: Lists
...: Pattern Language
...: R7RS

/: Implementation restrictions
/: Numerical operations
/: R7RS

1+: Numerical operations
1d-table/alist: 1D Tables
1d-table/get: 1D Tables
1d-table/lookup: 1D Tables
1d-table/put!: 1D Tables
1d-table/remove!: 1D Tables
1d-table?: 1D Tables

2d-get: The Association Table
2d-get-alist-x: The Association Table
2d-get-alist-y: The Association Table
2d-put!: The Association Table
2d-remove!: The Association Table

8-bit-char-set?: Character Sets

<: Numerical operations
<: R7RS
<=: Numerical operations
<=: R7RS
<=?: SRFI 128
<?: SRFI 128
<xml-!attlist>: XML Structure
<xml-!element>: XML Structure
<xml-!entity>: XML Structure
<xml-!notation>: XML Structure
<xml-declaration>: XML Structure
<xml-document>: XML Structure
<xml-dtd>: XML Structure
<xml-element>: XML Structure
<xml-external-id>: XML Structure
<xml-parameter-!entity>: XML Structure
<xml-processing-instructions>: XML Structure
<xml-unparsed-!entity>: XML Structure

=: Equivalence Predicates
=: Equivalence Predicates
=: Numerical operations
=: Numerical operations
=: Strings
=: R7RS
=>: Conditionals
=>: R7RS
=?: SRFI 128

>: Numerical operations
>: R7RS
>=: Numerical operations
>=: R7RS
>=?: SRFI 128
>?: SRFI 128

?: Regular S-Expressions
?: *Matcher
?: *Parser
??: Regular S-Expressions

\": Strings
\a: Strings
\b: Strings
\n: Strings
\r: Strings
\t: Strings
\x: Strings
\\: Strings
\|: Strings

_: R7RS

`: Quoting
`: Lists

abort: Restarts
abort: Invoking Standard Restart Code
abs: Numerical operations
abs: R7RS
access: Assignments
access-condition: Generating Operations on Conditions
access-condition: Simple Condition Instance Operations
acos: Numerical operations
acos: R7RS
acos/pi: Numerical operations
aexsec: Numerical operations
aexsec/pi: Numerical operations
alist->amap: Amap constructors
alist->hash-table: Construction of Hash Tables
alist->hash-table: Construction of Hash Tables
alist->hash-table: SRFI 69
alist->hash-table: SRFI 125
alist->rb-tree: Red-Black Trees
alist->wt-tree: Construction of Weight-Balanced Trees
alist-cons: SRFI 1
alist-copy: Association Lists
alist-copy: SRFI 1
alist-delete: SRFI 1
alist-delete!: SRFI 1
alist?: Association Lists
allocate-host-address: Miscellaneous OS Facilities
alt: Regular S-Expressions
alt: *Matcher
alt: *Parser
amap->alist: Amap copying and conversion
amap-args: Amap accessors
amap-clean!: Amap mutators
amap-clear!: Amap mutators
amap-comparator: Amap accessors
amap-contains?: Amap predicates
amap-copy: Amap copying and conversion
amap-count: Amap contents
amap-delete!: Amap mutators
amap-difference!: Amaps as sets
amap-empty-copy: Amap copying and conversion
amap-empty?: Amap predicates
amap-entries: Amap contents
amap-find: Amap contents
amap-fold: Amap mapping and folding
amap-for-each: Amap mapping and folding
amap-implementation-name: Amap accessors
amap-implementation-names: Amap constructors
amap-implementation-supported-args: Amap constructors
amap-implementation-supports-args?: Amap constructors
amap-implementation-supports-comparator?: Amap constructors
amap-intern!: Amap mutators
amap-intersection!: Amaps as sets
amap-keys: Amap contents
amap-map: Amap mapping and folding
amap-map!: Amap mapping and folding
amap-map->list: Amap mapping and folding
amap-mutable?: Amap predicates
amap-pop!: Amap mutators
amap-prune!: Amap mapping and folding
amap-ref: Amap accessors
amap-ref/default: Amap accessors
amap-set!: Amap mutators
amap-size: Amap contents
amap-unfold: Amap constructors
amap-union!: Amaps as sets
amap-update!: Amap mutators
amap-update!/default: Amap mutators
amap-values: Amap contents
amap-xor!: Amaps as sets
amap=?: Amap predicates
amap?: Amap predicates
and: Conditionals
and: Booleans
and: R7RS
and-let*: and-let* (SRFI 2)
and-let*: SRFI 2
angle: Numerical operations
angle: Numerical operations
angle: R7RS
any: Mapping of Lists
any: SRFI 1
any-char: Regular S-Expressions
append: Cutting and Pasting Lists
append: R7RS
append: SRFI 1
append!: Cutting and Pasting Lists
append!: SRFI 1
append-map: Mapping of Lists
append-map: SRFI 1
append-map!: Mapping of Lists
append-map!: SRFI 1
append-map*: Mapping of Lists
append-map*!: Mapping of Lists
append-reverse: SRFI 1
append-reverse!: SRFI 1
apply: Procedure Operations
apply: R7RS
apply-hook-extra: Application Hooks
apply-hook-procedure: Application Hooks
apply-hook?: Application Hooks
arithmetic-shift: Bit operations
asin: Numerical operations
asin: R7RS
asin/pi: Numerical operations
assoc: Association Lists
assoc: R7RS
assoc: SRFI 1
association-procedure: Association Lists
assq: Association Lists
assq: R7RS
assq: SRFI 1
assv: Association Lists
assv: R7RS
assv: SRFI 1
atan: Numerical operations
atan: Numerical operations
atan: Flonum Operations
atan: R7RS
atan/pi: Numerical operations
atan2/pi: Numerical operations
aversin: Numerical operations
aversin/pi: Numerical operations

beep: Output Procedures
begin: Sequencing
begin: R7RS
binary-port?: Ports
binary-port?: R7RS
bind-cell-contents!: Parameters
bind-condition-handler: Error System
bind-condition-handler: Condition Signalling
bind-condition-handler: Condition Handling
bind-condition-handler: Condition Handling
bind-default-condition-handler: Condition Signalling
bind-default-condition-handler: Condition Handling
bind-default-condition-handler: Condition Handling
bit: Bit operations
bit-antimask: Bit operations
bit-clear?: Bit operations
bit-count: Bit operations
bit-mask: Bit operations
bit-set?: Bit operations
bit-string->signed-integer: Integer Conversions of Bit Strings
bit-string->unsigned-integer: Integer Conversions of Bit Strings
bit-string-allocate: Construction of Bit Strings
bit-string-and: Bitwise Operations on Bit Strings
bit-string-and!: Bitwise Operations on Bit Strings
bit-string-andc: Bitwise Operations on Bit Strings
bit-string-andc!: Bitwise Operations on Bit Strings
bit-string-append: Cutting and Pasting Bit Strings
bit-string-clear!: Selecting Bit String Components
bit-string-copy: Construction of Bit Strings
bit-string-fill!: Modification of Bit Strings
bit-string-length: Selecting Bit String Components
bit-string-move!: Modification of Bit Strings
bit-string-movec!: Bitwise Operations on Bit Strings
bit-string-not: Bitwise Operations on Bit Strings
bit-string-or: Bitwise Operations on Bit Strings
bit-string-or!: Bitwise Operations on Bit Strings
bit-string-ref: Selecting Bit String Components
bit-string-set!: Selecting Bit String Components
bit-string-xor: Bitwise Operations on Bit Strings
bit-string-xor!: Bitwise Operations on Bit Strings
bit-string-zero?: Bitwise Operations on Bit Strings
bit-string=?: Bitwise Operations on Bit Strings
bit-string?: Selecting Bit String Components
bit-substring: Cutting and Pasting Bit Strings
bit-substring-find-next-set-bit: Selecting Bit String Components
bit-substring-move-right!: Modification of Bit Strings
bitless-char?: Character implementation
bits: Bit operations
bitwise-and: Bit operations
bitwise-andc1: Bit operations
bitwise-andc2: Bit operations
bitwise-eqv: Bit operations
bitwise-ior: Bit operations
bitwise-nand: Bit operations
bitwise-nor: Bit operations
bitwise-not: Bit operations
bitwise-orc1: Bit operations
bitwise-orc2: Bit operations
bitwise-xor: Bit operations
boolean-comparator: SRFI 162
boolean-hash: SRFI 128
boolean/and: Booleans
boolean/or: Booleans
boolean=?: R7RS
boolean?: Booleans
boolean?: R7RS
both: Strings
bound-restart: Finding and Invoking General Restart Code
bound-restarts: Finding and Invoking General Restart Code
bracketed-print-method: Custom Output
break: SRFI 1
break!: SRFI 1
break-on-signals: Condition Signalling
break-on-signals: Condition Handling
break-on-signals: Condition Handling
buffered-input-chars on textual input port: Textual Input Port Operations
buffered-output-chars on textual output port: Textual Output Port Operations
bytevector: R7RS
bytevector->generator: SRFI 158
bytevector-accumulator: SRFI 158
bytevector-accumulator!: SRFI 158
bytevector-append: R7RS
bytevector-copy: R7RS
bytevector-copy!: R7RS
bytevector-length: R7RS
bytevector-u8-ref: R7RS
bytevector-u8-set!: R7RS
bytevector?: R7RS

caaaar: Pairs
caaaar: R7RS
caaaar: SRFI 1
caaadr: Pairs
caaadr: R7RS
caaadr: SRFI 1
caaar: Pairs
caaar: R7RS
caaar: SRFI 1
caadar: Pairs
caadar: R7RS
caadar: SRFI 1
caaddr: Pairs
caaddr: R7RS
caaddr: SRFI 1
caadr: Pairs
caadr: R7RS
caadr: SRFI 1
caar: Pairs
caar: R7RS
caar: SRFI 1
cadaar: Pairs
cadaar: R7RS
cadaar: SRFI 1
cadadr: Pairs
cadadr: R7RS
cadadr: SRFI 1
cadar: Pairs
cadar: R7RS
cadar: SRFI 1
caddar: Pairs
caddar: R7RS
caddar: SRFI 1
cadddr: Pairs
cadddr: R7RS
cadddr: SRFI 1
caddr: Pairs
caddr: R7RS
caddr: SRFI 1
cadr: Pairs
cadr: R7RS
cadr: SRFI 1
call-with-binary-input-file: File Ports
call-with-binary-input-file: File Ports
call-with-binary-output-file: File Ports
call-with-binary-output-file: File Ports
call-with-current-continuation: Continuations
call-with-current-continuation: R7RS
call-with-input-file: File Ports
call-with-input-file: R7RS
call-with-output-bytevector: Bytevector Ports
call-with-output-file: File Ports
call-with-output-file: R7RS
call-with-output-string: String Ports
call-with-port: Ports
call-with-port: File Ports
call-with-port: File Ports
call-with-port: R7RS
call-with-temporary-file-pathname: File Manipulation
call-with-truncated-output-port: Ports
call-with-truncated-output-port: String Ports
call-with-truncated-output-string: String Ports
call-with-truncated-output-string: String Ports
call-with-truncated-output-string: String Ports
call-with-values: Continuations
call-with-values: R7RS
call/cc: R7RS
canonical-host-name: Miscellaneous OS Facilities
capture-syntactic-environment: SC Transformer Definition
car: Storage Model
car: Pairs
car: Streams
car: R7RS
car: SRFI 1
car+cdr: Pairs
car+cdr: SRFI 1
case: Conditionals
case: Sequencing
case: R7RS
case-lambda: R7RS
cd: Working Directory
cdaaar: Pairs
cdaaar: R7RS
cdaaar: SRFI 1
cdaadr: Pairs
cdaadr: R7RS
cdaadr: SRFI 1
cdaar: Pairs
cdaar: R7RS
cdaar: SRFI 1
cdadar: Pairs
cdadar: R7RS
cdadar: SRFI 1
cdaddr: Pairs
cdaddr: R7RS
cdaddr: SRFI 1
cdadr: Pairs
cdadr: R7RS
cdadr: SRFI 1
cdar: Pairs
cdar: R7RS
cdar: SRFI 1
cddaar: Pairs
cddaar: R7RS
cddaar: SRFI 1
cddadr: Pairs
cddadr: R7RS
cddadr: SRFI 1
cddar: Pairs
cddar: R7RS
cddar: SRFI 1
cdddar: Pairs
cdddar: R7RS
cdddar: SRFI 1
cddddr: Pairs
cddddr: R7RS
cddddr: SRFI 1
cdddr: Pairs
cdddr: R7RS
cdddr: SRFI 1
cddr: Pairs
cddr: R7RS
cddr: SRFI 1
cdr: Entry Format
cdr: Pairs
cdr: Streams
cdr: R7RS
cdr: SRFI 1
ceiling: Numerical operations
ceiling: R7RS
ceiling->exact: Numerical operations
ceiling-quotient: Numerical operations
ceiling-remainder: Numerical operations
ceiling/: Numerical operations
cell-contents: Parameters
cell?: Parameters
char: *Matcher
char->bitless-char: Character implementation
char->digit: Characters
char->integer: Characters
char->integer: R7RS
char->name: Characters
char-alphabetic?: Characters
char-alphabetic?: R7RS
char-alphanumeric?: Characters
char-bits: Character implementation
char-bits-limit: Character implementation
char-ci: Regular S-Expressions
char-ci: *Matcher
char-ci-comparator: SRFI 162
char-ci-hash: SRFI 128
char-ci-predicate: Character implementation
char-ci<=?: Characters
char-ci<=?: R7RS
char-ci<?: Characters
char-ci<?: R7RS
char-ci=?: Characters
char-ci=?: R7RS
char-ci>=?: Characters
char-ci>=?: R7RS
char-ci>?: Characters
char-ci>?: R7RS
char-code: Character implementation
char-code-limit: Character implementation
char-comparator: SRFI 162
char-downcase: Characters
char-downcase: R7RS
char-foldcase: Characters
char-foldcase: R7RS
char-general-category: Unicode
char-graphic?: Prompting
char-hash: SRFI 128
char-in: Regular S-Expressions
char-in-set?: Character Sets
char-lower-case?: Characters
char-lower-case?: R7RS
char-not-in: Regular S-Expressions
char-numeric?: Characters
char-numeric?: R7RS
char-predicate: Character implementation
char-ready?: Input Procedures
char-ready?: R7RS
char-ready? on textual input port: Textual Input Port Operations
char-set: Character Sets
char-set: *Matcher
char-set: SRFI 14
char-set*: Character Sets
char-set->code-points: Character Sets
char-set->list: SRFI 14
char-set->sre: SRFI 115
char-set->string: SRFI 14
char-set-adjoin: SRFI 14
char-set-adjoin!: SRFI 14
char-set-any: SRFI 14
char-set-complement: SRFI 14
char-set-complement!: SRFI 14
char-set-contains?: SRFI 14
char-set-copy: SRFI 14
char-set-count: SRFI 14
char-set-cursor: SRFI 14
char-set-cursor-next: SRFI 14
char-set-delete: SRFI 14
char-set-delete!: SRFI 14
char-set-diff+intersection: SRFI 14
char-set-diff+intersection!: SRFI 14
char-set-difference: Character Sets
char-set-difference: SRFI 14
char-set-difference!: SRFI 14
char-set-every: SRFI 14
char-set-filter: SRFI 14
char-set-filter!: SRFI 14
char-set-fold: SRFI 14
char-set-for-each: SRFI 14
char-set-hash: SRFI 14
char-set-intersection: Character Sets
char-set-intersection: SRFI 14
char-set-intersection!: SRFI 14
char-set-intersection*: Character Sets
char-set-invert: Character Sets
char-set-map: SRFI 14
char-set-predicate: Character Sets
char-set-ref: SRFI 14
char-set-size: SRFI 14
char-set-unfold: SRFI 14
char-set-unfold!: SRFI 14
char-set-union: Character Sets
char-set-union: SRFI 14
char-set-union!: SRFI 14
char-set-union*: Character Sets
char-set-xor: SRFI 14
char-set-xor!: SRFI 14
char-set:alphabetic: Character Sets
char-set:alphanumeric: Character Sets
char-set:ascii: SRFI 14
char-set:blank: SRFI 14
char-set:digit: SRFI 14
char-set:empty: SRFI 14
char-set:full: SRFI 14
char-set:graphic: SRFI 14
char-set:hex-digit: SRFI 14
char-set:iso-control: SRFI 14
char-set:letter: SRFI 14
char-set:letter+digit: SRFI 14
char-set:lower-case: Character Sets
char-set:lower-case: SRFI 14
char-set:numeric: Character Sets
char-set:printing: SRFI 14
char-set:punctuation: SRFI 14
char-set:symbol: SRFI 14
char-set:title-case: SRFI 14
char-set:upper-case: Character Sets
char-set:upper-case: SRFI 14
char-set:whitespace: Character Sets
char-set:whitespace: Strings
char-set:whitespace: SRFI 14
char-set<=: SRFI 14
char-set=: SRFI 14
char-set=?: Character Sets
char-set?: Character Sets
char-set?: SRFI 14
char-title-case?: SRFI 129
char-titlecase: SRFI 129
char-upcase: Characters
char-upcase: R7RS
char-upper-case?: Characters
char-upper-case?: R7RS
char-whitespace?: Characters
char-whitespace?: Strings
char-whitespace?: R7RS
char<=?: Characters
char<=?: R7RS
char<?: Characters
char<?: R7RS
char=?: Equivalence Predicates
char=?: Equivalence Predicates
char=?: Characters
char=?: R7RS
char>=?: Characters
char>=?: R7RS
char>?: Characters
char>?: R7RS
char?: Characters
char?: R7RS
chars-remaining on textual input port: Textual Input Port Operations
circular-generator: SRFI 158
circular-list: Miscellaneous List Operations
circular-list: SRFI 1
circular-list?: Selecting List Components
circular-list?: SRFI 1
clear: Output Procedures
clear-bit: Bit operations
close-all-open-files: File Ports
close-input-port: Ports
close-input-port: R7RS
close-output-port: Ports
close-output-port: R7RS
close-port: Ports
close-port: R7RS
close-syntax: SC Transformer Definition
close-tcp-server-socket: TCP Sockets
code-point-general-category: Unicode
code-point-in-set?: Character Sets
command-line: R7RS
comparator-check-type: SRFI 128
comparator-equality-predicate: SRFI 128
comparator-hash: SRFI 128
comparator-hash-function: SRFI 128
comparator-hashable?: SRFI 128
comparator-if<=>: SRFI 128
comparator-max: SRFI 162
comparator-max-in-list: SRFI 162
comparator-min: SRFI 162
comparator-min-in-list: SRFI 162
comparator-ordered?: SRFI 128
comparator-ordering-predicate: SRFI 128
comparator-register-default!: SRFI 128
comparator-test-type: SRFI 128
comparator-type-test-predicate: SRFI 128
comparator?: SRFI 128
compile-regsexp: Regsexp Procedures
compiled-procedure?: Procedure Operations
complex?: Numerical operations
complex?: R7RS
compound: Numerical operations
compound-procedure?: Procedure Operations
compoundm1: Numerical operations
compute-char-set: Character Sets
conc-name: Structure Definitions
concatenate: SRFI 1
concatenate!: SRFI 1
cond: Entry Format
cond: Conditionals
cond: Sequencing
cond: Booleans
cond: R7RS
cond-expand: cond-expand (SRFI 0)
cond-expand: R7RS
condition-accessor: Generating Operations on Conditions
condition-accessor: Generating Operations on Conditions
condition-accessor: Simple Condition Instance Operations
condition-constructor: Generating Operations on Conditions
condition-constructor: Generating Operations on Conditions
condition-predicate: Generating Operations on Conditions
condition-predicate: Generating Operations on Conditions
condition-signaller: Generating Operations on Conditions
condition-signaller: Generating Operations on Conditions
condition-type/error?: Condition Types
condition-type/field-names: Condition Types
condition-type/generalizations: Condition Types
condition-type:arithmetic-error: Taxonomy
condition-type:bad-range-argument: Numerical operations
condition-type:bad-range-argument: Integer Conversions of Bit Strings
condition-type:bad-range-argument: Integer Conversions of Bit Strings
condition-type:bad-range-argument: Object Hashing
condition-type:bad-range-argument: Taxonomy
condition-type:breakpoint: Error System
condition-type:breakpoint: Taxonomy
condition-type:control-error: Taxonomy
condition-type:datum-out-of-range: Taxonomy
condition-type:derived-file-error: Taxonomy
condition-type:derived-port-error: Taxonomy
condition-type:divide-by-zero: Taxonomy
condition-type:error: Condition Handling
condition-type:error: Condition State
condition-type:error: Condition Types
condition-type:error: Taxonomy
condition-type:file-error: Taxonomy
condition-type:file-operation-error: Miscellaneous Pathnames
condition-type:file-operation-error: File Manipulation
condition-type:file-operation-error: File Manipulation
condition-type:file-operation-error: Taxonomy
condition-type:floating-point-overflow: Taxonomy
condition-type:floating-point-underflow: Taxonomy
condition-type:illegal-datum: Taxonomy
condition-type:inapplicable-object: Taxonomy
condition-type:macro-binding: Environment Operations
condition-type:no-such-restart: Invoking Standard Restart Code
condition-type:no-such-restart: Invoking Standard Restart Code
condition-type:no-such-restart: Taxonomy
condition-type:not-loading: Taxonomy
condition-type:port-error: Taxonomy
condition-type:primitive-procedure-error: Taxonomy
condition-type:serious-condition: Error System
condition-type:serious-condition: Taxonomy
condition-type:simple-condition: Error System
condition-type:simple-condition: Taxonomy
condition-type:simple-error: Condition Signalling
condition-type:simple-error: Taxonomy
condition-type:simple-warning: Condition Signalling
condition-type:simple-warning: Taxonomy
condition-type:subprocess-abnormal-termination: Subprocess Conditions
condition-type:subprocess-signalled: Subprocess Conditions
condition-type:subprocess-stopped: Subprocess Conditions
condition-type:system-call-error: Taxonomy
condition-type:unassigned-variable: Variable Bindings
condition-type:unassigned-variable: Environment Operations
condition-type:unassigned-variable: Taxonomy
condition-type:unbound-variable: Environment Concepts
condition-type:unbound-variable: Dynamic Binding
condition-type:unbound-variable: Taxonomy
condition-type:variable-error: Taxonomy
condition-type:warning: Error System
condition-type:warning: Taxonomy
condition-type:wrong-number-of-arguments: Lambda Expressions
condition-type:wrong-number-of-arguments: Lambda Expressions
condition-type:wrong-number-of-arguments: Arity
condition-type:wrong-number-of-arguments: Taxonomy
condition-type:wrong-type-argument: Entry Format
condition-type:wrong-type-argument: Taxonomy
condition-type:wrong-type-datum: Taxonomy
condition-type?: Condition Types
condition/continuation: Condition State
condition/error?: Condition State
condition/report-string: Simple Condition Instance Operations
condition/restarts: Generating Operations on Conditions
condition/restarts: Condition State
condition/restarts: Simple Condition Instance Operations
condition/type: Condition State
condition?: Condition State
conjugate: Numerical operations
cons: Pairs
cons: R7RS
cons: SRFI 1
cons*: Construction of Lists
cons*: SRFI 1
cons-stream: Streams
console-i/o-port: Ports
constructor: Structure Definitions
continuation?: Continuations
continue: Restarts
continue: Invoking Standard Restart Code
copier: Structure Definitions
copy-area on x-graphics-device: Custom Operations on X Graphics Devices
copy-file: File Manipulation
copysign: Numerical operations
cos: Numerical operations
cos: R7RS
cos-pi*: Numerical operations
count: SRFI 1
count-accumulator: SRFI 158
count-pairs: Selecting List Components
cpu-architecture: SRFI 112
create-image on graphics-device: Images
current-error-port: Ports
current-error-port: R7RS
current-file-time: File Manipulation
current-input-port: Ports
current-input-port: File Ports
current-input-port: R7RS
current-jiffy: R7RS
current-output-port: Ports
current-output-port: File Ports
current-output-port: R7RS
current-parser-macros: Parser-language Macros
current-second: R7RS

day-of-week/long-string: External Representation of Time
day-of-week/short-string: External Representation of Time
debug: Prompting
decoded-time->file-time: Time-Format Conversion
decoded-time->string: Time-Format Conversion
decoded-time->universal-time: Time-Format Conversion
decoded-time/date-string: External Representation of Time
decoded-time/day: Decoded Time
decoded-time/day-of-week: Decoded Time
decoded-time/daylight-savings-time?: Decoded Time
decoded-time/hour: Decoded Time
decoded-time/minute: Decoded Time
decoded-time/month: Decoded Time
decoded-time/second: Decoded Time
decoded-time/time-string: External Representation of Time
decoded-time/year: Decoded Time
decoded-time/zone: Decoded Time
default-comparator: SRFI 162
default-hash: SRFI 128
default-object?: Lambda Expressions
default-random-source: Random Number Generation
default-random-source: SRFI 27
define: Environment Concepts
define: Definitions
define: Definitions
define: Internal Definitions
define: Sequencing
define: Environment Variables
define: R7RS
define: SRFI 219
define-*matcher-expander: Parser-language Macros
define-*matcher-macro: Parser-language Macros
define-*parser-expander: Parser-language Macros
define-*parser-macro: Parser-language Macros
define-print-method: Custom Output
define-record-type: define-record-type (SRFI 9)
define-record-type: R7RS
define-record-type: SRFI 9
define-record-type: SRFI 131
define-structure: Structure Definitions
define-structure: Records
define-syntax: Syntactic Binding Constructs
define-syntax: R7RS
define-values: R7RS
del-assoc: Association Lists
del-assoc!: Association Lists
del-assq: Association Lists
del-assq!: Association Lists
del-assv: Association Lists
del-assv!: Association Lists
delay: Lexical Binding
delay: Promises
delay: R7RS
delay-force: R7RS
delete: Filtering Lists
delete: SRFI 1
delete!: Filtering Lists
delete!: Filtering Lists
delete!: SRFI 1
delete-association-procedure: Association Lists
delete-directory: File Manipulation
delete-duplicates: SRFI 1
delete-duplicates!: SRFI 1
delete-file: File Manipulation
delete-file: R7RS
delete-file-no-errors: File Manipulation
delete-member-procedure: Filtering Lists
delq: Filtering Lists
delq!: Filtering Lists
delv: Filtering Lists
delv: Filtering Lists
delv!: Filtering Lists
denominator: Numerical operations
denominator: R7RS
digit->char: Characters
digit-value: Characters
digit-value: R7RS
directory-namestring: Operations on Pathnames
directory-pathname: Operations on Pathnames
directory-pathname-as-file: Operations on Pathnames
directory-pathname?: Operations on Pathnames
directory-read: Directory Reader
discard-chars on textual input port: Textual Input Port Operations
discard-matched: *Matcher
discard-matched: *Parser
discard-parser-buffer-head!: Parser Buffers
discretionary-flush-output: Output Procedures
discretionary-flush-output on textual output port: Textual Output Port Operations
display: Output Procedures
display: Error Messages
display: R7RS
do: Environment Concepts
do: Sequencing
do: Iteration
do: R7RS
dotted-list?: Selecting List Components
dotted-list?: SRFI 1
draw-arc: Custom Operations on X Graphics Devices
draw-arc on x-graphics-device: Custom Operations on X Graphics Devices
draw-circle: Custom Operations on X Graphics Devices
draw-circle on x-graphics-device: Custom Operations on X Graphics Devices
draw-image on graphics-device: Images
draw-subimage on graphics-device: Images
drop: Selecting List Components
drop: Cutting and Pasting Lists
drop: SRFI 1
drop-right: SRFI 1
drop-right!: SRFI 1
drop-while: SRFI 1
dynamic-wind: Continuations
dynamic-wind: R7RS

eighth: Selecting List Components
eighth: SRFI 1
else: Entry Format
else: Conditionals
else: Conditionals
else: R7RS
emergency-exit: R7RS
encapsulate: *Parser
end-of-char-set?: SRFI 14
end-of-input: *Matcher
enough-namestring: Operations on Pathnames
enough-pathname: Operations on Pathnames
entity-extra: Application Hooks
entity-procedure: Application Hooks
entity?: Application Hooks
enumerate-graphics-types: Opening and Closing of Graphics Devices
environment: Subprocess Options
environment: R7RS
environment-assign!: Environment Operations
environment-assignable?: Environment Operations
environment-assigned?: Environment Operations
environment-bindings: Environment Operations
environment-bound-names: Environment Operations
environment-bound?: Environment Operations
environment-definable?: Environment Operations
environment-define: Environment Operations
environment-define-macro: Environment Operations
environment-has-parent?: Environment Operations
environment-lookup: Environment Operations
environment-lookup-macro: Environment Operations
environment-macro-names: Environment Operations
environment-parent: Environment Operations
environment-reference-type: Environment Operations
environment?: Environment Operations
eof-object: Input Procedures
eof-object: R7RS
eof-object?: Input Procedures
eof-object?: R7RS
eof? on textual input port: Textual Input Port Operations
ephemeron-broken?: Ephemerons
ephemeron-broken?: SRFI 124
ephemeron-datum: Ephemerons
ephemeron-datum: SRFI 124
ephemeron-key: Ephemerons
ephemeron-key: SRFI 124
ephemeron?: Ephemerons
ephemeron?: SRFI 124
epoch: Universal Time
eq-comparator: SRFI 162
eq-hash: Construction of Hash Tables
eq-hash: Address Hashing
eq-hash-mod: Address Hashing
eq?: Equivalence Predicates
eq?: Equivalence Predicates
eq?: Symbols
eq?: Symbols
eq?: Association Lists
eq?: Association Lists
eq?: Association Lists
eq?: The Association Table
eq?: Construction of Hash Tables
eq?: Construction of Hash Tables
eq?: Construction of Hash Tables
eq?: Construction of Hash Tables
eq?: Construction of Hash Tables
eq?: Object Hashing
eq?: The Named Restart Abstraction
eq?: R7RS
equal-comparator: SRFI 162
equal-hash: Construction of Hash Tables
equal-hash: Address Hashing
equal-hash-mod: Address Hashing
equal?: Quoting
equal?: Equivalence Predicates
equal?: Equivalence Predicates
equal?: Association Lists
equal?: Association Lists
equal?: Association Lists
equal?: Construction of Hash Tables
equal?: Construction of Hash Tables
equal?: R7RS
eqv-comparator: SRFI 162
eqv-hash: Address Hashing
eqv-hash-mod: Address Hashing
eqv?: Storage Model
eqv?: Conditionals
eqv?: Equivalence Predicates
eqv?: Equivalence Predicates
eqv?: Pairs
eqv?: Association Lists
eqv?: Association Lists
eqv?: Association Lists
eqv?: Construction of Hash Tables
eqv?: Construction of Hash Tables
eqv?: Construction of Hash Tables
eqv?: Construction of Hash Tables
eqv?: R7RS
er-macro-transformer: Explicit Renaming
error: Errors
error: Error System
error: Condition Signalling
error: Condition Signalling
error: Condition Handling
error: Condition Handling
error: R7RS
error: SRFI 23
error-irritant/noise: Error Messages
error-object-irritants: R7RS
error-object-message: R7RS
error-object?: R7RS
error:bad-range-argument: Taxonomy
error:datum-out-of-range: Taxonomy
error:derived-file: Taxonomy
error:derived-port: Taxonomy
error:divide-by-zero: Taxonomy
error:file-operation: Taxonomy
error:no-such-restart: Taxonomy
error:wrong-number-of-arguments: Taxonomy
error:wrong-type-argument: Taxonomy
error:wrong-type-datum: Taxonomy
euclidean-quotient: Numerical operations
euclidean-remainder: Numerical operations
euclidean/: Numerical operations
eval: Environment Operations
eval: R7RS
even?: Numerical operations
even?: R7RS
every: Mapping of Lists
every: SRFI 1
exact: Exactness
exact: Numerical operations
exact: R7RS
exact->inexact: Numerical operations
exact-integer-sqrt: R7RS
exact-integer?: Numerical operations
exact-integer?: R7RS
exact-nonnegative-integer?: Numerical operations
exact-rational?: Numerical operations
exact?: Numerical operations
exact?: R7RS
except-last-pair: Cutting and Pasting Lists
except-last-pair!: Cutting and Pasting Lists
exit: R7RS
exp: Numerical operations
exp: R7RS
exp10: Numerical operations
exp10m1: Numerical operations
exp2: Numerical operations
exp2m1: Numerical operations
expm1: Numerical operations
export-random-state: Random Number Generation
expt: Numerical operations
expt: R7RS
exsec: Numerical operations
exsec-pi*: Numerical operations
extend-top-level-environment: Top-level Environments
extract-bit: Bit operations

false: Booleans
false?: Booleans
features: R7RS
fifth: Selecting List Components
fifth: SRFI 1
file-access: File Manipulation
file-access-time: File Manipulation
file-access-time-direct: File Manipulation
file-access-time-indirect: File Manipulation
file-attributes: File Manipulation
file-attributes-direct: File Manipulation
file-attributes-indirect: File Manipulation
file-attributes/access-time: File Manipulation
file-attributes/change-time: File Manipulation
file-attributes/gid: File Manipulation
file-attributes/inode-number: File Manipulation
file-attributes/length: File Manipulation
file-attributes/mode-string: File Manipulation
file-attributes/modes: File Manipulation
file-attributes/modification-time: File Manipulation
file-attributes/n-links: File Manipulation
file-attributes/type: File Manipulation
file-attributes/uid: File Manipulation
file-directory?: File Manipulation
file-eq?: File Manipulation
file-error?: File Ports
file-error?: File Ports
file-error?: File Ports
file-error?: R7RS
file-executable?: File Manipulation
file-exists-direct?: File Manipulation
file-exists-indirect?: File Manipulation
file-exists?: File Manipulation
file-exists?: R7RS
file-length: File Manipulation
file-modes: File Manipulation
file-modification-time: File Manipulation
file-modification-time-direct: File Manipulation
file-modification-time-indirect: File Manipulation
file-namestring: Operations on Pathnames
file-pathname: Operations on Pathnames
file-readable?: File Manipulation
file-regular?: File Manipulation
file-symbolic-link?: File Manipulation
file-time->global-decoded-time: Time-Format Conversion
file-time->global-time-string: Time-Format Conversion
file-time->local-decoded-time: Time-Format Conversion
file-time->local-time-string: Time-Format Conversion
file-time->universal-time: Time-Format Conversion
file-touch: File Manipulation
file-type-direct: File Manipulation
file-type-indirect: File Manipulation
file-writeable?: File Manipulation
fill-circle: Custom Operations on X Graphics Devices
fill-circle on x-graphics-device: Custom Operations on X Graphics Devices
fill-with: Strings
filter: Filtering Lists
filter: SRFI 1
filter!: Filtering Lists
filter!: SRFI 1
filter-map: SRFI 1
find: Searching Lists
find: SRFI 1
find-restart: Restarts
find-restart: Finding and Invoking General Restart Code
find-restart: Finding and Invoking General Restart Code
find-tail: Searching Lists
find-tail: SRFI 1
finite?: R7RS
first: Selecting List Components
first: SRFI 1
first-set-bit: Bit operations
fix:*: Fixnum Operations
fix:+: Fixnum Operations
fix:-: Fixnum Operations
fix:-1+: Fixnum Operations
fix:1+: Fixnum Operations
fix:<: Fixnum Operations
fix:<=: Fixnum Operations
fix:=: Fixnum Operations
fix:>: Fixnum Operations
fix:>=: Fixnum Operations
fix:and: Fixnum Operations
fix:andc: Fixnum Operations
fix:divide: Fixnum Operations
fix:fixnum?: Fixnum Operations
fix:gcd: Fixnum Operations
fix:lsh: Fixnum Operations
fix:negative?: Fixnum Operations
fix:not: Fixnum Operations
fix:or: Fixnum Operations
fix:positive?: Fixnum Operations
fix:quotient: Fixnum Operations
fix:remainder: Fixnum Operations
fix:xor: Fixnum Operations
fix:zero?: Fixnum Operations
fixnum?: SRFI 143
flo:*: Flonum Operations
flo:*+: Flonum Operations
flo:*-: Flonum Operations
flo:+: Flonum Operations
flo:-: Flonum Operations
flo:/: Flonum Operations
flo:<: Flonum Operations
flo:<=: Flonum Operations
flo:<>: Flonum Operations
flo:=: Flonum Operations
flo:>: Flonum Operations
flo:>=: Flonum Operations
flo:abs: Flonum Operations
flo:acos: Flonum Operations
flo:acos/pi: Flonum Operations
flo:acosh: Flonum Operations
flo:aexsec: Flonum Operations
flo:aexsec/pi: Flonum Operations
flo:asin: Flonum Operations
flo:asin/pi: Flonum Operations
flo:asinh: Flonum Operations
flo:atan: Flonum Operations
flo:atan/pi: Flonum Operations
flo:atan2: Flonum Operations
flo:atan2/pi: Flonum Operations
flo:atanh: Flonum Operations
flo:aversin: Flonum Operations
flo:aversin/pi: Flonum Operations
flo:cbrt: Flonum Operations
flo:ceiling: Flonum Operations
flo:ceiling->exact: Flonum Operations
flo:classify: Flonum Operations
flo:clear-exceptions!: Floating-Point Exceptions
flo:compound: Flonum Operations
flo:compoundm1: Flonum Operations
flo:copysign: Flonum Operations
flo:cos: Flonum Operations
flo:cos-pi*: Flonum Operations
flo:cosh: Flonum Operations
flo:default-environment: Floating-Point Environment
flo:default-rounding-mode: Floating-Point Rounding Mode
flo:default-trapped-exceptions: Floating-Point Exceptions
flo:defer-exception-traps!: Floating-Point Exceptions
flo:deferring-exception-traps: Floating-Point Exceptions
flo:environment: Floating-Point Environment
flo:erf: Flonum Operations
flo:erfc: Flonum Operations
flo:error-bound: Flonum Operations
flo:exception:divide-by-zero: Floating-Point Exceptions
flo:exception:inexact-result: Floating-Point Exceptions
flo:exception:invalid-operation: Floating-Point Exceptions
flo:exception:overflow: Floating-Point Exceptions
flo:exception:subnormal-operand: Floating-Point Exceptions
flo:exception:underflow: Floating-Point Exceptions
flo:exceptions->names: Floating-Point Exceptions
flo:exp: Flonum Operations
flo:exp10: Flonum Operations
flo:exp10m1: Flonum Operations
flo:exp2: Flonum Operations
flo:exp2m1: Flonum Operations
flo:expm1: Flonum Operations
flo:expt: Flonum Operations
flo:exsec: Flonum Operations
flo:exsec-pi*: Flonum Operations
flo:fast-fma?: Flonum Operations
flo:finite?: Flonum Operations
flo:flonum?: Flonum Operations
flo:floor: Flonum Operations
flo:floor->exact: Flonum Operations
flo:fma: Flonum Operations
flo:gamma: Flonum Operations
flo:greatest-normal-exponent-base-10: Flonum Operations
flo:greatest-normal-exponent-base-2: Flonum Operations
flo:greatest-normal-exponent-base-e: Flonum Operations
flo:have-trap-enable/disable?: Floating-Point Exceptions
flo:hypot: Flonum Operations
flo:ignoring-exception-traps: Floating-Point Exceptions
flo:infinite?: Flonum Operations
flo:j0: Flonum Operations
flo:j1: Flonum Operations
flo:jn: Flonum Operations
flo:largest-positive-normal: Flonum Operations
flo:ldexp: Flonum Operations
flo:least-normal-exponent-base-10: Flonum Operations
flo:least-normal-exponent-base-2: Flonum Operations
flo:least-normal-exponent-base-e: Flonum Operations
flo:least-subnormal-exponent-base-10: Flonum Operations
flo:least-subnormal-exponent-base-2: Flonum Operations
flo:least-subnormal-exponent-base-e: Flonum Operations
flo:lgamma: Flonum Operations
flo:log: Flonum Operations
flo:log-error-bound: Flonum Operations
flo:log-ulp-of-one: Flonum Operations
flo:log10: Flonum Operations
flo:log10p1: Flonum Operations
flo:log1p: Flonum Operations
flo:log2: Flonum Operations
flo:log2p1: Flonum Operations
flo:logb: Flonum Operations
flo:logp1: Flonum Operations
flo:make-nan: Flonum Operations
flo:max: Flonum Operations
flo:max-mag: Flonum Operations
flo:max-mag-num: Flonum Operations
flo:max-num: Flonum Operations
flo:min: Flonum Operations
flo:min-mag: Flonum Operations
flo:min-mag-num: Flonum Operations
flo:min-num: Flonum Operations
flo:names->exceptions: Floating-Point Exceptions
flo:nan-payload: Flonum Operations
flo:nan-quiet?: Flonum Operations
flo:nan?: Flonum Operations
flo:negate: Flonum Operations
flo:negative?: Flonum Operations
flo:nextafter: Flonum Operations
flo:normal-exponent-max: Flonum Operations
flo:normal-exponent-min: Flonum Operations
flo:normal?: Flonum Operations
flo:positive?: Flonum Operations
flo:precision: Flonum Operations
flo:preserving-environment: Floating-Point Environment
flo:radix: Flonum Operations
flo:radix.: Flonum Operations
flo:raise-exceptions!: Floating-Point Exceptions
flo:random-unit: Random Number Generation
flo:random-unit-closed: Random Number Generation
flo:random-unit-open: Random Number Generation
flo:restore-exception-flags!: Floating-Point Exceptions
flo:round: Flonum Operations
flo:round->exact: Flonum Operations
flo:rounding-mode: Floating-Point Rounding Mode
flo:rounding-modes: Floating-Point Rounding Mode
flo:rsqrt: Flonum Operations
flo:safe-zero?: Flonum Operations
flo:safe<: Flonum Operations
flo:safe<=: Flonum Operations
flo:safe<>: Flonum Operations
flo:safe=: Flonum Operations
flo:safe>: Flonum Operations
flo:safe>=: Flonum Operations
flo:save-exception-flags: Floating-Point Exceptions
flo:scalbn: Flonum Operations
flo:set-environment!: Floating-Point Environment
flo:set-rounding-mode!: Floating-Point Rounding Mode
flo:set-trapped-exceptions!: Floating-Point Exceptions
flo:sign-negative?: Flonum Operations
flo:signed-lgamma: Flonum Operations
flo:sin: Flonum Operations
flo:sin-pi*: Flonum Operations
flo:sinh: Flonum Operations
flo:smallest-positive-normal: Flonum Operations
flo:smallest-positive-subnormal: Flonum Operations
flo:sqrt: Flonum Operations
flo:sqrt1pm1: Flonum Operations
flo:subnormal-exponent-min: Flonum Operations
flo:subnormal?: Flonum Operations
flo:supported-exceptions: Floating-Point Exceptions
flo:tan: Flonum Operations
flo:tan-pi*: Flonum Operations
flo:tanh: Flonum Operations
flo:test-exception-flags: Floating-Point Exceptions
flo:test-exceptions: Floating-Point Exceptions
flo:total-mag<: Flonum Operations
flo:total-order: Flonum Operations
flo:total-order-mag: Flonum Operations
flo:total<: Flonum Operations
flo:trap-exceptions!: Floating-Point Exceptions
flo:trappable-exceptions: Floating-Point Exceptions
flo:trapped-exceptions: Floating-Point Exceptions
flo:truncate: Flonum Operations
flo:truncate->exact: Flonum Operations
flo:ulp: Flonum Operations
flo:ulp-of-one: Flonum Operations
flo:unordered?: Flonum Operations
flo:untrap-exceptions!: Floating-Point Exceptions
flo:update-environment!: Floating-Point Environment
flo:versin: Flonum Operations
flo:versin-pi*: Flonum Operations
flo:with-default-environment: Floating-Point Environment
flo:with-exceptions-trapped: Floating-Point Exceptions
flo:with-exceptions-untrapped: Floating-Point Exceptions
flo:with-rounding-mode: Floating-Point Rounding Mode
flo:with-trapped-exceptions: Floating-Point Exceptions
flo:y0: Flonum Operations
flo:y1: Flonum Operations
flo:yn: Flonum Operations
flo:zero?: Flonum Operations
flonum-parser-fast?: Numerical input and output
flonum-unparser-cutoff: Numerical input and output
floor: Numerical operations
floor: R7RS
floor->exact: Numerical operations
floor-quotient: Numerical operations
floor-quotient: R7RS
floor-remainder: Numerical operations
floor-remainder: R7RS
floor/: Numerical operations
floor/: R7RS
fluid-let: Dynamic Binding
flush-output: Output Procedures
flush-output on textual output port: Textual Output Port Operations
flush-output-port: Output Procedures
flush-output-port: Output Procedures
flush-output-port: R7RS
fold: Folding of Lists
fold: SRFI 1
fold-left: Folding of Lists
fold-right: Folding of Lists
fold-right: SRFI 1
font-structure on x-graphics-device: Custom Operations on X Graphics Devices
for-each: Mapping of Lists
for-each: R7RS
for-each: SRFI 1
force: Promises
force: Streams
force: R7RS
format: Format
format-error-message: Error Messages
fourth: Selecting List Components
fourth: SRFI 1
fresh-line: Output Procedures
fresh-line on textual output port: Textual Output Port Operations
fx*: SRFI 143
fx*/carry: SRFI 143
fx+: SRFI 143
fx+/carry: SRFI 143
fx-: SRFI 143
fx-/carry: SRFI 143
fx-greatest: SRFI 143
fx-least: SRFI 143
fx-width: SRFI 143
fx<=?: SRFI 143
fx<?: SRFI 143
fx=?: SRFI 143
fx>=?: SRFI 143
fx>?: SRFI 143
fxabs: SRFI 143
fxand: SRFI 143
fxarithmetic-shift: SRFI 143
fxarithmetic-shift-left: SRFI 143
fxarithmetic-shift-right: SRFI 143
fxbit-count: SRFI 143
fxbit-field: SRFI 143
fxbit-field-reverse: SRFI 143
fxbit-field-rotate: SRFI 143
fxbit-set?: SRFI 143
fxcopy-bit: SRFI 143
fxeven?: SRFI 143
fxfirst-set-bit: SRFI 143
fxif: SRFI 143
fxior: SRFI 143
fxlength: SRFI 143
fxmax: SRFI 143
fxmin: SRFI 143
fxneg: SRFI 143
fxnegative?: SRFI 143
fxnot: SRFI 143
fxodd?: SRFI 143
fxpositive?: SRFI 143
fxquotient: SRFI 143
fxremainder: SRFI 143
fxsqrt: SRFI 143
fxsquare: SRFI 143
fxxor: SRFI 143
fxzero?: SRFI 143

gappend: SRFI 158
gc-reclaimed-object: Weak Pairs
gc-reclaimed-object?: Weak Pairs
gcd: Numerical operations
gcd: R7RS
gcombine: SRFI 158
gcons*: SRFI 158
gdelete: SRFI 158
gdelete-neighbor-dups: SRFI 158
gdrop: SRFI 158
gdrop-while: SRFI 158
ge: Initial and Current Environments
ge: REPL Environment
general-car-cdr: Pairs
generate-uninterned-symbol: Symbols
generator: SRFI 158
generator->list: SRFI 158
generator->reverse-list: SRFI 158
generator->string: SRFI 158
generator->vector: SRFI 158
generator->vector!: SRFI 158
generator-any: SRFI 158
generator-count: SRFI 158
generator-every: SRFI 158
generator-find: SRFI 158
generator-fold: SRFI 158
generator-for-each: SRFI 158
generator-map->list: SRFI 158
generator-unfold: SRFI 158
get-default on x-graphics-device: Custom Operations on X Graphics Devices
get-environment-variable: R7RS
get-environment-variables: R7RS
get-host-by-address: Miscellaneous OS Facilities
get-host-by-name: Miscellaneous OS Facilities
get-host-name: Miscellaneous OS Facilities
get-output-bytevector: Bytevector Ports
get-output-bytevector: Bytevector Ports
get-output-bytevector: R7RS
get-output-string: String Ports
get-output-string: String Ports
get-output-string: R7RS
get-parser-buffer-pointer: Parser Buffers
get-parser-buffer-tail: Parser Buffers
get-universal-time: Universal Time
gfilter: SRFI 158
gflatten: SRFI 158
ggroup: SRFI 158
gindex: SRFI 158
global-decoded-time: Decoded Time
global-parser-macros: Parser-language Macros
gmap: SRFI 158
gmerge: SRFI 158
grapheme-cluster-length: Strings
grapheme-cluster-slice: Strings
graphics-bind-drawing-mode: Characteristics of Graphics Output
graphics-bind-line-style: Characteristics of Graphics Output
graphics-clear: Drawing Graphics
graphics-clear: Custom Operations on X Graphics Devices
graphics-clear: Custom Operations on X Graphics Devices
graphics-close: Opening and Closing of Graphics Devices
graphics-coordinate-limits: Coordinates for Graphics
graphics-device-coordinate-limits: Coordinates for Graphics
graphics-disable-buffering: Buffering of Graphics Output
graphics-drag-cursor: Drawing Graphics
graphics-draw-line: Drawing Graphics
graphics-draw-point: Drawing Graphics
graphics-draw-text: Drawing Graphics
graphics-enable-buffering: Buffering of Graphics Output
graphics-erase-point: Drawing Graphics
graphics-flush: Buffering of Graphics Output
graphics-move-cursor: Drawing Graphics
graphics-operation: Custom Graphics Operations
graphics-reset-clip-rectangle: Clipping of Graphics Output
graphics-set-clip-rectangle: Clipping of Graphics Output
graphics-set-coordinate-limits: Coordinates for Graphics
graphics-set-drawing-mode: Characteristics of Graphics Output
graphics-set-line-style: Characteristics of Graphics Output
graphics-type-available?: Opening and Closing of Graphics Devices
gremove: SRFI 158
group: Regular S-Expressions
group-ref: Regular S-Expressions
gselect: SRFI 158
gstate-filter: SRFI 158
gtake: SRFI 158
gtake-while: SRFI 158
guarantee-procedure-of-arity: Arity
guard: R7RS

hamming-distance: Bit operations
hard-link-file: File Manipulation
hash: Address Hashing
hash: Object Hashing
hash: SRFI 69
hash: SRFI 125
hash-bound: SRFI 128
hash-by-eqv: Address Hashing
hash-by-identity: Address Hashing
hash-by-identity: SRFI 69
hash-by-identity: SRFI 125
hash-object: Object Hashing
hash-salt: SRFI 128
hash-table: SRFI 125
hash-table->alist: Basic Hash Table Operations
hash-table->alist: SRFI 69
hash-table->alist: SRFI 125
hash-table-clean!: Basic Hash Table Operations
hash-table-clear!: Basic Hash Table Operations
hash-table-clear!: SRFI 125
hash-table-constructor: Construction of Hash Tables
hash-table-constructor: Construction of Hash Tables
hash-table-contains?: SRFI 125
hash-table-copy: SRFI 69
hash-table-copy: SRFI 125
hash-table-count: SRFI 125
hash-table-delete!: Basic Hash Table Operations
hash-table-delete!: SRFI 69
hash-table-delete!: SRFI 125
hash-table-difference!: SRFI 125
hash-table-empty-copy: SRFI 125
hash-table-empty?: SRFI 125
hash-table-entries: SRFI 125
hash-table-entry-type:datum-ephemeral: Construction of Hash Tables
hash-table-entry-type:datum-weak: Construction of Hash Tables
hash-table-entry-type:key&datum-ephemeral: Construction of Hash Tables
hash-table-entry-type:key&datum-weak: Construction of Hash Tables
hash-table-entry-type:key-ephemeral: Construction of Hash Tables
hash-table-entry-type:key-weak: Construction of Hash Tables
hash-table-entry-type:key/datum-weak: Construction of Hash Tables
hash-table-entry-type:strong: Construction of Hash Tables
hash-table-equivalence-function: SRFI 69
hash-table-equivalence-function: SRFI 125
hash-table-exists?: SRFI 69
hash-table-exists?: SRFI 125
hash-table-find: SRFI 125
hash-table-fold: SRFI 69
hash-table-fold: SRFI 125
hash-table-for-each: SRFI 125
hash-table-grow-size: Resizing of Hash Tables
hash-table-hash-function: SRFI 69
hash-table-hash-function: SRFI 125
hash-table-intern!: Basic Hash Table Operations
hash-table-intern!: SRFI 125
hash-table-intersection!: SRFI 125
hash-table-keys: Basic Hash Table Operations
hash-table-keys: SRFI 69
hash-table-keys: SRFI 125
hash-table-map: SRFI 125
hash-table-map!: SRFI 125
hash-table-map->list: SRFI 125
hash-table-merge!: SRFI 69
hash-table-merge!: SRFI 125
hash-table-mutable?: SRFI 125
hash-table-pop!: SRFI 125
hash-table-prune!: SRFI 125
hash-table-ref: Basic Hash Table Operations
hash-table-ref: SRFI 69
hash-table-ref: SRFI 125
hash-table-ref/default: Basic Hash Table Operations
hash-table-ref/default: SRFI 69
hash-table-ref/default: SRFI 125
hash-table-rehash-size: Resizing of Hash Tables
hash-table-rehash-threshold: Resizing of Hash Tables
hash-table-set!: Basic Hash Table Operations
hash-table-set!: SRFI 69
hash-table-set!: SRFI 125
hash-table-shrink-size: Resizing of Hash Tables
hash-table-size: Basic Hash Table Operations
hash-table-size: SRFI 69
hash-table-size: SRFI 125
hash-table-unfold: SRFI 125
hash-table-union!: SRFI 125
hash-table-update!: Basic Hash Table Operations
hash-table-update!: SRFI 69
hash-table-update!: SRFI 125
hash-table-update!/default: Basic Hash Table Operations
hash-table-update!/default: SRFI 69
hash-table-update!/default: SRFI 125
hash-table-values: Basic Hash Table Operations
hash-table-values: SRFI 69
hash-table-values: SRFI 125
hash-table-walk: Basic Hash Table Operations
hash-table-walk: SRFI 69
hash-table-walk: SRFI 125
hash-table-xor!: SRFI 125
hash-table/clean!: Basic Hash Table Operations
hash-table/clear!: Basic Hash Table Operations
hash-table/constructor: Construction of Hash Tables
hash-table/count: Basic Hash Table Operations
hash-table/datum-list: Basic Hash Table Operations
hash-table/for-each: Basic Hash Table Operations
hash-table/get: Basic Hash Table Operations
hash-table/intern!: Basic Hash Table Operations
hash-table/key-list: Basic Hash Table Operations
hash-table/lookup: Basic Hash Table Operations
hash-table/make: Object Hashing
hash-table/modify!: Basic Hash Table Operations
hash-table/put!: Basic Hash Table Operations
hash-table/rehash-size: Resizing of Hash Tables
hash-table/rehash-threshold: Resizing of Hash Tables
hash-table/remove!: Basic Hash Table Operations
hash-table/size: Resizing of Hash Tables
hash-table=?: SRFI 125
hash-table?: Basic Hash Table Operations
hash-table?: SRFI 69
hash-table?: SRFI 125
host-address-any: Miscellaneous OS Facilities
host-address-loopback: Miscellaneous OS Facilities
host-namestring: Operations on Pathnames
host=?: Miscellaneous Pathnames
host?: Miscellaneous Pathnames

i/o-port-type?: Textual Port Types
i/o-port?: Ports
identifier=?: SC Identifiers
identifier?: SC Identifiers
if: Conditionals
if: Booleans
if: R7RS
ignore-error: Condition Handling
ignore-errors: Condition Handling
imag-part: Numerical operations
imag-part: R7RS
image/destroy: Images
image/fill-from-byte-vector: Images
image/height: Images
image/width: Images
image?: Images
implementation-name: SRFI 112
implementation-version: SRFI 112
implemented-primitive-procedure?: Primitive Procedures
import-random-state: Random Number Generation
include: R7RS
include-ci: R7RS
inexact: Numerical operations
inexact: R7RS
inexact->exact: Numerical operations
inexact?: Numerical operations
inexact?: R7RS
infinite?: R7RS
init-file-pathname: Miscellaneous Pathnames
initial-offset: Structure Definitions
input: Subprocess Options
input-buffer-size: Subprocess Options
input-buffer-size on textual input port: Textual Input Port Operations
input-line-translation: Subprocess Options
input-port->parser-buffer: Parser Buffers
input-port-blocking-mode: Blocking Mode
input-port-open?: Ports
input-port-open?: R7RS
input-port-terminal-mode: Terminal Mode
input-port-type?: Textual Port Types
input-port/char-ready?: Textual Input Port Operations
input-port/discard-chars: Textual Input Port Operations
input-port/peek-char: Textual Input Port Operations
input-port/read-char: Textual Input Port Operations
input-port/read-string: Textual Input Port Operations
input-port/read-substring: Textual Input Port Operations
input-port?: Ports
input-port?: R7RS
integer->char: Characters
integer->char: R7RS
integer-ceiling: Numerical operations
integer-divide: Numerical operations
integer-divide: Fixnum Operations
integer-divide-quotient: Numerical operations
integer-divide-quotient: Fixnum Operations
integer-divide-remainder: Numerical operations
integer-divide-remainder: Fixnum Operations
integer-floor: Numerical operations
integer-length: Bit operations
integer-round: Numerical operations
integer-truncate: Numerical operations
integer?: Numerical operations
integer?: R7RS
interaction-environment: R7RS
interaction-i/o-port: Ports
interaction-i/o-port: Prompting
intern: Symbols
intern-soft: Symbols
internal-time/seconds->ticks: Machine Time
internal-time/ticks->seconds: Machine Time
interpreter-environment?: Top-level Environments
invoke-restart: Restarts
invoke-restart: Establishing Restart Code
invoke-restart: Finding and Invoking General Restart Code
invoke-restart: Finding and Invoking General Restart Code
invoke-restart: The Named Restart Abstraction
invoke-restart-interactively: Restarts
invoke-restart-interactively: Finding and Invoking General Restart Code
invoke-restart-interactively: Finding and Invoking General Restart Code
invoke-restart-interactively: Finding and Invoking General Restart Code
invoke-restart-interactively: The Named Restart Abstraction
invoke-restart-interactively: The Named Restart Abstraction
iota: Construction of Lists
iota: SRFI 1
istring?: SRFI 140

jiffies-per-second: R7RS

keyword-constructor: Structure Definitions

lambda: Entry Format
lambda: Static Scoping
lambda: Additional Notations
lambda: Procedure Call Syntax
lambda: Lambda Expressions
lambda: Lexical Binding
lambda: Definitions
lambda: Internal Definitions
lambda: Sequencing
lambda: Procedures
lambda: R7RS
last: Cutting and Pasting Lists
last: SRFI 1
last-pair: Cutting and Pasting Lists
last-pair: SRFI 1
lcm: Numerical operations
lcm: R7RS
leading: Strings
leading: Strings
length: Implementation restrictions
length: Selecting List Components
length: R7RS
length: SRFI 1
length+: Selecting List Components
length+: SRFI 1
let: Environment Concepts
let: Lexical Binding
let: Dynamic Binding
let: Definitions
let: Internal Definitions
let: Sequencing
let: Iteration
let: R7RS
let*: Environment Concepts
let*: Lexical Binding
let*: Definitions
let*: Internal Definitions
let*: Sequencing
let*: R7RS
let*-syntax: Syntactic Binding Constructs
let*-values: Lexical Binding
let*-values: Definitions
let*-values: Internal Definitions
let*-values: Sequencing
let*-values: R7RS
let-syntax: Syntactic Binding Constructs
let-syntax: R7RS
let-values: Lexical Binding
let-values: Definitions
let-values: Internal Definitions
let-values: Sequencing
let-values: R7RS
letrec: Environment Concepts
letrec: Lexical Binding
letrec: Definitions
letrec: Internal Definitions
letrec: Internal Definitions
letrec: Sequencing
letrec: R7RS
letrec*: Lexical Binding
letrec*: Definitions
letrec*: Internal Definitions
letrec*: Sequencing
letrec*: R7RS
letrec-syntax: Syntactic Binding Constructs
letrec-syntax: R7RS
line-end: Regular S-Expressions
line-start: Regular S-Expressions
link-variables: Top-level Environments
list: Entry Format
list: Construction of Lists
list: Construction of Lists
list: Miscellaneous List Operations
list: Construction of Vectors
list: String Ports
list: R7RS
list: SRFI 1
list->char-set: SRFI 14
list->char-set!: SRFI 14
list->generator: SRFI 158
list->stream: Streams
list->string: Strings
list->string: R7RS
list->string: SRFI 140
list->vector: Construction of Lists
list->vector: Construction of Vectors
list->vector: R7RS
list-accumulator: SRFI 158
list-comparator: SRFI 162
list-copy: Construction of Lists
list-copy: Association Lists
list-copy: R7RS
list-copy: SRFI 1
list-deletor: Filtering Lists
list-deletor: Filtering Lists
list-deletor: Association Lists
list-deletor!: Filtering Lists
list-deletor!: Filtering Lists
list-deletor!: Association Lists
list-head: Cutting and Pasting Lists
list-index: SRFI 1
list-ref: Selecting List Components
list-ref: R7RS
list-ref: SRFI 1
list-set!: R7RS
list-tabulate: Construction of Lists
list-tabulate: SRFI 1
list-tail: Cutting and Pasting Lists
list-tail: R7RS
list=: SRFI 1
list?: Selecting List Components
list?: Association Lists
list?: 1D Tables
list?: R7RS
load: R7RS
load-option: Format
load-option: Parser Language
load-option: XML Support
local-decoded-time: Decoded Time
local-host: Miscellaneous Pathnames
log: Numerical operations
log: R7RS
log-logistic: Numerical operations
log10: Numerical operations
log10p1: Numerical operations
log1mexp: Numerical operations
log1p: Numerical operations
log1pexp: Numerical operations
log2: Numerical operations
log2p1: Numerical operations
logistic: Numerical operations
logistic-1/2: Numerical operations
logit: Numerical operations
logit-exp: Numerical operations
logit1/2+: Numerical operations
logp1: Numerical operations
logsumexp: Numerical operations
lset-adjoin: SRFI 1
lset-diff+intersection: SRFI 1
lset-diff+intersection!: SRFI 1
lset-difference: SRFI 1
lset-difference!: SRFI 1
lset-intersection: SRFI 1
lset-intersection!: SRFI 1
lset-union: SRFI 1
lset-union!: SRFI 1
lset-xor: SRFI 1
lset-xor!: SRFI 1
lset<=: SRFI 1
lset=: SRFI 1

machine-name: SRFI 112
magnitude: Numerical operations
magnitude: R7RS
make-1d-table: 1D Tables
make-accumulator: SRFI 158
make-amap: Amap constructors
make-apply-hook: Application Hooks
make-bit-string: Construction of Bit Strings
make-bytevector: R7RS
make-cell: Parameters
make-char: Character implementation
make-circular-list: Miscellaneous List Operations
make-comparator: SRFI 128
make-condition: Condition Signalling
make-condition: Condition Signalling
make-condition: Simple Condition Instance Operations
make-condition-type: Condition Types
make-coroutine-generator: SRFI 158
make-datum-weak-eq-hash-table: Construction of Hash Tables
make-datum-weak-eqv-hash-table: Construction of Hash Tables
make-decoded-time: Decoded Time
make-default-comparator: SRFI 128
make-directory: File Manipulation
make-entity: Application Hooks
make-ephemeron: Ephemerons
make-ephemeron: SRFI 124
make-eq-comparator: SRFI 128
make-eq-hash-table: Construction of Hash Tables
make-equal-comparator: SRFI 128
make-equal-hash-table: Construction of Hash Tables
make-eqv-comparator: SRFI 128
make-eqv-hash-table: Construction of Hash Tables
make-for-each-generator: SRFI 158
make-graphics-device: Opening and Closing of Graphics Devices
make-hash-table: Construction of Hash Tables
make-hash-table: Construction of Hash Tables
make-hash-table: SRFI 69
make-hash-table: SRFI 125
make-hash-table*: Construction of Hash Tables
make-hash-table-type: Construction of Hash Tables
make-hash-table-type*: Construction of Hash Tables
make-initialized-list: Construction of Lists
make-initialized-vector: Construction of Vectors
make-iota-generator: SRFI 158
make-key-ephemeral-eq-hash-table: Construction of Hash Tables
make-key-ephemeral-eqv-hash-table: Construction of Hash Tables
make-key-weak-eq-hash-table: Construction of Hash Tables
make-key-weak-eqv-hash-table: Construction of Hash Tables
make-list: Construction of Lists
make-list: R7RS
make-list: SRFI 1
make-list-comparator: SRFI 128
make-object-hash-table: Construction of Hash Tables
make-object-hasher: Object Hashing
make-pair-comparator: SRFI 128
make-parameter: Parameters
make-parameter: R7RS
make-parameter: SRFI 39
make-parser-macros: Parser-language Macros
make-pathname: Components of Pathnames
make-polar: Numerical operations
make-polar: R7RS
make-port: Constructors and Accessors for Textual Ports
make-port-type: Textual Port Types
make-primitive-procedure: Primitive Procedures
make-procedure-arity: Arity
make-promise: R7RS
make-random-source: Random Number Generation
make-random-source: SRFI 27
make-random-state: Random Number Generation
make-range-generator: SRFI 158
make-rb-tree: Red-Black Trees
make-record-type: Records
make-rectangular: Numerical operations
make-rectangular: Numerical operations
make-rectangular: R7RS
make-root-top-level-environment: Top-level Environments
make-settable-parameter: Parameters
make-string: Strings
make-string: R7RS
make-string-hash-table: Construction of Hash Tables
make-strong-eq-hash-table: Construction of Hash Tables
make-strong-eqv-hash-table: Construction of Hash Tables
make-symbol-hash-table: Construction of Hash Tables
make-syntactic-closure: SC Transformer Definition
make-synthetic-identifier: SC Identifiers
make-textual-port: Constructors and Accessors for Textual Ports
make-textual-port-type: Textual Port Types
make-top-level-environment: Top-level Environments
make-unfold-generator: SRFI 158
make-unsettable-parameter: Parameters
make-vector: Construction of Vectors
make-vector: R7RS
make-vector-comparator: SRFI 128
make-weak-eq-hash-table: Construction of Hash Tables
make-weak-eqv-hash-table: Construction of Hash Tables
make-wt-tree: Construction of Weight-Balanced Trees
make-wt-tree-type: Construction of Weight-Balanced Trees
make-xml-!attlist: XML Structure
make-xml-!element: XML Structure
make-xml-!entity: XML Structure
make-xml-!notation: XML Structure
make-xml-declaration: XML Structure
make-xml-document: XML Structure
make-xml-dtd: XML Structure
make-xml-element: XML Structure
make-xml-external-id: XML Structure
make-xml-name: XML Names
make-xml-nmtoken: XML Names
make-xml-parameter-!entity: XML Structure
make-xml-processing-instructions: XML Structure
make-xml-qname: XML Names
make-xml-unparsed-!entity: XML Structure
map: Mapping of Lists
map: *Parser
map: R7RS
map: SRFI 1
map!: SRFI 1
map*: Mapping of Lists
map-in-order: SRFI 1
map-window on x-graphics-device: Custom Operations on X Graphics Devices
match: *Parser
match-parser-buffer-char: Parser Buffers
match-parser-buffer-char-ci: Parser Buffers
match-parser-buffer-char-ci-no-advance: Parser Buffers
match-parser-buffer-char-in-set: Parser Buffers
match-parser-buffer-char-in-set-no-advance: Parser Buffers
match-parser-buffer-char-no-advance: Parser Buffers
match-parser-buffer-not-char: Parser Buffers
match-parser-buffer-not-char-ci: Parser Buffers
match-parser-buffer-not-char-ci-no-advance: Parser Buffers
match-parser-buffer-not-char-no-advance: Parser Buffers
match-parser-buffer-string: Parser Buffers
match-parser-buffer-string-ci: Parser Buffers
match-parser-buffer-string-ci-no-advance: Parser Buffers
match-parser-buffer-string-no-advance: Parser Buffers
match-parser-buffer-substring: Parser Buffers
match-parser-buffer-substring-ci: Parser Buffers
match-parser-buffer-substring-ci-no-advance: Parser Buffers
match-parser-buffer-substring-no-advance: Parser Buffers
max: Numerical operations
max: R7RS
measure-interval: Machine Time
member: Searching Lists
member: R7RS
member: SRFI 1
member-procedure: Searching Lists
memq: Searching Lists
memq: R7RS
memq: SRFI 1
memv: Searching Lists
memv: R7RS
memv: SRFI 1
merge-pathnames: File Ports
merge-pathnames: Operations on Pathnames
merge-sort: Miscellaneous List Operations
merge-sort!: Modifying Vectors
microcode-id/operating-system: Miscellaneous OS Facilities
microcode-id/operating-system-name: Miscellaneous OS Facilities
microcode-id/operating-system-variant: Miscellaneous OS Facilities
min: Numerical operations
min: R7RS
modexp: Numerical operations
modulo: Numerical operations
modulo: R7RS
month/long-string: External Representation of Time
month/max-days: Decoded Time
month/short-string: External Representation of Time
move-window on x-graphics-device: Custom Operations on X Graphics Devices
muffle-warning: Condition Signalling
muffle-warning: Condition Handling
muffle-warning: Restarts
muffle-warning: Invoking Standard Restart Code

name->char: Characters
named: Structure Definitions
named-lambda: Lambda Expressions
named-lambda: Definitions
named-lambda: Sequencing
NaN (not a number): Flonum Operations
nan?: R7RS
nearest-repl/environment: REPL Environment
negative?: Numerical operations
negative?: R7RS
newline: Output Procedures
newline: R7RS
nil: Booleans
ninth: Selecting List Components
ninth: SRFI 1
noise: *Parser
not: Booleans
not: R7RS
not-char: *Matcher
not-char-ci: *Matcher
not-pair?: SRFI 1
notification-output-port: Ports
notification-output-port: Condition Handling
nt-file-mode/archive: File Manipulation
nt-file-mode/compressed: File Manipulation
nt-file-mode/directory: File Manipulation
nt-file-mode/hidden: File Manipulation
nt-file-mode/normal: File Manipulation
nt-file-mode/read-only: File Manipulation
nt-file-mode/system: File Manipulation
nt-file-mode/temporary: File Manipulation
null-list?: Selecting List Components
null-list?: SRFI 1
null-xml-name-prefix: XML Names
null-xml-name-prefix?: XML Names
null-xml-namespace-uri: XML Names
null-xml-namespace-uri?: XML Names
null?: Selecting List Components
null?: Selecting List Components
null?: Streams
null?: R7RS
null?: SRFI 1
number->string: Numerical input and output
number->string: R7RS
number-hash: SRFI 128
number-wt-type: Construction of Weight-Balanced Trees
number?: Numerical operations
number?: R7RS
numerator: Numerical operations
numerator: R7RS

object-hash: Object Hashing
object-hashed?: Object Hashing
object-unhash: Object Hashing
odd?: Numerical operations
odd?: R7RS
open-binary-i/o-file: File Ports
open-binary-input-file: File Ports
open-binary-input-file: File Ports
open-binary-input-file: R7RS
open-binary-output-file: File Ports
open-binary-output-file: File Ports
open-binary-output-file: R7RS
open-i/o-file: File Ports
open-input-bytevector: Bytevector Ports
open-input-bytevector: R7RS
open-input-file: File Ports
open-input-file: File Ports
open-input-file: R7RS
open-input-string: String Ports
open-input-string: R7RS
open-output-bytevector: Bytevector Ports
open-output-bytevector: Bytevector Ports
open-output-bytevector: R7RS
open-output-file: File Ports
open-output-file: File Ports
open-output-file: R7RS
open-output-string: String Ports
open-output-string: String Ports
open-output-string: String Ports
open-output-string: R7RS
open-tcp-server-socket: TCP Sockets
open-tcp-stream-socket: TCP Sockets
or: Conditionals
or: Booleans
or: R7RS
os-name: SRFI 112
os-version: SRFI 112
os/hostname: Miscellaneous OS Facilities
output: Subprocess Options
output-buffer-size: Subprocess Options
output-buffer-size on textual output port: Textual Output Port Operations
output-line-translation: Subprocess Options
output-port-blocking-mode: Blocking Mode
output-port-open?: Ports
output-port-open?: R7RS
output-port-terminal-mode: Terminal Mode
output-port-type?: Textual Port Types
output-port/discretionary-flush-output: Textual Output Port Operations
output-port/flush-output: Textual Output Port Operations
output-port/fresh-line: Textual Output Port Operations
output-port/write-char: Textual Output Port Operations
output-port/write-string: Textual Output Port Operations
output-port/write-substring: Textual Output Port Operations
output-port/x-size: Textual Output Port Operations
output-port/y-size: Textual Output Port Operations
output-port?: Ports
output-port?: R7RS

pair-comparator: SRFI 162
pair-fold: SRFI 1
pair-fold-right: SRFI 1
pair-for-each: SRFI 1
pair?: Pairs
pair?: Selecting List Components
pair?: Weak Pairs
pair?: R7RS
pair?: SRFI 1
param:default-pathname-defaults: Operations on Pathnames
param:flonum-printer-cutoff: Numerical input and output
param:print-with-maximum-readability?: Output Procedures
param:printer-list-breadth-limit: Output Procedures
param:printer-list-depth-limit: Output Procedures
param:printer-radix: Output Procedures
param:printer-string-length-limit: Output Procedures
param:reader-fold-case?: Input Procedures
param:reader-radix: Input Procedures
parameterize: Dynamic Binding
parameterize: Definitions
parameterize: Internal Definitions
parameterize: Sequencing
parameterize: Ports
parameterize: File Ports
parameterize: File Ports
parameterize: Output Procedures
parameterize: R7RS
parameterize: SRFI 39
parameterize*: Parameters
parse-namestring: Filenames and Pathnames
parser-buffer-pointer-index: Parser Buffers
parser-buffer-pointer-line: Parser Buffers
parser-buffer-pointer?: Parser Buffers
parser-buffer-position-string: Parser Buffers
parser-buffer-ref: Parser Buffers
parser-buffer?: Parser Buffers
parser-macros?: Parser-language Macros
partition: Filtering Lists
partition: SRFI 1
partition!: Filtering Lists
partition!: SRFI 1
pathname-absolute?: Operations on Pathnames
pathname-as-directory: Operations on Pathnames
pathname-as-directory: Working Directory
pathname-default: Operations on Pathnames
pathname-default-device: Components of Pathnames
pathname-default-directory: Components of Pathnames
pathname-default-name: Components of Pathnames
pathname-default-type: Components of Pathnames
pathname-default-version: Components of Pathnames
pathname-device: Components of Pathnames
pathname-directory: Components of Pathnames
pathname-host: Components of Pathnames
pathname-name: Components of Pathnames
pathname-new-device: Components of Pathnames
pathname-new-directory: Components of Pathnames
pathname-new-name: Components of Pathnames
pathname-new-type: Components of Pathnames
pathname-new-version: Components of Pathnames
pathname-simplify: Filenames and Pathnames
pathname-type: Components of Pathnames
pathname-version: Components of Pathnames
pathname-wild?: Operations on Pathnames
pathname=?: Operations on Pathnames
pathname?: Operations on Pathnames
peek-char: Input Procedures
peek-char: R7RS
peek-char on textual input port: Textual Input Port Operations
peek-parser-buffer-char: Parser Buffers
peek-u8: Input Procedures
peek-u8: R7RS
port-type/operation: Textual Port Types
port-type/operation-names: Textual Port Types
port-type/operations: Textual Port Types
port-type?: Textual Port Types
port/input-blocking-mode: Blocking Mode
port/input-terminal-mode: Terminal Mode
port/operation: Constructors and Accessors for Textual Ports
port/operation-names: Constructors and Accessors for Textual Ports
port/output-blocking-mode: Blocking Mode
port/output-terminal-mode: Terminal Mode
port/set-input-blocking-mode: Blocking Mode
port/set-input-terminal-mode: Terminal Mode
port/set-output-blocking-mode: Blocking Mode
port/set-output-terminal-mode: Terminal Mode
port/state: Constructors and Accessors for Textual Ports
port/type: Constructors and Accessors for Textual Ports
port/with-input-blocking-mode: Blocking Mode
port/with-input-terminal-mode: Terminal Mode
port/with-output-blocking-mode: Blocking Mode
port/with-output-terminal-mode: Terminal Mode
port?: Ports
port?: R7RS
positive?: Numerical operations
positive?: R7RS
pp: Output Procedures
predicate: Structure Definitions
primitive-procedure-name: Primitive Procedures
primitive-procedure?: Procedure Operations
print-procedure: Structure Definitions
procedure: Booleans
procedure-arity: Arity
procedure-arity-max: Arity
procedure-arity-min: Arity
procedure-arity-valid?: Arity
procedure-arity?: Arity
procedure-environment: Procedure Operations
procedure-of-arity?: Arity
procedure?: Procedure Operations
procedure?: R7RS
process-time-clock: Machine Time
product-accumulator: SRFI 158
promise-forced?: Promises
promise-value: Promises
promise?: Promises
promise?: R7RS
prompt-for-command-char: Prompting
prompt-for-command-expression: Prompting
prompt-for-confirmation: Prompting
prompt-for-evaluated-expression: Prompting
prompt-for-expression: Prompting
proper-list?: Selecting List Components
proper-list?: SRFI 1
pwd: Working Directory

quasiquote: Quoting
quasiquote: Lists
quasiquote: R7RS
quick-sort: Miscellaneous List Operations
quick-sort!: Modifying Vectors
quote: Quoting
quote: Lists
quote: R7RS
quotient: Numerical operations
quotient: R7RS

raise: R7RS
raise-continuable: R7RS
random: Random Number Generation
random-bytevector: Random Number Generation
random-bytevector!: Random Number Generation
random-integer: Random Number Generation
random-integer: SRFI 27
random-real: Random Number Generation
random-real: SRFI 27
random-source-make-integers: Random Number Generation
random-source-make-integers: SRFI 27
random-source-make-reals: Random Number Generation
random-source-make-reals: SRFI 27
random-source-make-reals: SRFI 27
random-source-pseudo-randomize!: Random Number Generation
random-source-pseudo-randomize!: SRFI 27
random-source-randomize!: Random Number Generation
random-source-randomize!: SRFI 27
random-source-state-ref: Random Number Generation
random-source-state-ref: SRFI 27
random-source-state-set!: Random Number Generation
random-source-state-set!: SRFI 27
random-source?: Random Number Generation
random-source?: SRFI 27
random-state?: Random Number Generation
rational?: Numerical operations
rational?: R7RS
rationalize: Numerical operations
rationalize: R7RS
rationalize->exact: Numerical operations
rb-tree->alist: Red-Black Trees
rb-tree/copy: Red-Black Trees
rb-tree/datum-list: Red-Black Trees
rb-tree/delete!: Red-Black Trees
rb-tree/delete-max!: Red-Black Trees
rb-tree/delete-max-datum!: Red-Black Trees
rb-tree/delete-max-pair!: Red-Black Trees
rb-tree/delete-min!: Red-Black Trees
rb-tree/delete-min-datum!: Red-Black Trees
rb-tree/delete-min-pair!: Red-Black Trees
rb-tree/empty?: Red-Black Trees
rb-tree/equal?: Red-Black Trees
rb-tree/height: Red-Black Trees
rb-tree/insert!: Red-Black Trees
rb-tree/intern!: Red-Black Trees
rb-tree/key-list: Red-Black Trees
rb-tree/lookup: Red-Black Trees
rb-tree/max: Red-Black Trees
rb-tree/max-datum: Red-Black Trees
rb-tree/max-pair: Red-Black Trees
rb-tree/min: Red-Black Trees
rb-tree/min-datum: Red-Black Trees
rb-tree/min-pair: Red-Black Trees
rb-tree/ref: Red-Black Trees
rb-tree/size: Red-Black Trees
rb-tree/update!: Red-Black Trees
rb-tree?: Red-Black Trees
read: Overview
read: External Representations
read: Lists
read: Symbols
read: Symbols
read: Symbols
read: Ports
read: Input Procedures
read: R7RS
read-bytevector: Input Procedures
read-bytevector: R7RS
read-bytevector!: Input Procedures
read-bytevector!: R7RS
read-char: Ports
read-char: Input Procedures
read-char: Input Procedures
read-char: Input Procedures
read-char: R7RS
read-char on textual input port: Textual Input Port Operations
read-char-no-hang: Input Procedures
read-delimited-string: Input Procedures
read-error?: R7RS
read-line: Input Procedures
read-line: R7RS
read-only: Structure Definitions
read-parser-buffer-char: Parser Buffers
read-string: Input Procedures
read-string: R7RS
read-string on textual input port: Textual Input Port Operations
read-string!: Input Procedures
read-substring on textual input port: Textual Input Port Operations
read-substring!: Input Procedures
read-u8: Ports
read-u8: Input Procedures
read-u8: R7RS
read-xml: XML Input
read-xml-file: XML Input
real-comparator: SRFI 162
real-part: Numerical operations
real-part: R7RS
real-time-clock: Machine Time
real?: Numerical operations
real?: R7RS
receive: receive (SRFI 8)
receive: SRFI 8
record-accessor: Records
record-constructor: Records
record-keyword-constructor: Records
record-modifier: Records
record-predicate: Records
record-type-descriptor: Records
record-type-field-names: Records
record-type-name: Records
record-type?: Records
record?: Records
redisplay-hook: Subprocess Options
reduce: Folding of Lists
reduce: SRFI 1
reduce-left: Folding of Lists
reduce-right: Folding of Lists
reduce-right: SRFI 1
reference-barrier: Reference barriers
reference-barrier: SRFI 124
regexp: SRFI 115
regexp-extract: SRFI 115
regexp-fold: SRFI 115
regexp-match->list: SRFI 115
regexp-match-count: SRFI 115
regexp-match-submatch: SRFI 115
regexp-match-submatch-end: SRFI 115
regexp-match-submatch-start: SRFI 115
regexp-match?: SRFI 115
regexp-matches: SRFI 115
regexp-matches?: SRFI 115
regexp-partition: SRFI 115
regexp-replace: SRFI 115
regexp-replace-all: SRFI 115
regexp-search: SRFI 115
regexp-split: SRFI 115
regexp?: SRFI 115
regsexp-match-string: Regsexp Procedures
regsexp-search-string-forward: Regsexp Procedures
remainder: Numerical operations
remainder: R7RS
remove: Filtering Lists
remove: SRFI 1
remove!: Filtering Lists
remove!: SRFI 1
rename-file: File Manipulation
resize-window on x-graphics-device: Custom Operations on X Graphics Devices
restart/effector: The Named Restart Abstraction
restart/interactor: Finding and Invoking General Restart Code
restart/interactor: The Named Restart Abstraction
restart/name: The Named Restart Abstraction
restart?: The Named Restart Abstraction
retry: Restarts
retry: Invoking Standard Restart Code
retry: Invoking Standard Restart Code
reverse: Miscellaneous List Operations
reverse: R7RS
reverse: SRFI 1
reverse!: Miscellaneous List Operations
reverse!: SRFI 1
reverse-list->string: SRFI 140
reverse-list->vector: SRFI 133
reverse-list-accumulator: SRFI 158
reverse-vector->generator: SRFI 158
reverse-vector->list: SRFI 133
reverse-vector-accumulator: SRFI 158
round: Numerical operations
round: R7RS
round->exact: Numerical operations
round-quotient: Numerical operations
round-remainder: Numerical operations
round/: Numerical operations
rsc-macro-transformer: SC Transformer Definition
rsqrt: Numerical operations
run-shell-command: Subprocess Procedures
run-synchronous-subprocess: Subprocess Procedures
runtime: Machine Time
rx: SRFI 115

safe-accessors: Structure Definitions
sc-macro-transformer: SC Transformer Definition
scheme-subprocess-environment: Subprocess Options
second: Selecting List Components
second: SRFI 1
seq: Regular S-Expressions
seq: *Matcher
seq: *Parser
set!: Top-Level Definitions
set!: Assignments
set!: R7RS
set-apply-hook-extra!: Application Hooks
set-apply-hook-procedure!: Application Hooks
set-background-color on x-graphics-device: Custom Operations on X Graphics Devices
set-bit: Bit operations
set-border-color on x-graphics-device: Custom Operations on X Graphics Devices
set-border-width on x-graphics-device: Custom Operations on X Graphics Devices
set-car!: Pairs
set-car!: R7RS
set-car!: SRFI 1
set-cdr!: Lists
set-cdr!: Pairs
set-cdr!: String Ports
set-cdr!: R7RS
set-cdr!: SRFI 1
set-cell-contents!: Parameters
set-current-input-port!: Ports
set-current-output-port!: Ports
set-current-parser-macros!: Parser-language Macros
set-entity-extra!: Application Hooks
set-entity-procedure!: Application Hooks
set-ephemeron-datum!: Ephemerons
set-ephemeron-key!: Ephemerons
set-file-modes!: File Manipulation
set-file-times!: File Manipulation
set-font on x-graphics-device: Custom Operations on X Graphics Devices
set-foreground-color on x-graphics-device: Custom Operations on X Graphics Devices
set-hash-table-rehash-size!: Resizing of Hash Tables
set-hash-table-rehash-threshold!: Resizing of Hash Tables
set-hash-table/rehash-size!: Resizing of Hash Tables
set-hash-table/rehash-threshold!: Resizing of Hash Tables
set-input-buffer-size on textual input port: Textual Input Port Operations
set-input-port-blocking-mode!: Blocking Mode
set-input-port-terminal-mode!: Terminal Mode
set-interaction-i/o-port!: Ports
set-internal-border-width on x-graphics-device: Custom Operations on X Graphics Devices
set-mouse-color on x-graphics-device: Custom Operations on X Graphics Devices
set-mouse-shape on x-graphics-device: Custom Operations on X Graphics Devices
set-notification-output-port!: Ports
set-output-buffer-size on textual output port: Textual Output Port Operations
set-output-port-blocking-mode: Blocking Mode
set-output-port-terminal-mode!: Terminal Mode
set-parser-buffer-pointer!: Parser Buffers
set-port/state!: Constructors and Accessors for Textual Ports
set-record-type-unparser-method!: Custom Output
set-textual-port-state!: Constructors and Accessors for Textual Ports
set-trace-output-port!: Ports
set-working-directory-pathname!: Working Directory
set-xml-!attlist-definitions!: XML Structure
set-xml-!attlist-name!: XML Structure
set-xml-!element-content-type!: XML Structure
set-xml-!element-name!: XML Structure
set-xml-!entity-name!: XML Structure
set-xml-!entity-value!: XML Structure
set-xml-!notation-id!: XML Structure
set-xml-!notation-name!: XML Structure
set-xml-declaration-encoding!: XML Structure
set-xml-declaration-standalone!: XML Structure
set-xml-declaration-version!: XML Structure
set-xml-document-declaration!: XML Structure
set-xml-document-dtd!: XML Structure
set-xml-document-misc-1!: XML Structure
set-xml-document-misc-2!: XML Structure
set-xml-document-misc-3!: XML Structure
set-xml-document-root!: XML Structure
set-xml-dtd-external!: XML Structure
set-xml-dtd-internal!: XML Structure
set-xml-dtd-root!: XML Structure
set-xml-element-attributes!: XML Structure
set-xml-element-content!: XML Structure
set-xml-element-name!: XML Structure
set-xml-external-id-id!: XML Structure
set-xml-external-id-uri!: XML Structure
set-xml-parameter-!entity-name!: XML Structure
set-xml-parameter-!entity-value!: XML Structure
set-xml-processing-instructions-name!: XML Structure
set-xml-processing-instructions-text!: XML Structure
set-xml-unparsed-!entity-id!: XML Structure
set-xml-unparsed-!entity-name!: XML Structure
set-xml-unparsed-!entity-notation!: XML Structure
seventh: Selecting List Components
seventh: SRFI 1
sexp: *Matcher
sexp: *Parser
shell-file-name: Subprocess Options
shift-left: Bit operations
shift-right: Bit operations
shiftin: Bit operations
shiftout: Bit operations
signal-condition: Error System
signal-condition: Condition Signalling
signal-condition: Condition Signalling
signal-condition: Condition Signalling
signal-condition: Condition Handling
signal-condition: Condition Handling
signal-condition: Condition Handling
signal-condition: Condition Handling
signed-integer->bit-string: Integer Conversions of Bit Strings
simplest-exact-rational: Numerical operations
simplest-rational: Numerical operations
sin: Numerical operations
sin: R7RS
sin-pi*: Numerical operations
singleton-wt-tree: Construction of Weight-Balanced Trees
sixth: Selecting List Components
sixth: SRFI 1
soft-link-file: File Manipulation
sort: Miscellaneous List Operations
sort!: Modifying Vectors
source->parser-buffer: Parser Buffers
span: SRFI 1
span!: SRFI 1
split-at: SRFI 1
split-at!: SRFI 1
sqrt: Implementation restrictions
sqrt: Numerical operations
sqrt: R7RS
sqrt1pm1: Numerical operations
square: R7RS
standard-error-handler: Condition Handling
standard-error-handler: Condition Handling
standard-error-hook: Condition Handling
standard-print-method: Custom Output
standard-unparser-method: Custom Output
standard-warning-handler: Condition Handling
standard-warning-handler: Condition Handling
standard-warning-hook: Condition Handling
store-value: Restarts
store-value: Invoking Standard Restart Code
store-value: Invoking Standard Restart Code
stream: Streams
stream->list: Streams
stream-car: Streams
stream-cdr: Streams
stream-first: Streams
stream-head: Streams
stream-length: Streams
stream-map: Streams
stream-null?: Streams
stream-pair?: Streams
stream-ref: Streams
stream-rest: Streams
stream-tail: Streams
string: Strings
string: *Matcher
string: R7RS
string: SRFI 140
string*: Strings
string->char-set: SRFI 14
string->char-set!: SRFI 14
string->decoded-time: Time-Format Conversion
string->file-time: Time-Format Conversion
string->generator: SRFI 158
string->list: Strings
string->list: R7RS
string->list: SRFI 140
string->nfc: Strings
string->nfd: Strings
string->number: Numerical input and output
string->number: R7RS
string->parser-buffer: Parser Buffers
string->symbol: Symbols
string->symbol: R7RS
string->uninterned-symbol: Symbols
string->universal-time: Time-Format Conversion
string->utf16: SRFI 140
string->utf16be: SRFI 140
string->utf16le: SRFI 140
string->utf8: R7RS
string->utf8: SRFI 140
string->vector: Construction of Vectors
string->vector: R7RS
string->vector: SRFI 140
string->xml: XML Input
string-accumulator: SRFI 158
string-any: Strings
string-any: SRFI 140
string-append: Strings
string-append: R7RS
string-append: SRFI 140
string-append*: Strings
string-builder: Strings
string-ci: Regular S-Expressions
string-ci: *Matcher
string-ci-comparator: SRFI 162
string-ci-hash: SRFI 69
string-ci-hash: SRFI 125
string-ci-hash: SRFI 128
string-ci<=?: Strings
string-ci<=?: R7RS
string-ci<=?: SRFI 140
string-ci<?: Strings
string-ci<?: R7RS
string-ci<?: SRFI 140
string-ci=?: Strings
string-ci=?: Strings
string-ci=?: R7RS
string-ci=?: SRFI 140
string-ci>=?: Strings
string-ci>=?: R7RS
string-ci>=?: SRFI 140
string-ci>?: Strings
string-ci>?: R7RS
string-ci>?: SRFI 140
string-comparator: SRFI 162
string-compare: Strings
string-compare-ci: Strings
string-concatenate: SRFI 140
string-concatenate-reverse: SRFI 140
string-contains: SRFI 140
string-contains-right: SRFI 140
string-copy: Strings
string-copy: R7RS
string-copy!: Strings
string-copy!: R7RS
string-count: Strings
string-count: SRFI 140
string-downcase: Strings
string-downcase: R7RS
string-downcase: SRFI 140
string-drop: SRFI 140
string-drop-right: SRFI 140
string-end: Regular S-Expressions
string-every: Strings
string-every: SRFI 140
string-fill!: Strings
string-fill!: R7RS
string-filter: SRFI 140
string-find-first-index: Searching and Matching Strings
string-find-last-index: Searching and Matching Strings
string-find-next-char: Searching and Matching Strings
string-find-next-char-ci: Searching and Matching Strings
string-find-next-char-in-set: Searching and Matching Strings
string-find-previous-char: Searching and Matching Strings
string-find-previous-char-ci: Searching and Matching Strings
string-find-previous-char-in-set: Searching and Matching Strings
string-fold: SRFI 140
string-fold-right: SRFI 140
string-foldcase: Strings
string-foldcase: R7RS
string-foldcase: SRFI 140
string-for-each: Strings
string-for-each: R7RS
string-for-each: SRFI 140
string-for-each-index: SRFI 140
string-hash: Strings
string-hash: Symbols
string-hash: Construction of Hash Tables
string-hash: SRFI 69
string-hash: SRFI 125
string-hash: SRFI 128
string-hash-ci: Strings
string-head: Strings
string-in-nfc?: Strings
string-in-nfd?: Strings
string-index: SRFI 140
string-index-right: SRFI 140
string-is-xml-name?: XML Names
string-is-xml-nmtoken?: XML Names
string-join: SRFI 140
string-joiner: Strings
string-joiner*: Strings
string-length: Implementation restrictions
string-length: Strings
string-length: R7RS
string-length: SRFI 140
string-lower-case?: Strings
string-map: Strings
string-map: R7RS
string-map: SRFI 140
string-map-index: SRFI 140
string-match-backward: Searching and Matching Strings
string-match-forward: Searching and Matching Strings
string-null?: Strings
string-null?: SRFI 140
string-pad: SRFI 140
string-pad-left: Strings
string-pad-right: Strings
string-pad-right: SRFI 140
string-padder: Strings
string-prefix-ci?: Searching and Matching Strings
string-prefix-length: SRFI 140
string-prefix?: Searching and Matching Strings
string-prefix?: SRFI 140
string-ref: Storage Model
string-ref: Strings
string-ref: R7RS
string-ref: SRFI 140
string-remove: SRFI 140
string-repeat: SRFI 140
string-replace: Strings
string-replace: SRFI 140
string-search-all: Searching and Matching Strings
string-search-backward: Searching and Matching Strings
string-search-forward: Searching and Matching Strings
string-set!: Storage Model
string-set!: Strings
string-set!: Symbols
string-set!: R7RS
string-skip: SRFI 140
string-skip-right: SRFI 140
string-slice: Strings
string-split: SRFI 140
string-splitter: Strings
string-start: Regular S-Expressions
string-suffix-ci?: Searching and Matching Strings
string-suffix-length: SRFI 140
string-suffix?: Searching and Matching Strings
string-suffix?: SRFI 140
string-tabulate: SRFI 140
string-tail: Strings
string-take: SRFI 140
string-take-right: SRFI 140
string-titlecase: Strings
string-titlecase: SRFI 129
string-titlecase: SRFI 140
string-trim: Strings
string-trim: SRFI 140
string-trim-both: SRFI 140
string-trim-left: Strings
string-trim-right: Strings
string-trim-right: SRFI 140
string-trimmer: Strings
string-unfold: SRFI 140
string-unfold-right: SRFI 140
string-upcase: Strings
string-upcase: R7RS
string-upcase: SRFI 140
string-upper-case?: Strings
string-word-breaks: Strings
string-wt-type: Construction of Weight-Balanced Trees
string<=?: Strings
string<=?: R7RS
string<=?: SRFI 140
string<?: Strings
string<?: R7RS
string<?: SRFI 140
string=?: Equivalence Predicates
string=?: Equivalence Predicates
string=?: Strings
string=?: Strings
string=?: Symbols
string=?: Symbols
string=?: Construction of Hash Tables
string=?: Construction of Hash Tables
string=?: R7RS
string=?: SRFI 140
string>=?: Strings
string>=?: R7RS
string>=?: SRFI 140
string>?: Strings
string>?: R7RS
string>?: SRFI 140
string?: Strings
string?: R7RS
string?: SRFI 140
strong-hash-table/constructor: Construction of Hash Tables
sublist: Cutting and Pasting Lists
substring: Strings
substring: R7RS
substring: SRFI 140
substring->parser-buffer: Parser Buffers
substring?: Searching and Matching Strings
subvector: Cutting Vectors
subvector->list: Construction of Lists
subvector-fill!: Modifying Vectors
subvector-move-left!: Modifying Vectors
subvector-move-right!: Modifying Vectors
sum-accumulator: SRFI 158
symbol->string: Storage Model
symbol->string: Equivalence Predicates
symbol->string: Equivalence Predicates
symbol->string: Symbols
symbol->string: R7RS
symbol-append: Symbols
symbol-hash: Symbols
symbol-hash: SRFI 128
symbol-hash-mod: Symbols
symbol<?: Symbols
symbol=?: R7RS
symbol?: Symbols
symbol?: R7RS
syntax-error: R7RS
syntax-rules: Pattern Language
syntax-rules: R7RS
system-clock: Machine Time
system-global-environment: Environment Variables
system-library-directory-pathname: Miscellaneous Pathnames
system-library-pathname: Miscellaneous Pathnames

t: Booleans
take: Cutting and Pasting Lists
take: SRFI 1
take!: SRFI 1
take-right: SRFI 1
take-while: SRFI 1
take-while!: SRFI 1
tan: Numerical operations
tan: R7RS
tan-pi*: Numerical operations
tcp-server-connection-accept: TCP Sockets
template: Entry Format
temporary-directory-pathname: File Manipulation
temporary-file-pathname: File Manipulation
tenth: Selecting List Components
tenth: SRFI 1
textual-i/o-port-type?: Textual Port Types
textual-input-port->parser-buffer: Parser Buffers
textual-input-port-type?: Textual Port Types
textual-output-port-type?: Textual Port Types
textual-port-operation: Constructors and Accessors for Textual Ports
textual-port-operation-names: Constructors and Accessors for Textual Ports
textual-port-state: Constructors and Accessors for Textual Ports
textual-port-type: Constructors and Accessors for Textual Ports
textual-port-type?: Textual Port Types
textual-port?: Ports
textual-port?: R7RS
the-environment: Top-level Environments
third: Selecting List Components
third: SRFI 1
thunk?: Arity
time-zone->string: External Representation of Time
time-zone?: Decoded Time
toggle-bit: Bit operations
top-level-environment?: Top-level Environments
trace-output-port: Ports
trailing: Strings
trailing: Strings
transform: *Parser
tree-copy: Pairs
true: Booleans
truncate: Numerical operations
truncate: R7RS
truncate->exact: Numerical operations
truncate-quotient: Numerical operations
truncate-quotient: R7RS
truncate-remainder: Numerical operations
truncate-remainder: R7RS
truncate/: Numerical operations
truncate/: R7RS
type: Structure Definitions
type: Structure Definitions
type-descriptor: Structure Definitions

u8-ready?: Input Procedures
u8-ready?: R7RS
ucs-range->char-set: SRFI 14
ucs-range->char-set!: SRFI 14
unbind-variable: Top-level Environments
unfold: SRFI 1
unfold-right: SRFI 1
unhash: Object Hashing
unhash-object: Object Hashing
unicode-char?: Unicode
unicode-code-point?: Unicode
unicode-scalar-value?: Unicode
universal-time->file-time: Time-Format Conversion
universal-time->global-decoded-time: Time-Format Conversion
universal-time->global-time-string: Time-Format Conversion
universal-time->local-decoded-time: Time-Format Conversion
universal-time->local-time-string: Time-Format Conversion
unless: R7RS
unparser/set-tagged-pair-method!: Custom Output
unparser/set-tagged-vector-method!: Custom Output
unquote: Quoting
unquote: Lists
unquote: R7RS
unquote-splicing: Quoting
unquote-splicing: Lists
unquote-splicing: R7RS
unread-char: Input Procedures
unsigned-integer->bit-string: Integer Conversions of Bit Strings
unzip1: SRFI 1
unzip2: SRFI 1
unzip3: SRFI 1
unzip4: SRFI 1
unzip5: SRFI 1
use-pty?: Subprocess Options
use-value: Restarts
use-value: Invoking Standard Restart Code
user-homedir-pathname: Miscellaneous Pathnames
user-initial-environment: Initial and Current Environments
user-initial-environment: Environment Variables
user-initial-environment: REPL Environment
utf16->string: SRFI 140
utf16be->string: SRFI 140
utf16le->string: SRFI 140
utf8->string: R7RS
utf8->string: SRFI 140

valid-hash-number?: Object Hashing
valid-object-hash?: Object Hashing
valid-sre?: SRFI 115
values: Continuations
values: *Parser
values: R7RS
vector: Construction of Vectors
vector: R7RS
vector->generator: SRFI 158
vector->list: Construction of Lists
vector->list: Construction of Vectors
vector->list: R7RS
vector->string: Construction of Vectors
vector->string: R7RS
vector->string: SRFI 140
vector-accumulator: SRFI 158
vector-accumulator!: SRFI 158
vector-any: SRFI 133
vector-append: R7RS
vector-append-subvectors: SRFI 133
vector-binary-search: Selecting Vector Components
vector-binary-search: SRFI 133
vector-comparator: SRFI 162
vector-concatenate: SRFI 133
vector-copy: Construction of Vectors
vector-copy: R7RS
vector-copy!: R7RS
vector-count: SRFI 133
vector-cumulate: SRFI 133
vector-eighth: Selecting Vector Components
vector-empty?: SRFI 133
vector-every: SRFI 133
vector-fifth: Selecting Vector Components
vector-fill!: Modifying Vectors
vector-fill!: R7RS
vector-first: Selecting Vector Components
vector-fold: SRFI 133
vector-fold-right: SRFI 133
vector-for-each: Construction of Vectors
vector-for-each: R7RS
vector-fourth: Selecting Vector Components
vector-grow: Construction of Vectors
vector-head: Cutting Vectors
vector-index: SRFI 133
vector-index-right: SRFI 133
vector-length: Implementation restrictions
vector-length: Selecting Vector Components
vector-length: R7RS
vector-map: Construction of Vectors
vector-map: R7RS
vector-map!: SRFI 133
vector-partition: SRFI 133
vector-ref: Storage Model
vector-ref: Selecting Vector Components
vector-ref: R7RS
vector-reverse!: SRFI 133
vector-reverse-copy: SRFI 133
vector-reverse-copy!: SRFI 133
vector-second: Selecting Vector Components
vector-set!: Selecting Vector Components
vector-set!: R7RS
vector-seventh: Selecting Vector Components
vector-sixth: Selecting Vector Components
vector-skip: SRFI 133
vector-skip-right: SRFI 133
vector-swap!: SRFI 133
vector-tail: Cutting Vectors
vector-third: Selecting Vector Components
vector-unfold: SRFI 133
vector-unfold!: SRFI 133
vector-unfold-right: SRFI 133
vector-unfold-right!: SRFI 133
vector=: SRFI 133
vector?: Selecting Vector Components
vector?: R7RS
versin: Numerical operations
versin-pi*: Numerical operations

warn: Condition Signalling
warn: Condition Signalling
warn: Invoking Standard Restart Code
weak-car: Weak Pairs
weak-cdr: Weak Pairs
weak-cons: Weak Pairs
weak-hash-table/constructor: Construction of Hash Tables
weak-pair/car?: Weak Pairs
weak-pair?: Weak Pairs
weak-set-car!: Weak Pairs
weak-set-cdr!: Weak Pairs
when: R7RS
where: Prompting
with-current-parser-macros: Parser-language Macros
with-current-unparser-state: Custom Output
with-exception-handler: R7RS
with-input-from-binary-file: File Ports
with-input-from-file: File Ports
with-input-from-file: R7RS
with-input-from-port: Ports
with-input-from-string: String Ports
with-input-port-blocking-mode: Blocking Mode
with-input-port-terminal-mode: Terminal Mode
with-interaction-i/o-port: Ports
with-notification-output-port: Ports
with-output-port-blocking-mode: Blocking Mode
with-output-port-terminal-mode: Terminal Mode
with-output-to-binary-file: File Ports
with-output-to-file: File Ports
with-output-to-file: R7RS
with-output-to-port: Ports
with-output-to-string: String Ports
with-output-to-truncated-string: String Ports
with-pointer: *Matcher
with-pointer: *Parser
with-restart: Error System
with-restart: Restarts
with-restart: Establishing Restart Code
with-restart: Finding and Invoking General Restart Code
with-simple-restart: Restarts
with-simple-restart: Restarts
with-simple-restart: Establishing Restart Code
with-simple-restart: Finding and Invoking General Restart Code
with-timings: Machine Time
with-trace-output-port: Ports
with-working-directory-pathname: Working Directory
withdraw-window on x-graphics-device: Custom Operations on X Graphics Devices
within-continuation: Continuations
working-directory: Subprocess Options
working-directory-pathname: Working Directory
write: External Representations
write: Symbols
write: Symbols
write: Ports
write: String Ports
write: String Ports
write: Output Procedures
write: Error Messages
write: R7RS
write-bytevector: Output Procedures
write-bytevector: R7RS
write-char: Entry Format
write-char: Ports
write-char: Output Procedures
write-char: R7RS
write-char on textual output port: Textual Output Port Operations
write-condition-report: Condition Handling
write-condition-report: Condition State
write-condition-report: Simple Condition Instance Operations
write-line: Output Procedures
write-restart-report: The Named Restart Abstraction
write-shared: Output Procedures
write-shared: R7RS
write-simple: Output Procedures
write-simple: R7RS
write-string: Output Procedures
write-string: Format
write-string: R7RS
write-substring: Output Procedures
write-substring on textual output port: Textual Output Port Operations
write-to-string: String Ports
write-u8: Ports
write-u8: Output Procedures
write-u8: R7RS
write-xml: XML Output
write-xml-file: XML Output
wt-tree/add: Basic Operations on Weight-Balanced Trees
wt-tree/add!: Basic Operations on Weight-Balanced Trees
wt-tree/delete: Basic Operations on Weight-Balanced Trees
wt-tree/delete!: Basic Operations on Weight-Balanced Trees
wt-tree/delete-min: Indexing Operations on Weight-Balanced Trees
wt-tree/delete-min!: Indexing Operations on Weight-Balanced Trees
wt-tree/difference: Advanced Operations on Weight-Balanced Trees
wt-tree/empty?: Basic Operations on Weight-Balanced Trees
wt-tree/fold: Advanced Operations on Weight-Balanced Trees
wt-tree/for-each: Advanced Operations on Weight-Balanced Trees
wt-tree/index: Indexing Operations on Weight-Balanced Trees
wt-tree/index-datum: Indexing Operations on Weight-Balanced Trees
wt-tree/index-pair: Indexing Operations on Weight-Balanced Trees
wt-tree/intersection: Advanced Operations on Weight-Balanced Trees
wt-tree/lookup: Basic Operations on Weight-Balanced Trees
wt-tree/member?: Basic Operations on Weight-Balanced Trees
wt-tree/min: Indexing Operations on Weight-Balanced Trees
wt-tree/min-datum: Indexing Operations on Weight-Balanced Trees
wt-tree/min-pair: Indexing Operations on Weight-Balanced Trees
wt-tree/rank: Indexing Operations on Weight-Balanced Trees
wt-tree/set-equal?: Advanced Operations on Weight-Balanced Trees
wt-tree/size: Basic Operations on Weight-Balanced Trees
wt-tree/split<: Advanced Operations on Weight-Balanced Trees
wt-tree/split>: Advanced Operations on Weight-Balanced Trees
wt-tree/subset?: Advanced Operations on Weight-Balanced Trees
wt-tree/union: Advanced Operations on Weight-Balanced Trees
wt-tree/union-merge: Advanced Operations on Weight-Balanced Trees
wt-tree?: Basic Operations on Weight-Balanced Trees

x-character-bounds/ascent: Custom Operations on X Graphics Devices
x-character-bounds/descent: Custom Operations on X Graphics Devices
x-character-bounds/lbearing: Custom Operations on X Graphics Devices
x-character-bounds/rbearing: Custom Operations on X Graphics Devices
x-character-bounds/width: Custom Operations on X Graphics Devices
x-close-all-displays: Utilities for X Graphics
x-font-structure/all-chars-exist: Custom Operations on X Graphics Devices
x-font-structure/character-bounds: Custom Operations on X Graphics Devices
x-font-structure/default-char: Custom Operations on X Graphics Devices
x-font-structure/direction: Custom Operations on X Graphics Devices
x-font-structure/max-ascent: Custom Operations on X Graphics Devices
x-font-structure/max-bounds: Custom Operations on X Graphics Devices
x-font-structure/max-descent: Custom Operations on X Graphics Devices
x-font-structure/min-bounds: Custom Operations on X Graphics Devices
x-font-structure/name: Custom Operations on X Graphics Devices
x-font-structure/start-index: Custom Operations on X Graphics Devices
x-geometry-string: Utilities for X Graphics
x-graphics/close-display: Utilities for X Graphics
x-graphics/open-display: Utilities for X Graphics
x-open-display: X Graphics Type
x-size on textual output port: Textual Output Port Operations
xcons: Pairs
xcons: SRFI 1
xml-!attlist: XML Structure
xml-!attlist-definitions: XML Structure
xml-!attlist-name: XML Structure
xml-!attlist?: XML Structure
xml-!element: XML Structure
xml-!element-content-type: XML Structure
xml-!element-name: XML Structure
xml-!element?: XML Structure
xml-!entity: XML Structure
xml-!entity-name: XML Structure
xml-!entity-value: XML Structure
xml-!entity?: XML Structure
xml-!notation: XML Structure
xml-!notation-id: XML Structure
xml-!notation-name: XML Structure
xml-!notation?: XML Structure
xml->string: XML Output
xml->wide-string: XML Output
xml-declaration: XML Structure
xml-declaration-encoding: XML Structure
xml-declaration-standalone: XML Structure
xml-declaration-version: XML Structure
xml-declaration?: XML Structure
xml-document: XML Structure
xml-document-declaration: XML Structure
xml-document-dtd: XML Structure
xml-document-misc-1: XML Structure
xml-document-misc-2: XML Structure
xml-document-misc-3: XML Structure
xml-document-root: XML Structure
xml-document?: XML Structure
xml-dtd: XML Structure
xml-dtd-external: XML Structure
xml-dtd-internal: XML Structure
xml-dtd-root: XML Structure
xml-dtd?: XML Structure
xml-element: XML Structure
xml-element-attributes: XML Structure
xml-element-content: XML Structure
xml-element-name: XML Structure
xml-element?: XML Structure
xml-external-id: XML Structure
xml-external-id-id: XML Structure
xml-external-id-uri: XML Structure
xml-external-id?: XML Structure
xml-name->symbol: XML Names
xml-name-local: XML Names
xml-name-prefix: XML Names
xml-name-string: XML Names
xml-name-uri: XML Names
xml-name=?: XML Names
xml-name?: XML Names
xml-nmtoken?: XML Names
xml-parameter-!entity: XML Structure
xml-parameter-!entity-name: XML Structure
xml-parameter-!entity-value: XML Structure
xml-parameter-!entity?: XML Structure
xml-processing-instructions: XML Structure
xml-processing-instructions-name: XML Structure
xml-processing-instructions-text: XML Structure
xml-processing-instructions?: XML Structure
xml-qname-local: XML Names
xml-qname-prefix: XML Names
xml-qname?: XML Names
xml-unparsed-!entity: XML Structure
xml-unparsed-!entity-id: XML Structure
xml-unparsed-!entity-name: XML Structure
xml-unparsed-!entity-notation: XML Structure
xml-unparsed-!entity?: XML Structure
xml-uri: XML Names
xmlns-uri: XML Names
xsubstring: SRFI 140

y-size: Textual Port Primitives
y-size on textual output port: Textual Output Port Operations

zero?: Numerical operations
zero?: Numerical operations
zero?: R7RS
zip: SRFI 1

Jump to:   "   #   '   (   )   *   +   ,   -   .   /   1   2   8   <   =   >   ?   \   _   `  
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  

Next: Concept Index, Previous: GNU Free Documentation License, Up: MIT/GNU Scheme   [Contents][Index]