| 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 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 |
| 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 |
| 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 |
| 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 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 |
| 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 |
| 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 |
| 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 |
| 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 |
| naming conventions: | | Win32 API names and procedures |
| 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: | | 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 |
| 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 |
| 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 |
| 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 |
| 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 | | |
|---|
| R4RS: | | 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: | | 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 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 |
| 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 |
| 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 | | |
|---|
| 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 |
| zero: | | Flonum Operations |
|