Haskell Unlocked

A Complete Guide to Functional Programming from First Principles to Production Mastery

Introduction: The Haskell Mindset

1. What You Will Learn
2. Prerequisites and How to Use This Book
3. A Note About GHC Versions
4. The Journey Ahead

Chapter 1: Why Haskell – A Different Way to Think About Code

1. The Problem with Imperative Code
2. What Makes Haskell Different
3. A Taste of Haskell – Your First Program
4. Who Uses Haskell in Production
5. How to Read This Book

Chapter 2: Getting Started – Installation and Your First Programs

1. Installing GHC and the Haskell Toolchain
2. Your First Program – Hello World and Beyond
3. The GHCi Interactive REPL
4. Understanding the Compilation Process
5. Cabal vs Stack – Package Managers Compared
6. Your First Project Structure

Chapter 3: Expressions, Types, and Functions – The Building Blocks

1. Everything Is an Expression
2. Basic Types – Numbers, Booleans, Characters, Strings
3. Defining and Calling Functions
4. Type Declarations and Type Inference
5. Guards and Conditional Logic
6. Where and Let Bindings

Chapter 4: Lists, Pattern Matching, and Recursion

1. Lists – The Workhorse Data Structure
2. Pattern Matching – Deconstructing Data Elegantly
3. Recursion – Thinking Without Loops
4. List Comprehensions
5. Common List Functions – Map, Filter, Fold
6. Writing Your First Recursive Algorithms

Chapter 5: Algebraic Data Types – Modeling the World

1. Product Types – Records and Structured Data
2. Sum Types – Choice and Variants
3. Type Synonyms and Newtypes
4. Deriving Standard Classes
5. Modeling a Domain – A Complete Example
6. Extensible Effects with GADTs (Preview)

Chapter 6: Higher-Order Functions and Function Composition

1. Functions as First-Class Values
2. Currying and Partial Application
3. Function Composition – Building from Small Pieces
4. Common Higher-Order Patterns
5. Section Notation and Operator Sections
6. The Lambda Calculus Connection

Chapter 7: Type Classes – Ad Hoc Polymorphism Done Right

1. What Are Type Classes?
2. The Standard Hierarchy – Eq, Ord, Show, Read
3. Numeric Type Classes – Num, Integral, Fractional
4. Defining Your Own Type Classes
5. Type Class Design Patterns

Chapter 8: Functors, Applicatives, and Monads – The Big Three

1. Functors – Mapping Over Contexts
2. Applicatives – Combining Contextual Values
3. Monads – Sequencing Computations
4. The Maybe Monad – Handling Absence
5. The List Monad – Non-Deterministic Computation
6. The IO Monad – Bridging Pure and Impure Worlds

Chapter 9: Advanced Type System Features

1. Higher-Kinded Types
2. Existential Types
3. Type Families
4. DataKinds and Singleton Types
5. Liquid Haskell – Refinement Types
6. The Expressiveness of the Haskell Type System

Chapter 10: Lazy Evaluation and Performance Semantics

1. How Laziness Works – Thunks and Demand
2. Benefits of Lazy Evaluation
3. The Space Leak Problem
4. Strictness Annotations – Bang Patterns and STRICT
5. Profiling and Benchmarking Haskell Programs
6. Writing Performant Code – Best Practices

Chapter 11: Error Handling – Beyond Exceptions

1. Maybe and Either – Pure Error Handling
2. The ExceptT Transformer
3. Assertions and Debugging
4. Exceptions in Haskell – When and Why
5. The Validation Pattern – Accumulating Errors
6. Custom Error Types for Your Domain

Chapter 12: Concurrency and Parallelism

1. Threads and the MVar Primitive
2. Software Transactional Memory (STM)
3. The STM Pattern – Composable Transactions
4. Parallelism with Strategies
5. Concurrent Data Structures
6. Real-World Concurrent Applications

Chapter 13: Testing, Quality, and Refactoring

1. The Haskell Testing Ecosystem
2. Unit Testing with HUnit
3. Property-Based Testing with QuickCheck
4. Combining Test Frameworks with Tasty
5. Mocking and Integration Testing
6. Refactoring Haskell Code

Chapter 14: The Haskell Ecosystem – Tools, Libraries, and Packages

1. Build Tools – Cabal, Stack, and GHCup
2. Linting and Formatting – HLint, Fourmolu, Stylish-Haskell
3. Documentation – Haddock and Hoogle
4. Package Management and Publishing to Hackage
5. Essential Libraries – Text, Aeson, Lens, Conduit
6. Web Frameworks – Servant, Yesod, Snap

Chapter 15: Design Patterns in Haskell

1. The Parser Combinator Pattern
2. The Church Encoding Pattern
3. Free Monads – Interpretable Programs
4. The Lens Pattern – Accessing Nested Data
5. The Arrow Pattern – Dataflow Programming
6. Functional Design Patterns vs Object-Oriented Patterns

Chapter 16: Building Real Projects – From Concept to Production

1. Project 1 – A Command-Line Task Manager
2. Project 2 – A REST API with Servant
3. Project 3 – A Concurrent Web Crawler
4. Deployment and CI/CD for Haskell
5. Performance Tuning a Production Application

Conclusion: The Haskell Mindset

References