Table of Contents
Lesson 1. Getting started with Haskell
1.2. The Glasgow Haskell Compiler
1.3. Interacting with Haskell—GHCi
Unit 1. Foundations of functional programming
Lesson 2. Functions and functional programming
2.3. The value of functional programming in practice
Lesson 3. Lambda functions and lexical scope
3.2. Writing your own where clause
3.3. From lambda to let: making your own variable variables!
Lesson 4. First-class functions
Lesson 5. Closures and partial application
5.1. Closures—creating functions with functions
5.2. Example: Generating URLs for an API
6.2. Lists and lazy evaluation
6.3. Common functions on lists
Lesson 7. Rules for recursion and pattern matching
7.2.1. Rule 1: Identify the end goal(s)
7.2.2. Rule 2: Determine what happens when a goal is reached
7.2.3. Rule 3: List all alternate possibilities
7.2.4. Rule 4: Determine your “Rinse and Repeat”
7.2.5. Rule 5: Ensure that each alterative moves you toward the goal
Lesson 8. Writing recursive functions
8.1. Review: Rules of recursion
8.3. Pathological recursion: Ackerman function and the Collatz conjecture
Lesson 9. Higher-order functions
Lesson 10. Capstone: Functional object-oriented programming with robots!
10.1. An object with one property: a cup of coffee
10.2. A more complex object: let’s build fighting robots!
10.3. Why stateless programming matters
10.4. Types—objects and so much more!
11.2.1. Functions for converting to and from strings
Lesson 12. Creating your own types
13.3. The benefits of type classes
13.6. The Ord and Eq type classes
14.1. A type in need of classes
14.3. Type classes and polymorphism
14.4. Default implementation and minimum complete definitions
14.6. To derive or not to derive?
Lesson 15. Capstone: Secret messages!
15.1. Ciphers for beginners: ROT13
15.2. XOR: The magic of cryptography!
15.3. Representing values as bits
Lesson 16. Creating types with “and” and “or”
16.1. Product types—combining types with “and”
16.2. Sum types—combining types with “or”
Lesson 17. Design by composition—Semigroups and Monoids
17.1. Intro to composability—combining functions
17.2. Combining like types: Semigroups
17.3. Composing with identity: Monoids
Lesson 18. Parameterized types
18.1. Types that take arguments
18.2. Types with more than one parameter
Lesson 19. The Maybe type: dealing with missing values
19.1. Introducing Maybe: solving missing values with types
Lesson 20. Capstone: Time series
20.1. Your data and the TS data type
20.2. Stitching together TS data with Semigroup and Monoid
20.3. Performing calculations on your time series
20.3.1. Calculating the min and max values for your time series
20.4. Transforming time series
Lesson 21. Hello World!—introducing IO types
21.1. IO types—dealing with an impure world
21.3. An example: command-line pizza cost calculator
Lesson 22. Interacting with the command line and lazy I/O
22.1. Interacting with the command line the nonlazy way
22.2. Interacting with lazy I/O
Lesson 23. Working with text and Unicode
24.1. Opening and closing files
24.3. The trouble with lazy I/O
Lesson 25. Working with binary data
25.1. Working with binary data by using ByteString
Lesson 26. Capstone: Processing binary files and book data
26.2. Working with MARC records
26.2.1. Understanding the structure of a MARC record
26.2.3. Checking the leader and iterating through your records
26.2.5. Using the directory to look up fields
26.2.6. Processing the directory entries and looking up MARC fields
26.2.7. Getting Author and Title information from a MARC field
Unit 5. Working with type in a context
Lesson 27. The Functor type class
27.1. An example: computing in a Maybe
27.2. Using functions in context with the Functor type class
27.3. Functors are everywhere!
27.3.1. One interface for four problems
27.3.2. Converting a Maybe RobotPart to Maybe Html
27.3.3. Converting a list of RobotParts to a list of HTML
Lesson 28. A peek at the Applicative type class: using functions in a context
28.1. A command-line application for calculating the distance between cities
28.2. Using <*> for partial application in a context
28.2.1. Introducing the <*> operator
28.2.2. Using <*> to finish your city distance program
28.2.3. Using a multi-argument function in IO using <$> and <*>
28.3. Using <*> to create data in a context
Lesson 29. Lists as context: a deeper look at the Applicative type class
29.1. Introducing the Applicative type class
29.3.1. Exploring container vs. context with a list
Lesson 30. Introducing the Monad type class
30.1. The limitations of Applicative and Functor
Lesson 31. Making Monads easier with do-notation
31.2. Using do-notation to reuse the same code in different contexts
31.2.2. The IO context—building a command-line tool
31.2.3. The Maybe context—working with a map of candidates
31.2.4. The List context—processing a list of candidates
31.2.5. Putting it all together and writing a monadic function
Lesson 32. The list monad and list comprehensions
32.1. Building lists with the list monad
Lesson 33. Capstone: SQL-like queries in Haskell
33.2. Basic queries for your list: select and where
33.3. Joining Course and Teacher data types
33.4. Building your HINQ interface and example queries
33.5. Making a HINQ type for your queries
33.6. Running your HINQ queries
Unit 6. Organizing code and building projects
Lesson 34. Organizing Haskell code with modules
34.1. What happens when you write a function with the same name as one in Prelude?
34.2. Building a multifile program with modules
34.2.1. Creating the Main module
34.2.2. Putting your improved isPalindrome code in its own module
Lesson 35. Building projects with stack
35.1. Starting a new stack project
35.2. Understanding the project structure
35.4. Building and running your project!
35.4.1. A quick improvement: getting rid of language pragmas
Lesson 36. Property testing with QuickCheck
36.2. Different types of testing
36.3. Property testing QuickCheck
36.3.2. Introducing QuickCheck
36.3.3. Using QuickCheck with more types and installing packages
Lesson 37. Capstone: Building a prime-number library
37.1. Starting your new project
37.2. Modifying the default files
37.3. Writing your core library functions
37.4. Writing tests for your code
37.5. Adding code to factor numbers
Lesson 38. Errors in Haskell and the Either type
38.1. Head, partial functions, and errors
38.2. Handling partial functions with Maybe
38.3. Introducing the Either type
Lesson 39. Making HTTP requests in Haskell
39.1. Getting your project set up
Lesson 40. Working with JSON data by using Aeson
40.3. Making your data types instances of FromJSON and ToJSON
Lesson 41. Using databases in Haskell
41.2. Using SQLite and setting up your database
41.3. Creating data—inserting users and checking out tools
41.4. Reading data from the database and FromRow
Lesson 42. Efficient, stateful arrays in Haskell
42.1. Creating efficient arrays in Haskell with the UArray type
42.2. Mutating state with STUArray
42.3. Taking values out of the ST context
More powerful type systems than Haskell?
Other functional programming languages
Answers to end-of-lesson exercises