Previous: , Up: Top   [Contents][Index]


Appendix C Concept Index

Jump to:   !   "   #   '   (   )   ,   -   .   1   ;   =   ?   [   \   ]   `  
A   B   C   D   E   F   G   H   I   J   K   L   M   N   O   P   Q   R   S   T   U   V   W   X   Z  
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: 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: 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

Jump to:   !   "   #   '   (   )   ,   -   .   1   ;   =   ?   [   \   ]   `  
A   B   C   D   E   F   G   H   I   J   K   L   M   N   O   P   Q   R   S   T   U   V   W   X   Z  

Previous: , Up: Top   [Contents][Index]