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
7. Building a Calculator: Pure Functions in Practice
8. Exploring GHCi with Your Project

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
7. Practical Examples: Putting It All Together

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
7. Implementing Standard List Functions

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)
7. Working with Trees: A Complete Example
8. Custom Error Types with Smart Constructors
9. Smart Constructors for Validation

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
7. Advanced Composition Patterns

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
6. Designing Your Own Type Classes

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
7. Practical Monad Examples

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
7. Practical Advanced Types

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
7. Diagnosing and Fixing Space Leaks

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
7. Practical Error Handling Patterns

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
7. Advanced Concurrency Patterns

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
7. Comprehensive Testing Examples

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
7. Setting Up a Professional Haskell Project
8. Building a Blog API with Servant

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
7. Advanced Design Pattern Examples

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
6. Production Deployment Patterns

Conclusion: The Haskell Mindset

References