Concept index

Next: Binding index, Previous: References, Up: Top

=scheme48/: Filenames
abstract data types: Records
accessing file ports' channels: Channel ports
accessing structures: Module configuration language
amb operator: Library utilities
anonymous structures: Module configuration language
arrays: Library data structures
asynchronous channels: Rendezvous communication channels
asynchronous thread communication channels: Higher-level synchronization
atomic regions: Optimistic concurrency
auto-integrate optimizer: Module configuration language
backtrace: Debugging commands
backtracking: Library utilities
batch mode: Command processor switches
batch mode: Running Scheme48
binary data operation: Bitwise manipulation
binary search trees: Library data structures
binding multiple values: Library utilities
bitwise integer operations: Bitwise manipulation
block input and output: Ports
blocking I/O: POSIX file system access
buffered input and output: Buffered ports & handlers
buffered output forcing: Ports
buffered output forcing: Miscellaneous features
byte manipulation: Bitwise manipulation
C access to Scheme byte vectors: Accessing Scheme data from C
C access to Scheme fixnums: Accessing Scheme data from C
C access to Scheme pairs: Accessing Scheme data from C
C access to Scheme strings: Accessing Scheme data from C
C access to Scheme vectors: Accessing Scheme data from C
C and Scheme data conversion: Accessing Scheme data from C
C dynamic loading: Dynamic loading of C modules
C macros for Scheme constants: Accessing Scheme data from C
C macros on Scheme booleans: Accessing Scheme data from C
C naming conventions: C interface
C predicates for Scheme data: Accessing Scheme data from C
C shared objects: Dynamic loading of C modules
callbacks from C and continuations: Calling Scheme procedures from C
callbacks from C and threads: Calling Scheme procedures from C
channel utilities, higher-level: Channels
channels: Rendezvous communication channels
channels: Channels
character sink output ports: I/O extensions
character source input ports: I/O extensions
closing channels: Channels
closure flattening: Module configuration language
closures in Pre-Scheme: Differences between Pre-Scheme & Scheme
code reloading: Module commands
code reloading: Using the module system
command levels: Command levels
command levels: Command processor switches
command processor help: Basic commands
command processor settings: Command processor switches
committing proposals: Optimistic concurrency
compile-time evaluation in Pre-Scheme: Differences between Pre-Scheme & Scheme
compiler optimization: Module configuration language
compound interfaces: Module configuration language
compound interfaces: Module system architecture
condition handlers: Condition system
condition messages: Condition system
condition restarting: Debugging commands
condition types: Condition system
conditions: Condition system
config package: Module commands
configuration language: Module configuration language
configuration language: Module system architecture
configuration language macros: Module configuration language
configuring the command processor: Command processor switches
continuation previews: Debugging commands
continuations and callbacks from C: Calling Scheme procedures from C
continuations in Pre-Scheme: Differences between Pre-Scheme & Scheme
creating directories: POSIX file system access
creating POSIX FIFOs: POSIX file system access
creating POSIX links: POSIX file system access
customized writer: Writer
debug data storage control: Resource statistics and control
defining record types: Records
deleting directories: POSIX file system access
deleting files: POSIX file system access
destructuring S-expressions: Library utilities
directory creation: POSIX file system access
directory deletion: POSIX file system access
directory listing: POSIX file system access
directory streams: POSIX file system access
disabling command levels: Command levels
disabling command levels: Command processor switches
disassembly: Debugging commands
displaying conditions: Condition system
displaying heap usage: Resource statistics and control
dumping heap images: Suspending and resuming heap images
dumping heap images: Image-building commands
dumping Scheme heap images with C data: Interacting with the Scheme heap in C
dynamic bindings: Fluid/dynamic bindings
environment flattening: Module configuration language
environment variables: POSIX process environment
error messages: Condition system
errors: Condition system
evaluation of top-level code in Pre-Scheme: Differences between Pre-Scheme & Scheme
event: Concurrent ML
exceptions: Condition system
exec language: Command programs
exec package: Command programs
executing processes: POSIX processes
execution timing: Resource statistics and control
exiting processes: POSIX processes
exiting Scheme: Basic commands
expanding macros: Debugging commands
exporting bindings from C to Scheme: Shared bindings between Scheme and C
exporting bindings from Scheme to C: Shared bindings between Scheme and C
exporting C functions to Scheme: Shared bindings between Scheme and C
fcntl: POSIX I/O utilities
fd-port dup'ing: POSIX I/O utilities
fd-port I/O flags: POSIX I/O utilities
fd-ports: POSIX I/O utilities
FIFOs: Queues
file access probing: POSIX file system access
file channels: Channels
file deletion: POSIX file system access
file descriptor ports: POSIX I/O utilities
file descriptor reassignment: POSIX I/O utilities
file info: POSIX file system access
file permissions: POSIX file system access
filename translations: Filenames
flat closures: Module configuration language
flat environments: Module configuration language
flat-environments optimizer: Module configuration language
fluid bindings: Fluid/dynamic bindings
flushing output buffers: Ports
flushing output buffers: Miscellaneous features
for-syntax: Macros in concert with modules
forcing buffered output: Ports
forcing buffered output: Miscellaneous features
forcing garbage collection: Resource statistics and control
forking: POSIX processes
functors: Module system architecture
garbage collection in Pre-Scheme: Differences between Pre-Scheme & Scheme
garbage collection, forcing: Resource statistics and control
GC protection in C: Interacting with the Scheme heap in C
generic functions: Generic dispatch system
generic modules: Module system architecture
generic predicate dispatch: Generic dispatch system
graph algorithms: Library utilities
group ids: POSIX users and groups
group ids: POSIX process environment
growing vectors: Library data structures
heap image dumping: Suspending and resuming heap images
heap image dumping: Image-building commands
heap image resumption: Suspending and resuming heap images
heap image resumption: Running Scheme48
heap image writing: Suspending and resuming heap images
heap image writing: Image-building commands
heap size: Running Scheme48
heap space analysis: Resource statistics and control
heap traversal: Resource statistics and control
help: Basic commands
higher-level channel utilities: Channels
higher-order modules: Module system architecture
hygiene of macros in modules: Macros in concert with modules
I/O flags: POSIX I/O utilities
image dumping: Suspending and resuming heap images
image dumping: Image-building commands
image writing: Suspending and resuming heap images
image writing: Image-building commands
immutability: Miscellaneous features
importing bindings into C from Scheme: Shared bindings between Scheme and C
importing bindings into Scheme from C: Shared bindings between Scheme and C
importing C functions to Scheme: Calling C functions from Scheme
in-line procedures: Module configuration language
input and output of blocks: Ports
input ports from strings: I/O extensions
installing condition handlers: Condition system
installing proposals: Optimistic concurrency
integrated procedures: Module configuration language
interaction between continuations and C: Calling Scheme procedures from C
interface abstraction: Module system architecture
interface definition forms: Module configuration language
interface reüse: Module system architecture
interfaces: Module system architecture
interfaces: Using the module system
join types: Static type system
limiting output: I/O extensions
line- & column-tracking ports: I/O extensions
listing directories: POSIX file system access
locks for mutual exclusion: Pessimistic concurrency
logging operations: Optimistic concurrency
logging operations: Port data type
logs: Optimistic concurrency
loopholes in the type system: Type annotations
low-level access to records: Records
low-level macros: Explicit renaming macros
macro expansion: Debugging commands
macro hygiene in modules: Macros in concert with modules
macro referential transparency in modules: Macros in concert with modules
macros in the module configuration language: Module configuration language
macros, low-level: Explicit renaming macros
macros, unhygienic: Explicit renaming macros
making directories: POSIX file system access
marshalling: Library utilities
meet types: Static type system
memory management in Pre-Scheme: Low-level Pre-Scheme memory manipulation
memory management in Pre-Scheme: Compound Pre-Scheme data manipulation
memory management in Pre-Scheme: Differences between Pre-Scheme & Scheme
memory size: Running Scheme48
message-passing: Rendezvous communication channels
modified interfaces: Module configuration language
modified structures: Module configuration language
module language: Module configuration language
module language: Module system architecture
module language macros: Module configuration language
modules: Module system architecture
multimethod dispatch: Generic dispatch system
multiple value binding: Library utilities
mutability: Miscellaneous features
mutex locks: Pessimistic concurrency
mutual exclusion: Pessimistic concurrency
namelists: Filenames
networking: TCP & UDP sockets
noise output: Ports
noise output: Miscellaneous features
nonblocking I/O: POSIX file system access
nondeterminism: Library utilities
numbers in Pre-Scheme: Differences between Pre-Scheme & Scheme
object dumping: Library utilities
object reference analysis: Resource statistics and control
opaque data types: Records
opening structures: Module configuration language
opening structures: Module system architecture
opening structures: Module commands
optimistic concurrency logging operations: Optimistic concurrency
optimistic concurrency logging operations: Port data type
optimistic concurrency logs: Optimistic concurrency
optimistic concurrency proposals: Optimistic concurrency
optimistically concurrent record types: Optimistic concurrency
optimizer: Module configuration language
output port buffer forcing: Ports
output port buffer forcing: Miscellaneous features
output ports to strings: I/O extensions
package clauses: Module configuration language
packages: Module system architecture
parameterized modules: Module system architecture
parametric polymorphism: Static type system
phase separation: Macros in concert with modules
pipe I/O: POSIX I/O utilities
port to channel conversion: Channel ports
ports that track line & column numbers: I/O extensions
ports with line & column numbers: I/O extensions
POSIX directory access: POSIX file system access
POSIX environment variables: POSIX process environment
POSIX exec: POSIX processes
POSIX fcntl: POSIX I/O utilities
POSIX FIFOs: POSIX file system access
POSIX file creation masks: POSIX file system access
POSIX file opening: POSIX file system access
POSIX file permissions: POSIX file system access
POSIX fork: POSIX processes
POSIX group ids: POSIX process environment
POSIX group info: POSIX users and groups
POSIX links: POSIX file system access
POSIX pipe I/O: POSIX I/O utilities
POSIX process exiting: POSIX processes
POSIX process ids: POSIX process environment
POSIX process ids: POSIX processes
POSIX process termination: POSIX processes
POSIX terminal ports: POSIX I/O utilities
POSIX user ids: POSIX process environment
POSIX user info: POSIX users and groups
POSIX working directory: POSIX file system access
Pre-Scheme closures: Differences between Pre-Scheme & Scheme
Pre-Scheme garbage collection: Differences between Pre-Scheme & Scheme
Pre-Scheme memory management: Low-level Pre-Scheme memory manipulation
Pre-Scheme memory management: Compound Pre-Scheme data manipulation
Pre-Scheme memory management: Differences between Pre-Scheme & Scheme
Pre-Scheme numbers: Differences between Pre-Scheme & Scheme
Pre-Scheme strings: Compound Pre-Scheme data manipulation
Pre-Scheme tail call optimization: Tail call optimization in Pre-Scheme
Pre-Scheme tail call optimization: Differences between Pre-Scheme & Scheme
Pre-Scheme top-level evaluation: Differences between Pre-Scheme & Scheme
Pre-Scheme type inference: Pre-Scheme type specifiers
Pre-Scheme type inference: Differences between Pre-Scheme & Scheme
Pre-Scheme vectors: Compound Pre-Scheme data manipulation
pretty-printing: Library utilities
previewing continuations: Debugging commands
printing: Library utilities
printing conditions: Condition system
procedure integration: Module configuration language
procedures, tracing: Debugging commands
proceeding from errors: Debugging commands
process forking: POSIX processes
process ids: POSIX process environment
process ids: POSIX processes
process termination: POSIX processes
programmatic record types: Records
proposals: Optimistic concurrency
proposals, committing: Optimistic concurrency
proposals, installing: Optimistic concurrency
quitting Scheme: Basic commands
real time: Library utilities
record resumers: Interacting with the Scheme heap in C
record types, defining: Records
record types, programmatic: Records
records, low-level access to: Records
referential transparency of macros in modules: Macros in concert with modules
reflective tower: Macros in concert with modules
reloading code: Module commands
reloading code: Using the module system
removing directories: POSIX file system access
removing files: POSIX file system access
renaming files: POSIX file system access
rendezvous: Concurrent ML
resizable vectors: Library data structures
restoring C data after resuming images: Interacting with the Scheme heap in C
resuming heap images: Suspending and resuming heap images
resuming heap images: Running Scheme48
resuming suspended threads: Custom thread synchronization
returning from errors: Debugging commands
run time: Library utilities
S-expression destructuring: Library utilities
Scheme and C data conversion: Accessing Scheme data from C
Scheme boolean testing in C: Accessing Scheme data from C
Scheme byte vector operations in C: Accessing Scheme data from C
Scheme callbacks in C: Calling Scheme procedures from C
Scheme constants in C: Accessing Scheme data from C
Scheme data predicates in C: Accessing Scheme data from C
Scheme fixnums from C: Accessing Scheme data from C
Scheme pair operations in C: Accessing Scheme data from C
Scheme string operations in C: Accessing Scheme data from C
Scheme vector operations in C: Accessing Scheme data from C
scheme48.h: Accessing Scheme data from C
separate compilation: Macros in concert with modules
serialization: Library utilities
sharing data between Scheme and C: Shared bindings between Scheme and C
signal queues: POSIX signals
signalling conditions: Condition system
simple character sink output ports: I/O extensions
simple character source input ports: I/O extensions
simple interfaces: Module configuration language
sleeping threads: Basic thread operations
space usage analysis: Resource statistics and control
spawning threads: Basic thread operations
stack size: Running Scheme48
static type analysis: Static type system
static types in Pre-Scheme: Pre-Scheme type specifiers
static types in Pre-Scheme: Differences between Pre-Scheme & Scheme
storage control of debug data: Resource statistics and control
storage leak analysis: Resource statistics and control
storing C data in the Scheme heap: Interacting with the Scheme heap in C
string input ports: I/O extensions
string matching: POSIX regular expressions
string output ports: I/O extensions
string ports: I/O extensions
strings in Pre-Scheme: Compound Pre-Scheme data manipulation
strongly-connected graph components: Library utilities
structure definition forms: Module configuration language
structures: Module system architecture
structures, accessing: Module configuration language
structures, opening: Module configuration language
structures, opening: Module system architecture
structures, opening: Module commands
suspending threads: Custom thread synchronization
synchronous channels: Rendezvous communication channels
syntactic tower: Macros in concert with modules
syntax expansion: Debugging commands
tail call optimization in Pre-Scheme: Tail call optimization in Pre-Scheme
tail call optimization in Pre-Scheme: Differences between Pre-Scheme & Scheme
tail recursion in Pre-Scheme: Tail call optimization in Pre-Scheme
tail recursion in Pre-Scheme: Differences between Pre-Scheme & Scheme
terminal ports: POSIX I/O utilities
terminating threads: Basic thread operations
thread cells: Custom thread synchronization
thread communication channels, asynchronous: Higher-level synchronization
thread descriptors: Basic thread operations
thread queues: Custom thread synchronization
thread sleeping: Basic thread operations
thread termination: Basic thread operations
thread yielding: Basic thread operations
threads and callbacks from C: Calling Scheme procedures from C
threads, spawning: Basic thread operations
time: Library utilities
time: Rendezvous base combinators
timing execution: Resource statistics and control
top-level evaluation in Pre-Scheme: Differences between Pre-Scheme & Scheme
towers of evaluation phases: Macros in concert with modules
tracing: Debugging commands
transaction logs: Optimistic concurrency
type dispatch: Generic dispatch system
type inference: Static type system
type lattice: Static type system
type system loopholes: Type annotations
undefined imported bindings: Running Scheme48
unhygienic macros: Explicit renaming macros
unspecific: Various utilities
unspecified: Various utilities
user ids: POSIX users and groups
user ids: POSIX process environment
user package: Module commands
usual resumer: Suspending and resuming heap images
vectors in Pre-Scheme: Compound Pre-Scheme data manipulation
waiting for POSIX processes: POSIX processes
warnings: Condition system
working directory: POSIX file system access
writer, customized: Writer
writing heap images: Suspending and resuming heap images
writing heap images: Image-building commands
yielding threads: Basic thread operations