| Index Entry | Section |
|---|
|
| ! |
|---|
| ! in mutation procedure names: | Naming Conventions |
|
| " |
|---|
| " as external representation: | Strings |
|
| # |
|---|
| # as format parameter: | Format |
| # in external representation of number: | Syntax of numerical constants |
| #( as external representation: | Vectors |
| #* as external representation: | Bit Strings |
| #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: | Custom Output |
| #\ as external representation: | Characters |
| #| as external representation: | Comments |
|
| ' |
|---|
| ’ as external representation: | Quoting |
|
| ( |
|---|
| ( as external representation: | Lists |
|
| ) |
|---|
| ) as external representation: | Lists |
|
| , |
|---|
| , as external representation: | Quoting |
| ,@ as external representation: | Quoting |
|
| - |
|---|
| -ci, in string procedure name: | Strings |
| -| notational convention: | Examples |
|
| . |
|---|
| . as external representation: | Lists |
| ... in entries: | Entry Format |
|
| 1 |
|---|
| 1D table (defn): | 1D Tables |
|
| ; |
|---|
| ; as external representation: | Comments |
|
| = |
|---|
| => in cond clause: | Conditionals |
| => notational convention: | Examples |
|
| ? |
|---|
| ? in predicate names: | Naming Conventions |
|
| [ |
|---|
| [ in entries: | Entry Format |
|
| \ |
|---|
| \ as escape character in string: | Strings |
|
| ] |
|---|
| ] in entries: | Entry Format |
|
| ` |
|---|
| ‘ as external representation: | Quoting |
|
| 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, of interned symbol: | Symbols |
| alphabetic case-insensitivity of programs (defn): | Uppercase and Lowercase |
| 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, of interned symbol: | Symbols |
| case-insensitivity of programs (defn): | Uppercase and Lowercase |
| 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, of character (defn): | Character implementation |
| code-point list: | Character Sets |
| code-point range: | Character Sets |
| code-point range: | Character Sets |
| 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, in examples: | Examples |
| error, unassigned variable: | Variable Bindings |
| error, unbound variable (defn): | Environment Concepts |
| error–> notational convention: | Examples |
| 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, XML: | XML Input |
| Parser-buffer pointer: | Parser Buffers |
| 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, as exponent marker in number: | Syntax of numerical constants |
| s-expression: | Environment Operations |
| 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 |
|