# Miranda The Craft of Functional Programming

## Part I Basic Functional Programming

### Chapter 1 Introducing functional programming

1.1 What is Functional Programming?
1.2 Miranda
1.3 Practical work

### Chapter 2 Basic types and simple programs

2.1 The numbers: Integers
2.2 Programming with integers
2.3 Syntax
2.4 Definitions: Patterns
2.5 Programming with Booleans
2.6 Characters and Strings
2.7 The numbers: Fractions
2.8 Programming with numbers and strings
2.9 Data structures: Tuples
2.10 Function Definitions
2.11 Programming with local definitions
2.13 Design

### Chapter 3 Reasoning about programs

3.1 Informal proof: an introduction
3.2 Proof by Induction
3.3 Building induction proofs

### Chapter 4 Data structures: Lists

4.1 Lists in Miranda
4.2 Defining functions over lists
4.3 Designing functions over lists
4.4 A library database
4.5 List comprehensions
4.6 Extended exercise: supermarket billing
4.7 Example: Text Processing
4.8 Definition forms
4.9 Program design

### Chapter 5 Reasoning about lists

5.1 Structural induction
5.2 Proofs by structural induction
5.3 Case studies
5.4 Generalizing the proof goal

## Part II Abstraction

### Chapter 6 Generalization

6.1 Functions as arguments
6.2 Polymorphism
6.3 Putting the two together
6.4 Using the higher-order functions
6.5 Generalizing: splitting up lists

### Chapter 7 Further Generalization

7.1 Function composition
7.2 Functions as results
7.3 Partial Application
7.4 Examples
7.5 Currying and uncurrying
7.6 Example: creating an index
7.7 Design revisited
7.8 Verification

### Chapter 8 Types in Miranda

8.1 Monomorphic types
8.2 Polymorphic types
8.3 Polymorphic Type Checking
8.4 Special functions

## Part III Larger-scale programming

### Chapter 9 Algebraic types

9.1 Introduction
9.2 Recursive Types
9.3 Polymorphic algebraic types
9.4 Case study: Program Errors
9.5 Design with Algebraic Data Types

### Chapter 10 Case study: Huffman codes

10.1 Modules in Miranda
10.2 Modular design
10.3 Coding and decoding
10.4 Implementation - I
10.5 Building Huffman trees
10.6 Design
10.7 Implementation - II

### Chapter 11 Type abstraction

11.1 Type representations
11.2 The Miranda abstype mechanism
11.3 Example: queues
11.4 Design
11.5 Example: Simulation
11.6 Implementing the simulation
11.7 Example: Search trees
11.8 Case Study: Sets
11.9 Relations and graphs

### Chapter 12 Lazy evaluation & Lists revisited

12.1 Introduction
12.2 Calculation Rules
12.3 List comprehensions revisited
12.4 Data on demand
12.5 Case study: Parsing expressions

### Chapter 13 Infinite lists

13.1 Infinite lists
13.2 Why infinite lists?
13.3 Case study: Simulation
13.4 Writing interactive programs
13.5 A library for interactions
13.6 Implementing the abstype of interactions
13.7 Proof revisited

### Chapter 14 Program behaviour

14.1 Complexity of functions
14.2 The complexity of calculations
14.3 Implementations of sets
14.4 Space behaviour
14.5 Folding revisited
14.6 Avoiding re-computation: memoization