|  | 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: |  | Custom Operations for Win32 Graphics | 
|  | bitmaps, graphics: |  | Images | 
|  | 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 | 
|  | circle, graphics: |  | Custom Operations for Win32 Graphics | 
|  | 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 | 
|  | color: |  | Custom Operations for Win32 Graphics | 
|  | 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 object (defn): |  | Lambda Expressions | 
|  | defaulting, of pathname: |  | Operations on Pathnames | 
|  | defaulting, of pathname: |  | Operations on Pathnames | 
|  | define, procedure (defn): |  | Definitions | 
|  | defining foreign procedures: |  | Windows Foreign Procedures | 
|  | defining foreign types: |  | Windows Types | 
|  | defining foreign types: |  | Windows Types | 
|  | 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 | 
|  | 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 | 
|  | division, of integers: |  | Numerical operations | 
|  | division, of numbers: |  | Numerical operations | 
|  | DLL, DIBUTILS.DLL: |  | Device Independent Bitmap Utilities | 
|  | DLL, exports: |  | Other parts of the DIB Utilities implementation | 
|  | DLL, GDI32.DLL: |  | Windows Foreign Procedures | 
|  | DLL, KERNEL32.DLL: |  | Windows Foreign Procedures | 
|  | DLL, loading: |  | Windows Foreign Procedures | 
|  | DLL, USER32.DLL: |  | Windows Foreign Procedures | 
|  | 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 | 
|  | ellipse, graphics: |  | Custom Operations for Win32 Graphics | 
|  | 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 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 | 
|  | 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 | 
|  | flonum (defn): |  | Flonum Operations | 
|  | flushing, of buffered output: |  | Output Procedures | 
|  | forcing, of promise: |  | Promises | 
|  | foreign type declarations: |  | Windows Types | 
|  | 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, circle: |  | Custom Operations for Win32 Graphics | 
|  | 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, ellipse: |  | Custom Operations for Win32 Graphics | 
|  | 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 | 
|  | 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 | 
|  | 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 | 
|  | limitations: |  | Win32 Package Overview | 
|  | limitations: |  | Foreign function interface | 
|  | 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 | 
|  | loading DLLs: |  | Windows Foreign Procedures | 
|  | local part, of XML name: |  | XML Names | 
|  | location: |  | Storage Model | 
|  | location, of variable: |  | Variable Bindings | 
|  | 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 | 
|  | naming conventions: |  | Win32 API names and procedures | 
|  | negative infinity ( -inf): |  | 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 | 
|  | Normalization Form C (NFC): |  | Strings | 
|  | Normalization Form D (NFD): |  | Strings | 
|  | not a number ( NaN): |  | 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, pseudo-random: |  | Random Numbers | 
|  | 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: |  | Red-Black Trees | 
|  | option, run-time-loadable: |  | Weight-Balanced Trees | 
|  | 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 | 
|  | 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 | 
| 
 | 
| 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 | 
|  | 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): |  | 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 | 
|  | printing graphics output: |  | Custom Operations for Win32 Graphics | 
|  | 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 | 
|  | pseudo-random number: |  | Random Numbers | 
| 
 | 
| Q |  |  | 
|---|
|  | qname, of XML name: |  | XML Names | 
|  | quote, as external representation: |  | Quoting | 
|  | quotient, of integers: |  | Numerical operations | 
|  | quotient, of numbers: |  | Numerical operations | 
|  | quoting: |  | Quoting | 
| 
 | 
| R |  |  | 
|---|
|  | R4RS: |  | Overview | 
|  | random number: |  | Random Numbers | 
|  | 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 | 
|  | reduction, of list: |  | Reduction of Lists | 
|  | 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: |  | Red-Black Trees | 
|  | run-time-loadable option: |  | Weight-Balanced Trees | 
|  | 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 | 
|  | signal an error (defn): |  | Errors | 
|  | signalling, of condition (defn): |  | Condition Signalling | 
|  | 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 | 
|  | 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 | 
|  | 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 | 
|  | 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 | 
|  | types, Windows: |  | Windows Types | 
| 
 | 
| 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 | 
|  | 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 | 
|  | 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 |  |  | 
|---|
|  | warning: |  | Foreign function interface | 
|  | 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 | 
|  | Win32 API names: |  | Win32 API names and procedures | 
|  | Win32 graphics: |  | Win32 Graphics | 
|  | Windows types: |  | Windows Types | 
|  | 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 | 
| 
 |