| 0 |
Table of Contents |
|
7.2 |
Mutable Pairs and Non-list Structures |
| 1 |
Table of Contents |
|
7.3 |
Promises and Delay/Force Revisited |
| 2 |
Programming Styles |
|
8 |
Tail Recursion |
| 2.1 |
Introduction |
|
8.1 |
What is tail recursion? |
| 2.2 |
Syntax and Semantics |
|
8.2 |
Converting to tail-recursive form |
| 2.3 |
Operational Semantics |
|
8.3 |
Converting tail-recursion to loop form |
| 2.4 |
Transformational Semantics |
|
9 |
Continuations |
| 2.5 |
Programming Styles |
|
9.1 |
What is a continuation? |
| 3 |
A Simple Subset of Scheme |
|
9.2 |
Simple Recursion: The Factorial Example |
| 3.1 |
Scheme |
|
9.3 |
Complex Recursion: Tree Traversal with Continuations |
| 3.2 |
Restricted Scheme |
|
10 |
Continuations continued |
| 3.3 |
Some Illustrative Examples |
|
10.1 |
call/cc and support for Continuations |
| 3.4 |
Scheme Naming Conventions |
|
10.2 |
Breaking and Resuming |
| 3.5 |
Iterated Function Composition |
|
10.3 |
Tree Traversal With Error Bailout |
| 4 |
Techniques for Functional Programming |
|
10.4 |
Co-routines |
| 4.1 |
Abstract, Map, Fold/Reduce, Recurse! |
|
10.5 |
Exceptions With Continuations |
| 4.2 |
Compute Once, Reuse Many |
|
10.6 |
Unexpected Behaviour |
| 4.3 |
Use cond instead of if for guarded commands |
|
10.7 |
Simple Threads |
| 4.4 |
Pass State Down the Recursion |
|
11 |
Haskell Intro |
| 4.5 |
Use Local Functions to Avoid Passing Common Data |
|
11.1 |
The Haskell functional programming language |
| 4.6 |
Restructure Your Code for Clarity |
|
11.2 |
Haskell References |
| 4.7 |
Use an Accumulator to Pass Partial Results Down |
|
11.3 |
Obtaining the Haskell environment |
| 4.8 |
Use Default Parameters to Start the Computation |
|
11.4 |
Preliminaries |
| 4.9 |
Getting the tail back in recursion |
|
11.5 |
Operators |
| 4.10 |
Prefix Computation |
|
11.6 |
More ... |
| 5 |
Definition and Evaluation |
|
11.7 |
Terminology and Notions |
| 5.1 |
Evaluation Strategies |
|
12 |
Types |
| 5.2 |
Special Forms Are Lazy |
|
12.1 |
Expression Trees |
| 5.3 |
Implementing Conditional Special Forms With Functional Truth |
|
12.2 |
Type Classes |
| 5.4 |
Implementing Lazy Evaluation |
|
13 |
Haskell Examples - Simple Parsing |
| 5.5 |
Diversion - Objects Are Just Closures |
|
13.1 |
Building up a simple parser for numbers |
| 6 |
Streams |
|
13.2 |
Making the parsing process abstract |
| 6.1 |
Streams - How To Handle Infinite Objects |
|
13.3 |
Evaluation as parsing |
| 6.2 |
Examples Of Stream Operations |
|
13.4 |
Cleaning Up the Parser |
| 6.3 |
The Stream of Primes |
|
13.5 |
Typeclasses and Handling Errors |
| 6.4 |
Implicit Streams and Fixed Points |
|
14 |
Haskell Tips |
| 6.5 |
The Square Root Stream |
|
14.1 |
Conversion |
| 6.6 |
The Pi Stream |
|
14.2 |
Modules |
| 6.7 |
Another Stream Implementation Variant |
|
15 |
Revision Log |
| 7 |
Mutable State |
|
16 |
End of Document |
| 7.1 |
Capturing Mutable State In Closures |
|
|
