|
|
- |
| -| notational convention | Examples |
| -ci, in string procedure name | Strings |
|
, |
| , as external representation | Quoting |
| ,@ as external representation | Quoting |
|
; |
| ; as external representation | Comments |
|
! |
| ! in mutation procedure names | Naming Conventions |
|
? |
| ? in predicate names | Naming Conventions |
|
. |
| . as external representation | Lists |
| ... in entries | Entry Format |
|
' |
| ’ as external representation | Quoting |
|
" |
| " as external representation | Strings |
|
( |
| ( as external representation | Lists |
|
) |
| ) as external representation | Lists |
|
[ |
| [ in entries | Entry Format |
|
] |
| ] in entries | Entry Format |
|
\ |
| \ as escape character in string | Strings |
|
# |
| # as format parameter | Format |
| # in external representation of number | Syntax of numerical constants |
| #( as external representation | Vectors |
| #[ as external representation | Custom Output |
| #* as external representation | Bit Strings |
| #\ as external representation | Characters |
| #| as external representation | Comments |
| #b as external representation | Syntax of numerical constants |
| #d as external representation | Syntax of numerical constants |
| #e as external representation | Syntax of numerical constants |
| #f as external representation | Booleans |
| #i as external representation | Syntax of numerical constants |
| #o as external representation | Syntax of numerical constants |
| #t as external representation | Booleans |
| #x as external representation | Syntax of numerical constants |
|
` |
| ‘ as external representation | Quoting |
|
= |
| => in cond clause | Conditionals |
| => notational convention | Examples |
|
1 |
| 1D table (defn) | 1D Tables |
|
A |
| absolute pathname (defn) | Working Directory |
| absolute value, of number | Numerical operations |
| access time, of file | File Manipulation |
| access, used with set! | Assignments |
| addition, of numbers | Numerical operations |
| address hashing | Address Hashing |
| alias | Syntax Terminology |
| alias | SC Identifiers |
| alist (defn) | Association Lists |
| alphabetic case-insensitivity of programs (defn) | Uppercase and Lowercase |
| alphabetic case, of interned symbol | Symbols |
| anonymous syntactic keyword | Macros |
| apostrophe, as external representation | Quoting |
| appending, of bit strings | Cutting and Pasting Bit Strings |
| appending, of lists | Cutting and Pasting Lists |
| appending, of symbols | Symbols |
| appending, to output file | File Ports |
| application hook (defn) | Procedures |
| application hook (defn) | Application Hooks |
| application, of procedure | Procedure Operations |
| apply hook (defn) | Application Hooks |
| argument evaluation order | Procedure Call Syntax |
| arity | Arity |
| ASCII character | Character implementation |
| assignment | Assignments |
| association list (defn) | Association Lists |
| association table (defn) | The Association Table |
| asterisk, as external representation | Bit Strings |
| attribute, of file | File Manipulation |
|
B |
| backquote, as external representation | Quoting |
| backslash, as escape character in string | Strings |
| Backtracking, in parser language | Parser Language |
| balanced binary trees | Red-Black Trees |
| balanced binary trees | Weight-Balanced Trees |
| barrier, reference | Reference barriers |
| bell, ringing on console | Output Procedures |
| binary port (defn) | Ports |
| binary trees | Red-Black Trees |
| binary trees | Weight-Balanced Trees |
| binary trees, as discrete maps | Weight-Balanced Trees |
| binary trees, as sets | Weight-Balanced Trees |
| binding expression (defn) | Static Scoping |
| binding expression, dynamic | Dynamic Binding |
| binding expression, lexical | Lexical Binding |
| binding, of variable | Variable Bindings |
| binding, syntactic keyword | Environment Operations |
| binding, unassigned | Environment Operations |
| binding, variable | Environment Operations |
| bit string (defn) | Bit Strings |
| bit string index (defn) | Bit Strings |
| bit string length (defn) | Bit Strings |
| bitless character | Character implementation |
| bitmaps, graphics | Images |
| bitwise operations | Bit operations |
| bitwise-logical operations, on fixnums | Fixnum Operations |
| block structure | Lexical Binding |
| blocking mode, of port | Blocking Mode |
| BOA constructor | Structure Definitions |
| BOA constructor (defn) | Structure Definitions |
| body, of special form (defn) | Entry Format |
| boolean object | True and False |
| boolean object (defn) | Booleans |
| boolean object, equivalence predicate | Booleans |
| bound variable (defn) | Variable Bindings |
| bound-restarts | Generating Operations on Conditions |
| bound-restarts | Simple Condition Instance Operations |
| bracket, in entries | Entry Format |
| broken ephemeron | Ephemerons |
| bucky bit, of character (defn) | Character implementation |
| bucky bit, prefix (defn) | Characters |
| buffering, of graphics output | Buffering of Graphics Output |
| buffering, of output | Output Procedures |
| built-in procedure | Procedures |
| bytevector, input and output ports | Bytevector Ports |
|
C |
| call by need evaluation (defn) | Promises |
| car field, of pair (defn) | Lists |
| case clause | Conditionals |
| case conversion, of character | Characters |
| case folding, of character | Characters |
| case sensitivity, of string operations | Strings |
| case-insensitivity of programs (defn) | Uppercase and Lowercase |
| case, of interned symbol | Symbols |
| cdr field, of pair (defn) | Lists |
| cell (defn) | Parameters |
| character (defn) | Characters |
| character bits (defn) | Character implementation |
| character code (defn) | Character implementation |
| character set | Character Sets |
| character, bitless | Character implementation |
| character, input from port | Input Procedures |
| character, input from textual port | Textual Input Port Operations |
| character, output to textual port | Textual Output Port Operations |
| character, searching string for | Searching and Matching Strings |
| characters, special, in programs | Additional Notations |
| child, of environment (defn) | Environment Concepts |
| circles, drawing | Custom Operations on X Graphics Devices |
| circles, drawing | Custom Operations on X Graphics Devices |
| circular list | Selecting List Components |
| circular list | Miscellaneous List Operations |
| circular structure | Equivalence Predicates |
| clause, of case expression | Conditionals |
| clause, of cond expression | Conditionals |
| clearing the console screen | Output Procedures |
| client socket | TCP Sockets |
| clip rectangle, graphics (defn) | Clipping of Graphics Output |
| clipping, of graphics | Clipping of Graphics Output |
| closing environment, of procedure (defn) | Lambda Expressions |
| closing, of file port | File Ports |
| closing, of port | Ports |
| code point | Unicode |
| code-point list | Character Sets |
| code-point range | Character Sets |
| code-point range | Character Sets |
| code, of character (defn) | Character implementation |
| combination (defn) | Procedure Call Syntax |
| comma, as external representation | Quoting |
| comment, extended, in programs (defn) | Comments |
| comment, in programs (defn) | Comments |
| comparison predicate | Explicit Renaming |
| comparison, for equivalence | Equivalence Predicates |
| comparison, of bit strings | Bitwise Operations on Bit Strings |
| comparison, of boolean objects | Booleans |
| comparison, of characters | Characters |
| comparison, of numbers | Numerical operations |
| comparison, of XML names | XML Names |
| compiled, procedure type | Procedures |
| component selection, of bit string | Selecting Bit String Components |
| component selection, of cell | Parameters |
| component selection, of character | Character implementation |
| component selection, of ephemeron | Ephemerons |
| component selection, of list | Selecting List Components |
| component selection, of pair | Pairs |
| component selection, of stream | Streams |
| component selection, of vector | Selecting Vector Components |
| component selection, of weak pair | Weak Pairs |
| components, of pathname | Components of Pathnames |
| compound procedure | Procedures |
| cond clause | Conditionals |
| condition (defn) | Condition Instances |
| condition handler (defn) | Condition Handling |
| condition instance (defn) | Condition Instances |
| condition signalling (defn) | Condition Signalling |
| condition type | Error System |
| condition type | Condition Types |
| conditional expression (defn) | Conditionals |
| console, clearing | Output Procedures |
| console, port | Ports |
| console, ringing the bell | Output Procedures |
| constant | Storage Model |
| constant expression (defn) | Literal Expressions |
| constant, and quasiquote | Quoting |
| constant, and quote | Quoting |
| construction, of bit string | Construction of Bit Strings |
| construction, of cell | Parameters |
| construction, of character | Character implementation |
| construction, of circular list | Miscellaneous List Operations |
| construction, of continuation | Continuations |
| construction, of EOF object | Input Procedures |
| construction, of ephemeron | Ephemerons |
| construction, of hash table | Construction of Hash Tables |
| construction, of list | Construction of Lists |
| construction, of pair | Pairs |
| construction, of pathname | Filenames and Pathnames |
| construction, of pathname | Filenames and Pathnames |
| construction, of pathname | Components of Pathnames |
| construction, of procedure | Lambda Expressions |
| construction, of promise | Promises |
| construction, of stream | Streams |
| construction, of symbols | Symbols |
| construction, of textual port type | Textual Port Types |
| construction, of vector | Construction of Vectors |
| construction, of weak pair | Weak Pairs |
| continuation | Continuations |
| continuation, alternate invocation | Continuations |
| continuation, and dynamic binding | Dynamic Binding |
| control, bucky bit prefix (defn) | Characters |
| conventions for error messages | Error Messages |
| conventions, lexical | Lexical Conventions |
| conventions, naming | Naming Conventions |
| conventions, notational | Notational Conventions |
| conversion, pathname to string | Filenames and Pathnames |
| conversion, pathname to string | Operations on Pathnames |
| cooked mode, of terminal port | Terminal Mode |
| coordinates, graphics | Coordinates for Graphics |
| copying, of alist | Association Lists |
| copying, of bit string | Construction of Bit Strings |
| copying, of file | File Manipulation |
| copying, of tree | Pairs |
| copying, of vector | Construction of Vectors |
| current environment | Top-level Environments |
| current environment (defn) | Initial and Current Environments |
| current error port (defn) | Ports |
| current input port (defn) | Ports |
| current input port, rebinding | File Ports |
| current interaction port (defn) | Ports |
| current notification port (defn) | Ports |
| current output port (defn) | Ports |
| current output port, rebinding | File Ports |
| current tracing output port (defn) | Ports |
| current working directory | Operating-System Interface |
| current working directory (defn) | Working Directory |
| cursor, graphics (defn) | Drawing Graphics |
| custom operations, on graphics device | Custom Graphics Operations |
| custom operations, on textual port | Textual Port Primitives |
| cutting, of bit string | Cutting and Pasting Bit Strings |
| cutting, of list | Cutting and Pasting Lists |
| cutting, of vector | Cutting Vectors |
|
D |
| d, as exponent marker in number | Syntax of numerical constants |
| decoded time | Date and Time |
| default environment, floating-point | Floating-Point Environment |
| default object (defn) | Lambda Expressions |
| defaulting, of pathname | Operations on Pathnames |
| defaulting, of pathname | Operations on Pathnames |
| define, procedure (defn) | Definitions |
| definition | Definitions |
| definition, internal | Internal Definitions |
| definition, internal (defn) | Definitions |
| definition, top-level | Top-Level Definitions |
| definition, top-level (defn) | Definitions |
| deletion, of alist element | Association Lists |
| deletion, of file | File Manipulation |
| deletion, of list element | Filtering Lists |
| delimiter, in programs (defn) | Delimiters |
| denormal | Flonum Operations |
| device coordinates, graphics (defn) | Coordinates for Graphics |
| device, pathname component | Components of Pathnames |
| difference, of numbers | Numerical operations |
| directive, format (defn) | Format |
| directory path (defn) | Components of Pathnames |
| directory, converting pathname to | Operations on Pathnames |
| directory, current working (defn) | Working Directory |
| directory, pathname component | Components of Pathnames |
| directory, predicate for | File Manipulation |
| directory, reading | Miscellaneous Pathnames |
| directory, reading | Directory Reader |
| discrete maps, using binary trees | Weight-Balanced Trees |
| discretionary flushing, of buffered output | Output Procedures |
| disembodied property list | Symbols |
| display, clearing | Output Procedures |
| display, X graphics | Utilities for X Graphics |
| divide-by-zero exception | Floating-Point Exceptions |
| division, of integers | Numerical operations |
| division, of numbers | Numerical operations |
| dot, as external representation | Lists |
| dotted notation, for pair (defn) | Lists |
| dotted pair (see pair) | Lists |
| double precision, of inexact number | Syntax of numerical constants |
| double quote, as external representation | Strings |
| drawing arcs and circles, graphics | Custom Operations on X Graphics Devices |
| drawing arcs and circles, graphics | Custom Operations on X Graphics Devices |
| drawing mode, graphics (defn) | Characteristics of Graphics Output |
| dynamic binding | Dynamic Binding |
| dynamic binding | Condition Handling |
| dynamic binding | Condition Handling |
| dynamic binding, and continuations | Dynamic Binding |
| dynamic binding, versus static scoping | Static Scoping |
| dynamic environment | Dynamic Binding |
| dynamic extent | Dynamic Binding |
| dynamic parameter (defn) | Parameters |
| dynamic types (defn) | Overview |
|
E |
| e, as exponent marker in number | Syntax of numerical constants |
| effector, restart (defn) | Restarts |
| element, of list (defn) | Lists |
| ellipsis, in entries | Entry Format |
| else clause, of case expression (defn) | Conditionals |
| else clause, of cond expression (defn) | Conditionals |
| empty list (defn) | Lists |
| empty list, external representation | Lists |
| empty list, predicate for | Selecting List Components |
| empty stream, predicate for | Streams |
| empty string, predicate for | Strings |
| end of file object (see EOF object) | Input Procedures |
| end, of subvector (defn) | Vectors |
| entity (defn) | Application Hooks |
| entry format | Entry Format |
| environment (defn) | Environment Concepts |
| environment, current | Top-level Environments |
| environment, current (defn) | Initial and Current Environments |
| environment, extension (defn) | Environment Concepts |
| environment, initial (defn) | Initial and Current Environments |
| environment, interpreter | Top-level Environments |
| environment, of procedure | Lambda Expressions |
| environment, procedure closing (defn) | Lambda Expressions |
| environment, procedure invocation (defn) | Lambda Expressions |
| environment, top-level | Top-level Environments |
| EOF object, construction | Input Procedures |
| EOF object, predicate for | Input Procedures |
| ephemerally held data, of hash table | Construction of Hash Tables |
| ephemerally held keys, of hash table | Construction of Hash Tables |
| ephemeron (defn) | Ephemerons |
| ephemeron, broken | Ephemerons |
| equality, of XML names | XML Names |
| equivalence predicate (defn) | Equivalence Predicates |
| equivalence predicate, for bit strings | Bitwise Operations on Bit Strings |
| equivalence predicate, for boolean objects | Booleans |
| equivalence predicate, for characters | Characters |
| equivalence predicate, for fixnums | Fixnum Operations |
| equivalence predicate, for flonums | Flonum Operations |
| equivalence predicate, for flonums | Flonum Operations |
| equivalence predicate, for numbers | Numerical operations |
| equivalence predicate, for pathname host | Miscellaneous Pathnames |
| equivalence predicate, for pathnames | Operations on Pathnames |
| equivalence predicate, of hash table | Construction of Hash Tables |
| error messages, conventions | Error Messages |
| error port, current (defn) | Ports |
| error–> notational convention | Examples |
| error, in examples | Examples |
| error, unassigned variable | Variable Bindings |
| error, unbound variable (defn) | Environment Concepts |
| errors, notational conventions | Errors |
| escape character, for string | Strings |
| escape procedure (defn) | Continuations |
| escape procedure, alternate invocation | Continuations |
| evaluation order, of arguments | Procedure Call Syntax |
| evaluation, call by need (defn) | Promises |
| evaluation, in examples | Examples |
| evaluation, lazy (defn) | Promises |
| evaluation, of s-expression | Environment Operations |
| even number | Numerical operations |
| exactness | Exactness |
| examples | Examples |
| existence, testing of file | File Manipulation |
| exit, non-local | Continuations |
| explicit renaming | Explicit Renaming |
| exponent marker (defn) | Syntax of numerical constants |
| expression (defn) | Expressions |
| expression, binding (defn) | Static Scoping |
| expression, conditional (defn) | Conditionals |
| expression, constant (defn) | Literal Expressions |
| expression, input from port | Input Procedures |
| expression, iteration (defn) | Iteration |
| expression, literal (defn) | Literal Expressions |
| expression, procedure call (defn) | Procedure Call Syntax |
| expression, special form (defn) | Special Form Syntax |
| extended comment, in programs (defn) | Comments |
| extended real line | Flonum Operations |
| extension, of environment (defn) | Environment Concepts |
| extent, of dynamic binding (defn) | Dynamic Binding |
| extent, of objects | Overview |
| external representation (defn) | External Representations |
| external representation, and quasiquote | Quoting |
| external representation, and quote | Quoting |
| external representation, for bit string | Bit Strings |
| external representation, for empty list | Lists |
| external representation, for list | Lists |
| external representation, for number | Syntax of numerical constants |
| external representation, for pair | Lists |
| external representation, for procedure | Procedures |
| external representation, for string | Strings |
| external representation, for symbol | Symbols |
| external representation, for vector | Vectors |
| external representation, parsing | Input Procedures |
| extra object, of application hook | Application Hooks |
|
F |
| f, as exponent marker in number | Syntax of numerical constants |
| false, boolean object | True and False |
| false, boolean object (defn) | Booleans |
| false, in conditional expression (defn) | Conditionals |
| false, predicate for | Booleans |
| FDL, GNU Free Documentation License | GNU Free Documentation License |
| file (regular), predicate for | File Manipulation |
| file name | Pathnames |
| file time | Date and Time |
| file type, procedure for | File Manipulation |
| file, converting pathname directory to | Operations on Pathnames |
| file, end-of-file marker (see EOF object) | Input Procedures |
| file, input and output ports | File Ports |
| filename (defn) | Pathnames |
| filling, of bit string | Modification of Bit Strings |
| filling, of vector | Modifying Vectors |
| filtering, of list | Filtering Lists |
| fixnum (defn) | Fixnum Operations |
| floating-point comparison, ordered | Flonum Operations |
| floating-point comparison, unordered | Flonum Operations |
| floating-point environment | Floating-Point Environment |
| floating-point environment, default | Floating-Point Environment |
| floating-point number, infinite | Flonum Operations |
| floating-point number, normal | Flonum Operations |
| floating-point number, not a number | Flonum Operations |
| floating-point number, subnormal | Flonum Operations |
| floating-point number, zero | Flonum Operations |
| flonum (defn) | Flonum Operations |
| flushing, of buffered output | Output Procedures |
| folding, of list | Folding of Lists |
| forcing, of promise | Promises |
| form | Syntax Terminology |
| form, special (defn) | Special Form Syntax |
| formal parameter list, of lambda (defn) | Lambda Expressions |
| format directive (defn) | Format |
| format, entry | Entry Format |
|
G |
| generalization, of condition types | Error System |
| generalization, of condition types | Condition Signalling |
| generalization, of condition types | Condition Types |
| generalization, of condition types | Condition Types |
| generalization, of condition types | Condition Types |
| generalization, of condition types (defn) | Error System |
| gensym (see uninterned symbol) | Symbols |
| geometry string, X graphics | Utilities for X Graphics |
| grapheme cluster | Strings |
| graphics | Graphics |
| graphics, bitmaps | Images |
| graphics, buffering of output | Buffering of Graphics Output |
| graphics, clipping | Clipping of Graphics Output |
| graphics, coordinate systems | Coordinates for Graphics |
| graphics, cursor (defn) | Drawing Graphics |
| graphics, custom operations | Custom Graphics Operations |
| graphics, device coordinates (defn) | Coordinates for Graphics |
| graphics, drawing | Drawing Graphics |
| graphics, drawing arcs and circles | Custom Operations on X Graphics Devices |
| graphics, drawing arcs and circles | Custom Operations on X Graphics Devices |
| graphics, drawing mode (defn) | Characteristics of Graphics Output |
| graphics, images | Images |
| graphics, line style (defn) | Characteristics of Graphics Output |
| graphics, opening and closing devices | Opening and Closing of Graphics Devices |
| graphics, output characteristics | Characteristics of Graphics Output |
| graphics, virtual coordinates (defn) | Coordinates for Graphics |
| greatest common divisor, of numbers | Numerical operations |
| growing, of vector | Construction of Vectors |
|
H |
| handler, condition (defn) | Condition Handling |
| hard linking, of file | File Manipulation |
| hash table | Hash Tables |
| hashing, of key in hash table | Construction of Hash Tables |
| hashing, of object | Object Hashing |
| hashing, of string | Strings |
| hashing, of symbol | Symbols |
| home directory, as pathname | Miscellaneous Pathnames |
| home directory, as pathname | Miscellaneous Pathnames |
| hook, application (defn) | Procedures |
| host, in filename | Pathnames |
| host, pathname component | Components of Pathnames |
| hostname, TCP | TCP Sockets |
| hygienic | Macros |
| hyper, bucky bit prefix (defn) | Characters |
|
I |
| I/O, to bytevectors | Bytevector Ports |
| I/O, to files | File Ports |
| I/O, to strings | String Ports |
| identifier | Syntax Terminology |
| identifier (defn) | Identifiers |
| identity, additive | Numerical operations |
| identity, multiplicative | Numerical operations |
| images, graphics | Images |
| immutable | Storage Model |
| immutable string | Strings |
| implementation restriction | Implementation restrictions |
| implicit begin | Sequencing |
| improper list (defn) | Lists |
| index, of bit string (defn) | Bit Strings |
| index, of list (defn) | Selecting List Components |
| index, of string (defn) | Strings |
| index, of subvector (defn) | Vectors |
| index, of vector (defn) | Vectors |
| inexact-result exception | Floating-Point Exceptions |
| infinity (+inf.0 , -inf.0 ) | Flonum Operations |
| inheritance, of environment bindings (defn) | Environment Concepts |
| initial environment (defn) | Initial and Current Environments |
| initial size, of hash table | Resizing of Hash Tables |
| input | Input/Output |
| input form | SC Transformer Definition |
| input form, to macro | Explicit Renaming |
| input operations | Input Procedures |
| input port (defn) | Ports |
| input port, bytevector | Bytevector Ports |
| input port, console | Ports |
| input port, current (defn) | Ports |
| input port, file | File Ports |
| input port, string | String Ports |
| input, XML | XML Input |
| insensitivity, to case in programs (defn) | Uppercase and Lowercase |
| installed, as pathname component | Components of Pathnames |
| instance, of condition (defn) | Condition Instances |
| integer division | Numerical operations |
| integer, converting to bit string | Integer Conversions of Bit Strings |
| interaction port, current (defn) | Ports |
| interactive input ports (defn) | Input Procedures |
| internal definition | Internal Definitions |
| internal definition (defn) | Definitions |
| internal representation, for character | Character implementation |
| internal representation, for inexact number | Syntax of numerical constants |
| interned symbol (defn) | Symbols |
| interning, of symbols | Symbols |
| interpreted, procedure type | Procedures |
| interpreter environment | Top-level Environments |
| invalid-operation exception | Flonum Operations |
| invalid-operation exception | Floating-Point Exceptions |
| inverse, additive, of number | Numerical operations |
| inverse, multiplicative, of number | Numerical operations |
| inverse, of bit string | Bitwise Operations on Bit Strings |
| inverse, of boolean object | Booleans |
| invocation environment, of procedure (defn) | Lambda Expressions |
| iteration expression (defn) | Iteration |
|
J |
| joiner procedure, of strings | Strings |
| joining, of strings | Strings |
|
K |
| key, of association list element (defn) | Association Lists |
| keyword | Macros |
| keyword binding | Environment Operations |
| keyword constructor | Structure Definitions |
| keyword constructor (defn) | Structure Definitions |
| keyword, of special form (defn) | Special Form Syntax |
|
L |
| l, as exponent marker in number | Syntax of numerical constants |
| lambda expression (defn) | Lambda Expressions |
| lambda list (defn) | Lambda Expressions |
| lambda, implicit in define | Definitions |
| lambda, implicit in let | Lexical Binding |
| latent types (defn) | Overview |
| lazy evaluation (defn) | Promises |
| least common multiple, of numbers | Numerical operations |
| length, of bit string | Selecting Bit String Components |
| length, of bit string (defn) | Bit Strings |
| length, of list (defn) | Lists |
| length, of stream | Streams |
| length, of string (defn) | Strings |
| length, of vector (defn) | Vectors |
| letrec, implicit in define | Internal Definitions |
| lexical binding expression | Lexical Binding |
| lexical conventions | Lexical Conventions |
| lexical scoping (defn) | Static Scoping |
| library, system pathname | Miscellaneous Pathnames |
| library, system pathname | Miscellaneous Pathnames |
| line style, graphics (defn) | Characteristics of Graphics Output |
| linking (hard), of file | File Manipulation |
| linking (soft), of file | File Manipulation |
| list (defn) | Lists |
| list index (defn) | Selecting List Components |
| list, association (defn) | Association Lists |
| list, converting to stream | Streams |
| list, converting to vector | Construction of Vectors |
| list, external representation | Lists |
| list, improper (defn) | Lists |
| literal expression (defn) | Literal Expressions |
| literal, and quasiquote | Quoting |
| literal, and quote | Quoting |
| literal, identifier as | Identifiers |
| local part, of XML name | XML Names |
| location | Storage Model |
| location, of variable | Variable Bindings |
| log-odds | Numerical operations |
| log-odds | Numerical operations |
| log-probability | Numerical operations |
| log-probability | Numerical operations |
| logical operations, on fixnums | Fixnum Operations |
| long precision, of inexact number | Syntax of numerical constants |
| loopback interface | Miscellaneous OS Facilities |
| looping (see iteration expressions) | Iteration |
| lowercase | Uppercase and Lowercase |
| lowercase, character conversion | Characters |
|
M |
| macro | Macros |
| macro keyword | Macros |
| macro transformer | Macros |
| macro transformer | SC Transformer Definition |
| macro transformer | Explicit Renaming |
| macro use | Macros |
| magnitude, of real number | Numerical operations |
| manifest types (defn) | Overview |
| mapping, of list | Mapping of Lists |
| mapping, of stream | Streams |
| mapping, of vector | Construction of Vectors |
| Matcher language | *Matcher |
| Matcher procedure | *Matcher |
| matching, of strings | Searching and Matching Strings |
| maximum, of numbers | Numerical operations |
| memoization, of promise | Promises |
| merging, of pathnames | Operations on Pathnames |
| meta, bucky bit prefix (defn) | Characters |
| minimum, of numbers | Numerical operations |
| modification time, of file | File Manipulation |
| modification, of bit string | Modification of Bit Strings |
| modification, of vector | Modifying Vectors |
| modulus, of hashing procedure | Construction of Hash Tables |
| modulus, of integers | Numerical operations |
| moving, of bit string elements | Modification of Bit Strings |
| moving, of vector elements | Modifying Vectors |
| multiple values, from procedure | Continuations |
| multiplication, of numbers | Numerical operations |
| must be, notational convention | Errors |
| mutable | Storage Model |
| mutable string | Strings |
| mutation procedure (defn) | Naming Conventions |
|
N |
| name, of file | File Manipulation |
| name, of symbol | Symbols |
| name, of value (defn) | Variable Bindings |
| name, pathname component | Components of Pathnames |
| named lambda (defn) | Lambda Expressions |
| named let (defn) | Iteration |
| names, XML | XML Names |
| naming conventions | Naming Conventions |
| NaN | Flonum Operations |
| negative infinity (-inf.0 ) | Flonum Operations |
| negative number | Numerical operations |
| nesting, of quasiquote expressions | Quoting |
| newest, as pathname component | Components of Pathnames |
| NFC | Strings |
| NFD | Strings |
| non-local exit | Continuations |
| normal floating-point number | Flonum Operations |
| Normalization Form C (NFC) | Strings |
| Normalization Form D (NFD) | Strings |
| not a number (NaN, +nan.0 ) | Flonum Operations |
| notation, dotted (defn) | Lists |
| notational conventions | Notational Conventions |
| notification port, current (defn) | Ports |
| null string, predicate for | Strings |
| number | Numbers |
| number, external representation | Syntax of numerical constants |
| number, pseudorandom generation | Random Number Generation |
| numeric precision, inexact | Syntax of numerical constants |
| numerical input and output | Numerical input and output |
| numerical operations | Numerical operations |
| numerical types | Numerical types |
|
O |
| object hashing | Object Hashing |
| odd number | Numerical operations |
| oldest, as pathname component | Components of Pathnames |
| one-dimensional table (defn) | 1D Tables |
| operand, of procedure call (defn) | Procedure Call Syntax |
| Operating-System Interface | Operating-System Interface |
| operator, of procedure call (defn) | Procedure Call Syntax |
| option, run-time-loadable | Format |
| option, run-time-loadable | Parser Language |
| option, run-time-loadable | XML Support |
| optional component, in entries | Entry Format |
| optional parameter (defn) | Lambda Expressions |
| order, of argument evaluation | Procedure Call Syntax |
| ordered comparison | Flonum Operations |
| ordering, of characters | Characters |
| ordering, of numbers | Numerical operations |
| output | Input/Output |
| output form | SC Transformer Definition |
| output port (defn) | Ports |
| output port, bytevector | Bytevector Ports |
| output port, console | Ports |
| output port, current (defn) | Ports |
| output port, file | File Ports |
| output port, string | String Ports |
| output procedures | Output Procedures |
| output, XML | XML Output |
| overflow exception | Floating-Point Exceptions |
|
P |
| padder procedure | Strings |
| padding, of string | Strings |
| pair (defn) | Lists |
| pair, external representation | Lists |
| pair, weak (defn) | Weak Pairs |
| parameter list, of lambda (defn) | Lambda Expressions |
| parameter, dynamic (defn) | Parameters |
| parameter, entry category | Entry Format |
| parameter, optional (defn) | Lambda Expressions |
| parameter, required (defn) | Lambda Expressions |
| parameter, rest (defn) | Lambda Expressions |
| parent, of directory | Components of Pathnames |
| parent, of environment (defn) | Environment Concepts |
| parenthesis, as external representation | Lists |
| parenthesis, as external representation | Vectors |
| Parser buffer | Parser Buffers |
| Parser language | Parser Language |
| Parser language | *Parser |
| Parser procedure | *Parser |
| Parser-buffer pointer | Parser Buffers |
| parser, XML | XML Input |
| parsing, of external representation | Input Procedures |
| pasting, of bit strings | Cutting and Pasting Bit Strings |
| pasting, of lists | Cutting and Pasting Lists |
| pasting, of symbols | Symbols |
| path, directory (defn) | Components of Pathnames |
| pathname | Operating-System Interface |
| pathname (defn) | Pathnames |
| pathname components | Components of Pathnames |
| pathname, absolute (defn) | Working Directory |
| pathname, relative (defn) | Working Directory |
| period, as external representation | Lists |
| physical size, of hash table (defn) | Resizing of Hash Tables |
| pop count | Bit operations |
| port | Input/Output |
| port (defn) | Ports |
| port number, TCP | TCP Sockets |
| port, bytevector | Bytevector Ports |
| port, console | Ports |
| port, current | Ports |
| port, file | File Ports |
| port, string | String Ports |
| positive infinity (+inf.0 ) | Flonum Operations |
| positive number | Numerical operations |
| precision, of inexact number | Syntax of numerical constants |
| predicate (defn) | Naming Conventions |
| predicate (defn) | Equivalence Predicates |
| predicate, equivalence (defn) | Equivalence Predicates |
| prefix, of string | Searching and Matching Strings |
| prefix, of XML name | XML Names |
| pretty printer | Output Procedures |
| primitive procedure (defn) | Procedures |
| primitive, procedure type | Procedures |
| print name, of symbol | Symbols |
| printed output, in examples | Examples |
| procedure | Procedures |
| procedure call (defn) | Procedure Call Syntax |
| procedure define (defn) | Definitions |
| procedure, closing environment (defn) | Lambda Expressions |
| procedure, compiled | Procedures |
| procedure, compound | Procedures |
| procedure, construction | Lambda Expressions |
| procedure, entry format | Entry Format |
| procedure, escape (defn) | Continuations |
| procedure, interpreted | Procedures |
| procedure, invocation environment (defn) | Lambda Expressions |
| procedure, of application hook | Application Hooks |
| procedure, primitive | Procedures |
| procedure, type | Procedures |
| product, of numbers | Numerical operations |
| promise (defn) | Promises |
| promise, construction | Promises |
| promise, forcing | Promises |
| prompting | Prompting |
| proper tail recursion (defn) | Overview |
| property list | Associations |
| property list | 1D Tables |
| property list | The Association Table |
| property list, of symbol | Symbols |
| protocol, restart (defn) | Restarts |
| pseudorandom number generation | Random Number Generation |
|
Q |
| qname, of XML name | XML Names |
| quiet NaN | Flonum Operations |
| quiet NaN | Floating-Point Exceptions |
| quote, as external representation | Quoting |
| quotient, of integers | Numerical operations |
| quotient, of numbers | Numerical operations |
| quoting | Quoting |
|
R |
| R7RS | Overview |
| random number generation | Random Number Generation |
| rational, simplest (defn) | Numerical operations |
| raw mode, of terminal port | Terminal Mode |
| record-type descriptor (defn) | Records |
| recursion (see tail recursion) | Overview |
| red-black binary trees | Red-Black Trees |
| reference barrier | Reference barriers |
| reference, strong (defn) | Weak References |
| reference, variable (defn) | Variable References |
| reference, weak (defn) | Weak References |
| referentially transparent | Macros |
| region of variable binding, do | Iteration |
| region of variable binding, internal definition | Internal Definitions |
| region of variable binding, lambda | Lambda Expressions |
| region of variable binding, let | Lexical Binding |
| region of variable binding, let* | Lexical Binding |
| region of variable binding, letrec | Lexical Binding |
| region, of variable binding (defn) | Static Scoping |
| regular file, predicate for | File Manipulation |
| rehash size, of hash table (defn) | Resizing of Hash Tables |
| rehash threshold, of hash table (defn) | Resizing of Hash Tables |
| relative pathname (defn) | Working Directory |
| remainder, of integers | Numerical operations |
| renaming procedure | Explicit Renaming |
| renaming, of file | File Manipulation |
| REP loop | Condition Signalling |
| REP loop | Condition Signalling |
| REP loop | Condition Handling |
| REP loop | Condition Handling |
| REP loop | Condition Handling |
| REP loop | Condition Handling |
| REP loop | Invoking Standard Restart Code |
| REP loop (defn) | Initial and Current Environments |
| REP loop, environment of | Initial and Current Environments |
| representation, external (defn) | External Representations |
| required parameter (defn) | Lambda Expressions |
| resizing, of hash table | Resizing of Hash Tables |
| resources, X graphics | X Graphics Type |
| rest parameter (defn) | Lambda Expressions |
| restart (defn) | Restarts |
| restart effector (defn) | Restarts |
| restart protocol | Restarts |
| restarts, bound | Generating Operations on Conditions |
| restarts, bound | Simple Condition Instance Operations |
| result of evaluation, in examples | Examples |
| result, unspecified (defn) | Examples |
| reversal, of list | Miscellaneous List Operations |
| ringing the console bell | Output Procedures |
| root, as pathname component | Components of Pathnames |
| run-time-loadable option | Format |
| run-time-loadable option | Parser Language |
| run-time-loadable option | XML Support |
| runtime system | Overview |
|
S |
| s-expression | Environment Operations |
| s, as exponent marker in number | Syntax of numerical constants |
| scalar value | Unicode |
| scheme concepts | Scheme Concepts |
| Scheme standard | Overview |
| scope (see region) | Overview |
| scoping, lexical (defn) | Static Scoping |
| scoping, static | Static Scoping |
| screen, clearing | Output Procedures |
| searching, of alist | Association Lists |
| searching, of bit string | Selecting Bit String Components |
| searching, of list | Searching Lists |
| searching, of string | Searching and Matching Strings |
| searching, of vector | Selecting Vector Components |
| selecting, of stream component | Streams |
| selection, components of pathname | Operations on Pathnames |
| selection, of bit string component | Selecting Bit String Components |
| selection, of cell component | Parameters |
| selection, of character component | Character implementation |
| selection, of ephemeron component | Ephemerons |
| selection, of list component | Selecting List Components |
| selection, of pair component | Pairs |
| selection, of vector component | Selecting Vector Components |
| selection, of weak pair component | Weak Pairs |
| semicolon, as external representation | Comments |
| sensitivity, to case in programs (defn) | Uppercase and Lowercase |
| sequencing expressions | Sequencing |
| server socket | TCP Sockets |
| server socket | TCP Sockets |
| service, TCP | TCP Sockets |
| set, of characters | Character Sets |
| sets, using binary trees | Weight-Balanced Trees |
| shadowing, of variable binding (defn) | Environment Concepts |
| short precision, of inexact number | Syntax of numerical constants |
| sign bit, of number | Numerical operations |
| signal an error (defn) | Errors |
| signalling NaN | Flonum Operations |
| signalling NaN | Floating-Point Exceptions |
| signalling, of condition (defn) | Condition Signalling |
| signed zero | Flonum Operations |
| simplest rational (defn) | Numerical operations |
| simplification, of pathname | Filenames and Pathnames |
| single precision, of inexact number | Syntax of numerical constants |
| size, of hash table (defn) | Resizing of Hash Tables |
| slice, of string | Strings |
| socket | TCP Sockets |
| soft linking, of file | File Manipulation |
| special characters, in programs | Additional Notations |
| special form | Special Forms |
| special form (defn) | Special Form Syntax |
| special form, entry category | Entry Format |
| specialization, of condition types | Error System |
| specialization, of condition types | Condition Signalling |
| specialization, of condition types | Generating Operations on Conditions |
| specialization, of condition types | Generating Operations on Conditions |
| specialization, of condition types | Condition State |
| specialization, of condition types | Condition Types |
| specialization, of condition types (defn) | Error System |
| specified result, in examples | Examples |
| splitter procedure | Strings |
| splitting, of string | Strings |
| SRFI 0 | cond-expand (SRFI 0) |
| SRFI 2 | and-let* (SRFI 2) |
| SRFI 8 | receive (SRFI 8) |
| SRFI 9 | define-record-type (SRFI 9) |
| SRFI syntax | SRFI syntax |
| standard operations, on textual port | Textual Port Primitives |
| standard Scheme (defn) | Overview |
| start, of subvector (defn) | Vectors |
| static scoping | Static Scoping |
| static scoping (defn) | Overview |
| static types (defn) | Overview |
| stream (defn) | Streams |
| stream, converting to list | Streams |
| string builder procedure | Strings |
| string index (defn) | Strings |
| string length (defn) | Strings |
| string slice | Strings |
| string, character (defn) | Strings |
| string, input and output ports | String Ports |
| string, input from port | Input Procedures |
| string, input from textual port | Textual Input Port Operations |
| string, interning as symbol | Symbols |
| string, of bits (defn) | Bit Strings |
| string, searching string for | Searching and Matching Strings |
| strong reference (defn) | Weak References |
| strong types (defn) | Overview |
| strongly held data, of hash table | Construction of Hash Tables |
| strongly held keys, of hash table | Construction of Hash Tables |
| subnormal floating-point number | Flonum Operations |
| subnormal-operand exception | Floating-Point Exceptions |
| subprocess | Subprocesses |
| substring, of bit string | Cutting and Pasting Bit Strings |
| substring, output to textual port | Textual Output Port Operations |
| subtraction, of numbers | Numerical operations |
| subvector (defn) | Vectors |
| suffix, of string | Searching and Matching Strings |
| sum, of numbers | Numerical operations |
| super, bucky bit prefix (defn) | Characters |
| symbol (defn) | Symbols |
| symbolic link, predicate for | File Manipulation |
| symbolic linking, of file | File Manipulation |
| synchronous subprocess | Subprocesses |
| syntactic closure | Syntax Terminology |
| syntactic closures | Syntactic Closures |
| syntactic environment | Syntax Terminology |
| syntactic keyword | Procedure Call Syntax |
| syntactic keyword | Macros |
| syntactic keyword (defn) | Special Form Syntax |
| syntactic keyword binding | Environment Operations |
| syntactic keyword, identifier as | Identifiers |
| synthetic identifier | Syntax Terminology |
|
T |
| table, association (defn) | The Association Table |
| table, one-dimensional (defn) | 1D Tables |
| tail recursion (defn) | Overview |
| tail recursion, vs. iteration expression | Iteration |
| taxonomical link, of condition type (defn) | Error System |
| terminal mode, of port | Terminal Mode |
| terminal screen, clearing | Output Procedures |
| tetrachotomy | Flonum Operations |
| textual input port operations | Textual Input Port Operations |
| textual output port operations | Textual Output Port Operations |
| textual port (defn) | Ports |
| textual port primitives | Textual Port Primitives |
| textual port type | Textual Port Primitives |
| tick | Machine Time |
| time, decoded | Date and Time |
| time, file | Date and Time |
| time, string | Date and Time |
| time, universal | Date and Time |
| token, in programs (defn) | Whitespace |
| top-level definition | Top-Level Definitions |
| top-level definition (defn) | Definitions |
| top-level environment | Top-level Environments |
| total ordering (defn) | Miscellaneous List Operations |
| tracing output port, current (defn) | Ports |
| transformer environment | SC Transformer Definition |
| tree, copying | Pairs |
| trees, balanced binary | Red-Black Trees |
| trees, balanced binary | Weight-Balanced Trees |
| trichotomy | Flonum Operations |
| trimmer procedure | Strings |
| trimming, of string | Strings |
| true, boolean object | True and False |
| true, boolean object (defn) | Booleans |
| true, in conditional expression (defn) | Conditionals |
| truename, of input file | File Manipulation |
| type predicate, for 1D table | 1D Tables |
| type predicate, for alist | Association Lists |
| type predicate, for apply hook | Application Hooks |
| type predicate, for bit string | Selecting Bit String Components |
| type predicate, for boolean | Booleans |
| type predicate, for cell | Parameters |
| type predicate, for character | Characters |
| type predicate, for character set | Character Sets |
| type predicate, for compiled procedure | Procedure Operations |
| type predicate, for compound procedure | Procedure Operations |
| type predicate, for continuation | Continuations |
| type predicate, for empty list | Selecting List Components |
| type predicate, for entity | Application Hooks |
| type predicate, for environment | Environment Operations |
| type predicate, for EOF object | Input Procedures |
| type predicate, for ephemeron | Ephemerons |
| type predicate, for fixnum | Fixnum Operations |
| type predicate, for flonum | Flonum Operations |
| type predicate, for hash table | Basic Hash Table Operations |
| type predicate, for list | Selecting List Components |
| type predicate, for number | Numerical operations |
| type predicate, for pair | Pairs |
| type predicate, for pathname | Operations on Pathnames |
| type predicate, for pathname host | Miscellaneous Pathnames |
| type predicate, for port | Ports |
| type predicate, for primitive procedure | Procedure Operations |
| type predicate, for procedure | Procedure Operations |
| type predicate, for promise | Promises |
| type predicate, for record | Records |
| type predicate, for record type | Records |
| type predicate, for stream pair | Streams |
| type predicate, for symbol | Symbols |
| type predicate, for top-level environment | Top-level Environments |
| type predicate, for vector | Selecting Vector Components |
| type predicate, for weak pair | Weak Pairs |
| type, condition | Error System |
| type, of condition | Condition Types |
| type, of procedure | Procedures |
| type, pathname component | Components of Pathnames |
| types, latent (defn) | Overview |
| types, manifest (defn) | Overview |
|
U |
| unassigned binding | Environment Operations |
| unassigned variable | Variable References |
| unassigned variable (defn) | Variable Bindings |
| unassigned variable, and assignment | Assignments |
| unassigned variable, and definition | Top-Level Definitions |
| unassigned variable, and dynamic bindings | Dynamic Binding |
| unassigned variable, and named let | Iteration |
| unbound variable | Variable References |
| unbound variable (defn) | Environment Concepts |
| underflow exception | Floating-Point Exceptions |
| Unicode | Unicode |
| Unicode code point | Unicode |
| Unicode normalization forms | Strings |
| Unicode scalar value | Unicode |
| Uniform Resource Identifier | XML Names |
| uninterned symbol (defn) | Symbols |
| universal time | Date and Time |
| unordered comparison | Flonum Operations |
| unspecified result (defn) | Examples |
| up, as pathname component | Components of Pathnames |
| uppercase | Uppercase and Lowercase |
| uppercase, character conversion | Characters |
| URI, of XML name | XML Names |
| usable size, of hash table (defn) | Resizing of Hash Tables |
| usage environment | SC Transformer Definition |
|
V |
| V as format parameter | Format |
| valid index, of bit string (defn) | Bit Strings |
| valid index, of list (defn) | Selecting List Components |
| valid index, of string (defn) | Strings |
| valid index, of subvector (defn) | Vectors |
| valid index, of vector (defn) | Vectors |
| value, of variable (defn) | Variable Bindings |
| values, multiple | Continuations |
| variable binding | Variable Bindings |
| variable binding | Environment Operations |
| variable binding, do | Iteration |
| variable binding, fluid-let | Dynamic Binding |
| variable binding, internal definition | Internal Definitions |
| variable binding, lambda | Lambda Expressions |
| variable binding, let | Lexical Binding |
| variable binding, let* | Lexical Binding |
| variable binding, letrec | Lexical Binding |
| variable binding, top-level definition | Top-Level Definitions |
| variable reference (defn) | Variable References |
| variable, adding to environment | Definitions |
| variable, assigning values to | Assignments |
| variable, binding region (defn) | Static Scoping |
| variable, entry category | Entry Format |
| variable, identifier as | Identifiers |
| vector (defn) | Vectors |
| vector index (defn) | Vectors |
| vector length (defn) | Vectors |
| vector, converting to list | Construction of Lists |
| version, pathname component | Components of Pathnames |
| virtual coordinates, graphics (defn) | Coordinates for Graphics |
|
W |
| weak pair (defn) | Weak Pairs |
| weak pair, and 1D table | 1D Tables |
| weak reference (defn) | Weak References |
| weak types (defn) | Overview |
| weakly held data, of hash table | Construction of Hash Tables |
| weakly held keys, of hash table | Construction of Hash Tables |
| weight-balanced binary trees | Weight-Balanced Trees |
| whitespace, in programs (defn) | Whitespace |
| working directory (see current working directory) | Working Directory |
|
X |
| X display, graphics | Utilities for X Graphics |
| X geometry string, graphics | Utilities for X Graphics |
| X graphics | X Graphics |
| X resources, graphics | X Graphics Type |
| X window system | X Graphics |
| XML input | XML Input |
| XML names | XML Names |
| XML output | XML Output |
| XML parser | XML Input |
|
Z |
| zero | Numerical operations |
| zero | Flonum Operations |
|