Version: 4.2.1

Index

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

 

#!
3m
A Customer Manager Component for Managing Customer Relationships
A Dictionary
A First Contract Violation
A Note to Readers with Scheme/Lisp Experience
A Parameteric (Simple) Stack
A Queue
A Subtle Contract Violation
Abbreviating quote with
aborts
accessor
Adding Contracts to Signatures
Adding Contracts to Units
Alternation
An Aside on Indenting Code
An Extended Example
Anonymous Functions with lambda
Arity-Sensitive Functions: case-lambda
Arrows
assertions
Assignment and Redefinition
Assignment: set!
attached
backreference
Backreferences
Backtracking
backtracking
Basic Assertions
Booleans
box
Boxes
bracketed character class
Built-In Datatypes
byte
byte string
Bytes and Byte Strings
Bytes, Characters, and Encodings
call-by-reference
Certificate Propagation
CGC
Chaining Tests: cond
character
character class
Characters
Characters and Character Classes
Checking Properties of Data Structures
Classes and Objects
cloister
Cloisters
closures
Clustering
Clusters
collections
Combining Tests: and and or
Compilation and Configuration
Compile and Run-Time Phases
complex
components
composable continuations
Conditionals
Conditionals with if, and, or, and cond
conservative garbage collector
constructor
constructor guard
continuation
Continuations
Contract Error Messages that Contain “???”
Contracts
Contracts and Boundaries
Contracts and eq?
Contracts Coerced from Other Values
Contracts for case-lambda
Contracts for Units
Contracts on Functions in General
Contracts on Higher-order Functions
Contracts on Structures
Controlling the Scope of External Names
Copying and Update
Creating and Installing Namespaces
Creating Executables
Creating Stand-Alone Executables
current continuation
current namespace
Curried Function Shorthand
Datatypes and Serialization
Declaring a Rest Argument
Declaring Keyword Arguments
Declaring Optional Arguments
Default Ports
default prompt tag
define-syntax and syntax-rules
define-syntax-rule
Defining recursive contracts
Definitions
Definitions and Interactions
definitions area
Definitions: define
delimited continuations
destructing bind
Dialects of Scheme
Dynamic Binding: parameterize
Effects After: begin0
Effects Before: begin
Effects If...: when and unless
Ensuring that a Function Properly Modifies State
Ensuring that All Structs are Well-Formed
eval
Evaluation Order and Arity
Examples
exception
Exceptions
Exceptions and Control
expands
Experimenting with examples
Exports: provide
Expressions and Definitions
Extended Example: Call-by-Reference Functions
Final, Augment, and Inner
First-Class Units
fixnum
Fixnum and Flonum Optimizations
flat named contracts
flonum
for and for*
for/and and for/or
for/first and for/last
for/fold and for*/fold
for/list and for*/list
Function Calls (Procedure Applications)
Function Calls (Procedure Applications)
Function Calls, Again
Function Shorthand
Function-Call Optimizations
functional update
Functions (Procedures): lambda
General Macro Transformers
generational garbage collector
Gotchas
greedy
Guide: PLT Scheme
Guidelines for Using Assignment
hash table
Hash Tables
I/O Patterns
identifier macro
Identifier Macros
identifier syntax object
Identifiers
Identifiers and Binding
Imports: require
Imposing Obligations on a Module’s Clients
index pairs
Infix Contract Notation
Inherit and Super in Traits
Initialization Arguments
Input and Output
instantiates
integer
Interacting with Scheme
Interactive Mode
Interfaces
Internal and External Names
Internal Certificates
Internal Definitions
invoked
Invoking Units
Iteration Performance
Iterations and Comprehensions
JIT
just-in-time
keyword
Keyword Arguments
Keyword Arguments
Keywords
letrec Performance
Lexical Scope
link
Linking Units
list
List Iteration from Scratch
Lists and Scheme Syntax
Lists, Iteration, and Recursion
Load Mode
Local Binding
Local Binding with define, let, and let*
Local Scopes
Lookahead
Lookbehind
Looking Ahead and Behind
macro
macro pattern variables
macro transformer
macro-generating macro
Macro-Generating Macros
Macros
Manipulating Namespaces
Matching Regexp Patterns
Matching Sequences
Memory Management
meta-compile phase level
metacharacters
metasequences
Methods
mixin
Mixing Patterns and Expressions: syntax-case
Mixins
Mixins and Interfaces
Module Basics
Module Mode
module path
Module Paths
Module Syntax
Modules
Modules and Performance
More Libraries
More PLT Schemes
More Structure Type Options
multi-line mode
Multiple Result Values
Multiple Values and define-values
Multiple Values: let-values, let*-values, letrec-values
Multiple Values: set!-values
Multiple-Valued Sequences
Mutation and Performance
mutator
Named let
namespace
Namespaces
Namespaces and Modules
non-capturing
Non-capturing Clusters
non-greedy
Notation
number
Numbers
opaque
Opaque versus Transparent Stucture Types
Optional Arguments
Optional Keyword Arguments
pair
Pairs and Lists
Pairs, Lists, and Scheme Syntax
Parallel Binding: let
Parameterized Mixins
parameters
Pattern Matching
pattern variables
pattern-based macro
Pattern-Based Macros
Performance
phase level -1
phase level 2
port
POSIX character class
POSIX character classes
Predefined List Loops
predicate
prefab
Prefab Stucture Types
Procedures of Some Fixed, but Statically Unknown Arity
Programmer-Defined Datatypes
Promising Something About a Specific Structure
Promising Something About a Specific Vector
prompt
prompt tag
Prompts and Aborts
property
Quantifiers
quantifiers
Quasiquoting: quasiquote and `
Quoting Pairs and Symbols with quote
Quoting: quote and
R5RS
R6RS
rational
Reading and Writing Scheme Data
real
Recursion versus Iteration
Recursive Binding: letrec
Reflection and Dynamic Evaluation
regexp
Regular Expressions
REPL
Rest Arguments
Restricting the Arguments of a Function
Restricting the Range of a Function
Rolling Your Own Contracts for Function Arguments
Running and Creating Executables
Running mzscheme and mred
Scheme Essentials
Scripting Evaluation and Using load
Sequence Constructors
Sequencing
Sequential Binding: let*
serialization
Sharing Data and Code Across Namespaces
signatures
Signatures and Units
Simple Branching: if
Simple Contracts on Functions
Simple Definitions and Expressions
Simple Dispatch: case
Simple Structure Types: define-struct
Simple Values
Some Frequently Used Character Classes
Standards
string
Strings (Unicode)
Structure Subtypes
structure type descriptor
Structure Type Generativity
Stucture Comparisons
subcluster
submatch
subpattern
symbol
Symbols
Syntax Certificates
Syntax Objects
syntax objects
Tail Recursion
Teaching
template
template phase level
text string
The #lang Shorthand
The and/c, or/c, and listof Contract Combinators
The apply Function
The Bytecode and Just-in-Time (JIT) Compilers
The Difference Between any and any/c
The mixin Form
The module Form
The trait Form
Traits
Traits as Sets of Mixins
transformer
transformer binding
transparent
unit versus module
Units
Units (Components)
Unix Scripts
Using set! to Assign to Variables Provided via provide/contract
Varieties of Ports
vector
Vectors
Void and Undefined
Welcome to PLT Scheme
When a Function’s Result Depends on its Arguments
When Contract Arguments Depend on Each Other
Whole-module Signatures and Units
with-syntax and generate-temporaries
Writing Regexp Patterns