Every recommendation below comes with an honest note on what it's actually good for — none of this is a bare link dump. Read in roughly the order given if you're starting from scratch.
The friendliest possible on-ramp, and still the best first book for most people despite its age. Its great strength is tone: it never assumes you already think functionally, and it takes genuine care over exactly the kind of "what IS a function" confusion Chapter 2 of this book opens with. Free to read online, which makes it an easy first stop before committing to anything longer.
Where Lipovača optimizes for friendliness, Hutton optimizes for precision — this is the book to read once you want the ideas stated tightly and correctly, with real attention paid to equational reasoning (Chapter 4 of this book leans directly on the style Hutton teaches). Used widely as an actual university textbook, and it reads like one in the best sense: dense, well-sequenced, no filler.
The book to reach for once the fundamentals from this site have settled and you want to build something real — parsers, web services, concurrent programs. Some library-specific details have aged (it predates several now-standard tools), but the engineering judgment throughout — when to reach for laziness, when to fight it, how to structure a real project — holds up extremely well. Free to read online.
The book for the reader who wants Chapter 4's "equational reasoning" promise taken all the way seriously. Bird treats Haskell programs as mathematical objects to be derived and proven correct, not just written and tested. Demanding, and genuinely rewarding if you want to see how far the "code as math" idea actually goes.
The single best resource for turning this book's Chapter 8–10 "category-theoretic asides" into real, working understanding. Milewski teaches category theory *to* programmers, using Haskell (and some C++) as the worked examples throughout, rather than teaching abstract math and hoping the programming connection is obvious. Free as a set of blog posts, also collected into a PDF and a paperback.
Answers the question Chapter 4's "Cool Fact" box raises and doesn't fully resolve: how do you build genuinely efficient data structures — queues, heaps, search trees — when nothing is ever allowed to mutate? Based on Okasaki's PhD thesis, and still the definitive reference on the subject a quarter-century later.
The definitive, exhaustive mathematical treatment of everything Chapter 1 introduces informally — beta reduction, alpha-conversion, Church encodings, and fixed-point combinators, proven rigorously rather than motivated by example. Not a casual read, but the single most authoritative source on the subject.
If you only ever read one paper about Functional Programming, make it this one. Hughes makes the case — with the actual, small, convincing code examples to back it up — that laziness and higher-order functions aren't stylistic preferences but genuine tools for modularity, echoing exactly the "generate vs. consume" separation Chapter 5 walks through with `primes`.
Published the same year as Church's lambda calculus paper, and proven shortly after to define exactly the same class of computable functions. Worth reading alongside Chapter 1 specifically to see two totally different-looking formalisms — an abstract machine with a tape, versus a calculus of pure substitution — arrive at the identical notion of "computable."
The paper that took monads from a category-theory curiosity into a working tool for programming language design, written by one of the people most responsible for their presence in Haskell at all. Denser than Hughes's paper above, but reading it after Chapter 10 of this book — rather than before — makes it far more approachable than its reputation suggests.
The original STM paper Chapter 7 is built on. Technical and implementation-focused, but the motivating examples — especially around why lock-based code fails to compose — are worth reading even without following every proof.
The more accessible essay version of the same ideas, written for the *Beautiful Code* anthology rather than a systems conference. The direct source for this book's Chapter 7, and this book's title for that chapter.
A genuinely fun read, not just a historical record: the committee members who actually designed Haskell explain the arguments, dead ends, and compromises behind decisions this book treats as settled fact — including why laziness became the default (Chapter 5) rather than an opt-in feature.
The talk this book's Chapter 0 quotes from directly. Watching Peyton Jones derive Software Transactional Memory live from Haskell's purity guarantees is the clearest possible demonstration that "purity" (Chapter 6) isn't an academic nicety — it has sharp, practical teeth.
A wonderful, largely code-free lecture on the Curry–Howard correspondence this book's Chapter 3 mentions in passing. Wadler traces the idea from Curry and Howard's original insight through to how it shapes Haskell's type system today — genuinely accessible even without a formal logic background.
Alonzo Church (1903–1995)
Invented the Lambda Calculus in the 1930s as a foundation for mathematical logic — decades before electronic computers existed. Every function definition in this book is, underneath, Church's notation with better syntax.
Alan Turing (1912–1954)
Published his own, independent formalization of computability the same year as Church — the Turing machine — and proved shortly after that it and the lambda calculus define exactly the same class of computable functions, a result now called the Church-Turing thesis.
Haskell Curry (1900–1982)
Pioneered combinatory logic and gave his name to the language this book is about (chosen by the Haskell committee specifically to honour him). 'Currying' — turning a multi-argument function into a chain of one-argument functions — is his idea, used silently throughout every chapter here.
Simon Peyton Jones (b. 1958)
Lead designer of GHC, the compiler almost everyone means when they say 'Haskell,' and one of the most persistent, most quoted advocates for why laziness and purity are worth their cost.
Philip Wadler (b. 1956)
Brought monads into practical programming-language design and did foundational work connecting type theory to logic (Curry–Howard) — two ideas that, between them, underpin roughly half of this book.
Saunders Mac Lane & Samuel Eilenberg (1909–2005 / 1913–1998)
Founded Category Theory itself in the 1940s, originally to formalize a notion of 'natural transformation' in algebraic topology — with no idea it would, sixty years later, become the vocabulary Chapters 8 through 10 of a Haskell book would borrow wholesale.