Essential Scheme

A Complete Guide to the Language and Its Philosophy

Introduction: Why Learn Scheme?

1. The Promise of This Book
2. A Note on Standards and Portability
3. How to Read This Book
4. What Scheme Is Not

Chapter 1: What Is Scheme?

1. The Lisp Family Tree: From McCarthy to Today
2. The Birth of Scheme: MIT AI Lab and Minimalist Design
3. The Standardization Story: R5RS Through R7RS
4. What Makes Scheme Different: A Philosophy of Simplicity
5. Choosing an Implementation: Getting Started with Real Code

Chapter 2: First Steps in Scheme

1. The Read-Eval-Print Loop: Your First Encounter
2. Expressions and Values: Everything Evaluates to Something
3. Numbers and Arithmetic: More Than Just Math
4. Quoting: When You Want Data Instead of Computation
5. Lists as the Fundamental Structure
6. Putting It Together: Your First Real Program

Chapter 3: Procedures and Functions

1. Defining Procedures with define
2. Calling Procedures: Application and Argument Passing
3. Lambda: The Anonymous Function at the Core
4. First-Class Functions: Functions as Data
5. Named vs Anonymous: When Each Makes Sense
6. Quasiquoting and Unquoting
7. Summary

Chapter 4: Control Flow and Conditionals

1. Boolean Values and Predicates
2. if: The Fundamental Conditional
3. cond and case: Multi-Way Branching
4. Recursion as the Primary Loop Mechanism
5. Mutual Recursion: Functions Calling Each Other
6. Summary

Chapter 5: Data Structures

1. Pairs and Cons Cells: The Atomic Building Block
2. Lists: Construction, Traversal, and Patterns
3. Symbols: Named Atoms for Programs and Data
4. Strings and Characters: Text Processing
5. Vectors: Indexed Collections for Performance
6. Summary

Chapter 6: State and Mutation

1. Variables as Names for Values
2. Lexical Scope: Where Bindings Live
3. set!: Changing Variable Values
4. Mutable Data Structures: set-car!, set-cdr!, and Friends
5. When to Mutate and When Not To
6. Summary

Chapter 7: Higher-Order Programming

1. Functions That Take Functions as Arguments
2. Map, Filter, Fold: The Functional Toolkit
3. Function Composition and Partial Application
4. Closures: Capturing Environment
5. Building Domain-Specific Abstractions
6. Summary

Chapter 8: Tail Calls and Efficiency

1. What Is a Tail Call?
2. Tail-Recursive Patterns for Iteration
3. How Tail-Call Optimization Works
4. Accumulators and State in Pure Function Style
5. Performance Implications and Real-World Use
6. Summary

Chapter 9: Input, Output, and Exceptions

1. Reading from and Writing to Ports
2. File I/O: Opening, Reading, Writing, Closing
3. Standard Input and Output
4. Exception Handling with with-exception-handler
5. Error Reporting and Debugging Techniques
6. Summary

Chapter 10: Records and Structured Data

1. The Need for Structured Data
2. R6RS/R7RS Record Types
3. Accessors, Mutators, Predicates
4. Extending and Inheriting Record Types
5. Practical Data Modeling with Records
6. Summary

Chapter 11: Macros and Metaprogramming

1. Why Macros Exist: Beyond Functions
2. syntax-rules: Pattern-Matching Code Generation
3. Hygienic Macros: Avoiding Name Collisions
4. Writing Useful Macros: Let Variants and More
5. When Macros Help and When They Hurt
6. Summary

Chapter 12: Continuations and Control Flow

1. What Is a Continuation?
2. call-with-current-continuation: Capturing Control
3. Nonlocal Exits and Exception Handling
4. Coroutines and Generators with Continuations
5. Backtracking and Search Algorithms
6. Summary

Chapter 13: Delayed Evaluation and Streams

1. Eager vs Lazy Evaluation
2. Promises with delay and force
3. Infinite Sequences as Finite Objects
4. Stream Operations: Map, Filter, Fold on Streams
5. Practical Uses of Lazy Evaluation
6. Summary

Chapter 14: Modules and Libraries

1. The Module Problem: Why Namespaces Matter
2. R5RS Style: No Built-In Modules
3. R6RS and R7RS Module Systems
4. Importing, Exporting, Renaming
5. Building Library Code for Others to Use
6. Summary

Chapter 15: Interpreters and DSLs

1. Why Scheme Is Great for Language Work
2. Writing a Metacircular Evaluator
3. Extending the Language with New Forms
4. Building Domain-Specific Languages
5. From Interpreter to Compiler: The Path Forward
6. Summary

Chapter 16: Performance, Testing, and Real-World Development

1. Understanding Scheme Performance Characteristics
2. Profiling and Optimizing Code
3. Testing Strategies for Scheme Programs
4. Debugging Techniques Across Implementations
5. Interoperability: Calling C, FFI, Foreign Languages
6. Concurrency Where Available
7. Summary

Chapter 17: The Scheme Ecosystem Today

1. Major Implementations Compared
2. Libraries and Package Managers by Implementation
3. Real-World Uses of Scheme Today
4. The Future of Scheme: Trends and Directions
5. Where to Go From Here

Conclusion: The Enduring Power of Simplicity

References