Appendix C Concept Index

• ! 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
• #[ as external representation: Custom Output
• #\ as external representation: External Representation of Characters
• #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: 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
• 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
• 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, of string: Alphabetic Case in Strings
• alphabetic case-insensitivity of programs (defn): Uppercase and Lowercase
• alphabetic character (defn): Character Sets
• alphanumeric character (defn): Character Sets
• 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 strings: Cutting and Pasting Strings
• 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: Internal Representation of Characters
• assignment: Assignments
• association list (defn): Association Lists
• association table (defn): The Association Table
• asterisk, as external representation: Bit Strings
• attribute, of file: File Manipulation
• 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
• bell, ringing on console: Output Procedures
• Big endian: Unicode Representations
• binary file ports: File 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 (or fluid): 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
• 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): Internal Representation of Characters
• bucky bit, prefix (defn): External Representation of Characters
• buffering, of graphics output: Buffering of Graphics Output
• buffering, of output: Output Procedures
• built-in procedure: Procedures
• byte vector: Byte Vectors
• call by need evaluation (defn): Promises
• capitalization, of string: Alphabetic Case in Strings
• car field, of pair (defn): Lists
• case clause: Conditionals
• case conversion, of character: Miscellaneous Character Operations
• case sensitivity, of string operations: Strings
• case, of interned symbol: Symbols
• case, of string: Alphabetic Case in Strings
• case-insensitivity of programs (defn): Uppercase and Lowercase
• cdr field, of pair (defn): Lists
• cell (defn): Cells
• character (defn): Characters
• character bits (defn): Internal Representation of Characters
• character code (defn): Internal Representation of Characters
• character set: Character Sets
• character, alphabetic (defn): Character Sets
• character, alphanumeric (defn): Character Sets
• character, graphic (defn): Character Sets
• character, input from port: Input Port Operations
• character, input from port: Input Procedures
• character, ISO-8859-1 (defn): ISO-8859-1 Characters
• character, named (defn): External Representation of Characters
• character, numeric (defn): Character Sets
• character, output to port: Output Procedures
• character, output to port: Output Port Operations
• character, searching string for: Searching Strings
• character, standard (defn): Character Sets
• Character, Unicode: Unicode
• character, whitespace (defn): Character Sets
• 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
• 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, of character (defn): Internal Representation of Characters
• 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: Comparison of Characters
• comparison, of numbers: Numerical operations
• comparison, of strings: Comparison of Strings
• comparison, of XML names: XML Names
• compiled, procedure type: Procedures
• component selection, of bit string: Selecting Bit String Components
• component selection, of cell: Cells
• component selection, of character: Internal Representation of Characters
• 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 string: Selecting String Components
• 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: Cells
• construction, of character: Internal Representation of Characters
• construction, of character set: Character Sets
• construction, of circular list: Miscellaneous List Operations
• construction, of continuation: Continuations
• construction, of EOF object: Constructors and Accessors for Ports
• construction, of ephemeron: Ephemerons
• construction, of file input port: File Ports
• construction, of file output port: File Ports
• 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: Components of Pathnames
• construction, of port type: Port Types
• construction, of procedure: Lambda Expressions
• construction, of promise: Promises
• construction, of stream: Streams
• construction, of string: Construction of Strings
• construction, of string input port: String Ports
• construction, of string output port: String Ports
• construction, of symbols: Symbols
• 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): External Representation of 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 string: Construction of Strings
• copying, of tree: Pairs
• copying, of vector: Construction of Vectors
• current environment: Top-level Environments
• current environment (defn): Initial and Current Environments
• current input port (defn): Ports
• current input port, rebinding: String Ports
• current input port, rebinding: File Ports
• current output port (defn): Ports
• current output port, rebinding: String Ports
• current output port, rebinding: File 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 port: Port Primitives
• cutting, of bit string: Cutting and Pasting Bit Strings
• cutting, of list: Cutting and Pasting Lists
• cutting, of string: Cutting and Pasting Strings
• cutting, of vector: Cutting Vectors
• 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
• define, procedure (defn): Definitions
• defining foreign procedures: Windows Foreign Procedures
• 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: Directory Reader
• directory, reading: Miscellaneous Pathnames
• discrete maps, using binary trees: Weight-Balanced Trees
• discretionary flushing, of buffered output: Output Procedures
• disembodied property list: Symbols
• dispatch tag: Dispatch Tags
• 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 mode, graphics (defn): Characteristics of Graphics Output
• dynamic binding: Condition Handling
• dynamic binding: Dynamic Binding
• dynamic binding: Condition Handling
• dynamic binding, and continuations: Dynamic Binding
• dynamic binding, versus static scoping: Static Scoping
• dynamic types (defn): Overview
• 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: Selecting String Components
• end of file object (see EOF object): Input Procedures
• end, of substring (defn): Strings
• end, of subvector (defn): Vectors
• Endianness: Unicode Representations
• 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: Constructors and Accessors for Ports
• 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: Comparison of 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, for strings: Comparison of Strings
• equivalence predicate, of hash table: Construction of Hash Tables
• equivalence predicates, for characters: Comparison of Characters
• error messages, conventions: Error Messages
• 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, output to port: Output Procedures
• 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 character: External Representation of Characters
• 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, generating: Output Procedures
• external representation, parsing: Input Procedures
• external representations, Unicode: Unicode Representations
• extra object, of application hook: Application Hooks
• 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 string: Modification of Strings
• filling, of vector: Modifying Vectors
• filtering, of list: Filtering Lists
• fixnum (defn): Fixnum Operations
• flonum (defn): Flonum Operations
• fluid binding: Condition Handling
• fluid binding: Dynamic Binding
• fluid binding: Condition Handling
• 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
• generalization, of condition types: Error System
• generalization, of condition types: Condition Types
• generalization, of condition types: Condition Signalling
• generalization, of condition types (defn): Error System
• generating, external representation: Output Procedures
• generic procedure: Generic Dispatch
• gensym (see uninterned symbol): Symbols
• geometry string, X graphics: Utilities for X Graphics
• graphic character (defn): Character Sets
• 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 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
• 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: Comparison of Strings
• hashing, of symbol: Symbols
• home directory, as pathname: Miscellaneous Pathnames
• hook, application (defn): Procedures
• Host endian: Unicode Representations
• host, in filename: Pathnames
• host, pathname component: Components of Pathnames
• hostname, TCP: TCP Sockets
• hygienic: Macros
• hyper, bucky bit prefix (defn): External Representation of Characters
• 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
• 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 operations: Input Port Operations
• 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
• interactive input ports (defn): Input Procedures
• internal definition: Internal Definitions
• internal definition (defn): Definitions
• internal representation, for character: Internal Representation of Characters
• 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
• ISO-8859-1 character (defn): ISO-8859-1 Characters
• iteration expression (defn): Iteration
• 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, 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: Variable-Length Strings
• 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
• 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 string: Construction of Strings
• 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
• Little endian: Unicode Representations
• 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: Miscellaneous Character Operations
• lowercase, in string: Alphabetic Case in Strings
• 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: Matching Strings
• maximum length, of string (defn): Variable-Length Strings
• maximum, of numbers: Numerical operations
• memoization, of promise: Promises
• merging, of pathnames: Operations on Pathnames
• meta, bucky bit prefix (defn): External Representation of Characters
• method, of generic procedure: Generic Procedures
• method, unparser (defn): Custom Output
• minimum, of numbers: Numerical operations
• modification time, of file: File Manipulation
• modification, of bit string: Modification of Bit Strings
• modification, of string: Modification of 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 string elements: Modification of 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
• mutation procedure (defn): Naming Conventions
• name, of character: External Representation of Characters
• 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: Win32 API names and procedures
• naming conventions: Naming Conventions
• negative infinity (-inf): Flonum Operations
• negative number: Numerical operations
• nesting, of quasiquote expressions: Quoting
• newest, as pathname component: Components of Pathnames
• newline character (defn): External Representation of Characters
• newline character, output to port: Output Procedures
• newline translation: File Ports
• non-local exit: Continuations
• not a number (NaN): Flonum Operations
• notation, dotted (defn): Lists
• notational conventions: Notational Conventions
• null string, predicate for: Selecting String Components
• number: Numbers
• number, external representation: Syntax of numerical constants
• number, pseudo-random: Random Numbers
• numeric character (defn): Character Sets
• numeric precision, inexact: Syntax of numerical constants
• numerical input and output: Numerical input and output
• numerical operations: Numerical operations
• numerical types: Numerical types
• 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: Parser Language
• option, run-time-loadable: Weight-Balanced Trees
• option, run-time-loadable: Format
• option, run-time-loadable: Red-Black Trees
• 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: Comparison of Characters
• ordering, of numbers: Numerical operations
• ordering, of strings: Comparison of Strings
• output: Input/Output
• output form: SC Transformer Definition
• output port operations: Output Port Operations
• 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
• padding, of string: Cutting and Pasting Strings
• pair (defn): Lists
• pair, external representation: Lists
• pair, weak (defn): Weak Pairs
• parameter list, of lambda (defn): Lambda Expressions
• 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: Vectors
• parenthesis, as external representation: Lists
• 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 strings: Cutting and Pasting Strings
• 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 primitives: Port Primitives
• port type: Port Primitives
• 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: 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, generic: Generic Dispatch
• 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: The Association Table
• property list: Associations
• property list: 1D Tables
• property list, of symbol: Symbols
• protocol, restart (defn): Restarts
• pseudo-random number: Random Numbers
• qname, of XML name: XML Names
• quote, as external representation: Quoting
• quotient, of integers: Numerical operations
• quotient, of numbers: Numerical operations
• quoting: Quoting
• 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, 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 expression, searching string for: Regular-expression procedures
• 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 Handling
• REP loop: Condition Signalling
• REP loop: Condition Handling
• REP loop: Condition Signalling
• REP loop: Invoking Standard Restart Code
• REP loop (defn): Initial and Current Environments
• REP loop, environment of: Initial and Current Environments
• replacement, of string component: Modification of Strings
• 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: Simple Condition Instance Operations
• restarts, bound: Generating Operations on Conditions
• result of evaluation, in examples: Examples
• result, unspecified (defn): Examples
• reversal, of list: Miscellaneous List Operations
• REXP abstraction: REXP abstraction
• ringing the console bell: Output Procedures
• root, as pathname component: Components of Pathnames
• run-time-loadable option: Parser Language
• run-time-loadable option: XML Support
• run-time-loadable option: Weight-Balanced Trees
• run-time-loadable option: Format
• run-time-loadable option: Red-Black Trees
• runtime system: Overview
• s, as exponent marker in number: Syntax of numerical constants
• s-expression: Environment Operations
• Scalar value, Unicode: 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, for regular expression: Regular-expression procedures
• searching, of alist: Association Lists
• searching, of bit string: Selecting Bit String Components
• searching, of list: Searching Lists
• searching, of string: Searching 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: Cells
• selection, of character component: Internal Representation of Characters
• selection, of ephemeron component: Ephemerons
• selection, of list component: Selecting List Components
• selection, of pair component: Pairs
• selection, of string component: Selecting String Components
• 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
• 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
• 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: Condition State
• specialization, of condition types: Condition Types
• specialization, of condition types: Generating Operations on Conditions
• specialization, of condition types: Error System
• specialization, of condition types: Condition Signalling
• specialization, of condition types: Generating Operations on Conditions
• specialization, of condition types (defn): Error System
• specified result, in examples: Examples
• 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 character (defn): Character Sets
• standard operations, on port: Port Primitives
• standard ports: Ports
• standard Scheme (defn): Overview
• start, of substring (defn): Strings
• 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 index (defn): Strings
• string length (defn): Strings
• string, character (defn): Strings
• string, converting to input port: String Ports
• string, converting to list: Construction of Lists
• string, input and output ports: String Ports
• string, input from port: Input Port Operations
• string, input from port: Input Procedures
• string, interning as symbol: Symbols
• string, of bits (defn): Bit Strings
• string, output to port: Output Procedures
• String, wide: Wide 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 (defn): Strings
• substring, of bit string: Cutting and Pasting Bit Strings
• substring, output to port: Output Port Operations
• substring, searching string for: Searching Strings
• subtraction, of numbers: Numerical operations
• subvector (defn): Vectors
• suffix, of string: Matching Strings
• sum, of numbers: Numerical operations
• super, bucky bit prefix (defn): External Representation of 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: Macros
• syntactic keyword: Procedure Call Syntax
• syntactic keyword (defn): Special Form Syntax
• syntactic keyword binding: Environment Operations
• syntactic keyword, identifier as: Identifiers
• synthetic identifier: Syntax Terminology
• table, association (defn): The Association Table
• table, one-dimensional (defn): 1D Tables
• tag, dispatch: Dispatch Tags
• 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
• 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
• transformer environment: SC Transformer Definition
• tree, copying: Pairs
• trees, balanced binary: Weight-Balanced Trees
• trees, balanced binary: Red-Black Trees
• trimming, of string: Cutting and Pasting 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: Cells
• type predicate, for character: Miscellaneous Character Operations
• 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 string: Selecting String Components
• 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
• 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 character: Unicode
• Unicode external representations: Unicode Representations
• Uniform Resource Identifier: XML Names
• uninterned symbol (defn): Symbols
• universal time: Date and Time
• unparser method (defn): Custom Output
• unspecified result (defn): Examples
• up, as pathname component: Components of Pathnames
• uppercase: Uppercase and Lowercase
• uppercase, character conversion: Miscellaneous Character Operations
• uppercase, in string: Alphabetic Case in Strings
• URI, of XML name: XML Names
• usable size, of hash table (defn): Resizing of Hash Tables
• usage environment: SC Transformer Definition
• UTF-16: Unicode Representations
• UTF-32: Unicode Representations
• UTF-8: Unicode Representations
• 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, byte: Byte Vectors
• vector, converting to list: Construction of Lists
• version, pathname component: Components of Pathnames
• virtual coordinates, graphics (defn): Coordinates for Graphics
• 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 character (defn): Character Sets
• whitespace, in programs (defn): Whitespace
• Wide string: Wide Strings
• 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 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
• zero: Numerical operations