book

Haskell in Depth

by Vitaly Bragilevsky

June 2021

Intermediate to advanced

664 pages

17h 16m

English

Manning Publications

Read now

Unlock full access

forewordprefaceFunctional programmingType systemLazy evaluationTooling around HaskellWhat can be done using Haskell: Librariesacknowledgmentsabout this bookWho should read this bookHow this book is organized: A roadmapAbout the codeGetting the sourcesUsing cabalUsing stackliveBook discussion forumabout the authorabout the cover illustration
1.1 Solving problems in the GHCi REPL with functions1.2 From GHCi and String to GHC and Text1.3 Functional programs as sets of IO actions1.4 Embracing pure functions1.4.1 Separating I/O from pure functions1.4.2 Computing the most frequent words by sorting them1.4.3 Formatting reports1.4.4 Rule them all with IO actionsSummary
2.1 Manipulating a radar antenna with type classes2.1.1 The problem at hand2.1.2 Rotating a radar antenna with Eq, Enum, and Bounded2.1.3 Combining turns with Semigroup and Monoid2.1.4 Printing and reading data with Show and Read2.1.5 Testing functions with Ord and Random2.2 Issues with numbers and text2.2.1 Numeric types and type classes2.2.2 Numeric conversions2.2.3 Computing with fixed precision2.2.4 More about Show and Read2.2.5 Converting recursive types to strings2.3 Abstracting computations with type classes2.3.1 An idea of a computational context and a common behavior2.3.2 Exploring different contexts in parallel2.3.3 The do notation2.3.4 Folding and traversingSummary
3.1 Setting the scene3.1.1 Inputs3.1.2 Outputs3.1.3 Project structure3.2 Exploring design space3.2.1 Designing the user interface3.2.2 Dealing with input data3.2.3 Formatting reports3.2.4 Plotting charts3.2.5 Project dependencies overview3.3 Implementation details3.3.1 Describing data3.3.2 Plotting charts3.3.3 Preparing reports3.3.4 Implementing the user interface3.3.5 Connecting partsSummary

4.1 Organizing Haskell code with modules4.1.1 Module structure, imports and exports, and module hierarchy4.1.2 Custom Preludes4.1.3 Example: containers-mini4.2 Understanding Haskell packages4.2.1 Packages at the GHC level4.2.2 Cabal packages and Hackage4.3 Tools for project development4.3.1 Dependency management4.3.2 Haskell projects as a collection of packages4.3.3 Common project management activities and toolsSummary
5.1 Basic monads in use: Maybe, Reader, Writer5.1.1 Maybe monad as a line saver5.1.2 Carrying configuration all over the program with Reader5.1.3 Writing logs via Writer5.2 Maintaining state via the State monad5.2.1 Basic examples with the State monad5.2.2 Parsing arithmetic expressions with State5.2.3 RWS monad to rule them all: The game of dice5.3 Other approaches to mutability5.3.1 Mutable references in the IO monad5.3.2 Mutable references in the ST monadSummary
6.1 The problem of combining monads6.1.1 Evaluating expressions in reverse Polish notation6.1.2 Introducing monad transformers and monad stacks6.2 IO-based monad transformer stacks6.2.1 Describing a monad stack6.2.2 Exploiting monad stack functionality6.2.3 Running an application6.2.4 Can we do it without RWST?6.3 What is a monad transformer?6.3.1 Step 0: Defining a type for a transformer6.3.2 Step 1: Turning a monad stack into a monad6.3.3 Step 2: Implementing the full monad stack functionality6.3.4 Step 3: Supplying additional functionality6.3.5 Using a transformer6.4 Monad transformers in the Haskell libraries6.4.1 Identity is where it all starts6.4.2 An overview of the most common monad transformersSummary
7.1 Overview of error-handling mechanisms in Haskell7.1.1 The idea of exceptions7.1.2 To use or not to use?7.1.3 Programmable exceptions vs. GHC runtime exceptions7.2 Programmable exceptions in monad stacks7.2.1 The ExceptT monad transformer7.2.2 Example: Evaluating RPN expressions7.3 GHC runtime exceptions7.3.1 An idea of extensible exceptions7.3.2 Throwing exceptions7.3.3 Catching exceptions7.4 Example: Accessing web APIs and GHC exceptions7.4.1 Application components7.4.2 Exception-handling strategies7.5 Logging7.5.1 An overview of the monad-logger library7.5.2 Introducing logging with monad-logger into the suntimes projectSummary
8.1 Setting a scene: IPv4 filtering application8.1.1 Development process overview8.1.2 Initial implementation8.2 Testing the IPv4 filtering application8.2.1 Overview of approaches to testing8.2.2 Testing Cabal projects with tasty8.2.3 Specifications writing and checking with Hspec8.2.4 Property-based testing with Hedgehog8.2.5 Golden tests with tasty-golden8.3 Other approaches to testing8.3.1 Testing functions à la the REPL with doctest8.3.2 Lightweight verification with LiquidHaskell8.3.3 Code quality with hlintSummary
9.1 A mental model for Haskell memory usage at run time9.1.1 General memory structure and closures9.1.2 Primitive unboxed data types9.1.3 Representing data and code in memory with closures9.1.4 A detour: Lifted types and the concept of strictness9.2 Control over evaluation and memory usage9.2.1 Controlling strictness and laziness9.2.2 Defining data types with unboxed values9.3 Exploring compiler optimizations by example9.3.1 Optimizing code manually9.3.2 Looking at GHC CoreSummary
10.1 Benchmarking functions with criterion10.1.1 Benchmarking implementations of a simple function10.1.2 Benchmarking an IPv4 filtering application10.2 Profiling execution time and memory usage10.2.1 Simulating iplookup usage in the real world10.2.2 Analyzing execution time and memory allocation10.2.3 Analyzing memory usage10.3 Tuning performance of the IPv4 filtering application10.3.1 Choosing the right data structure10.3.2 Squeezing parseIP performanceSummary
11.1 Haskell types 10111.1.1 Terms, types, and kinds11.1.2 Delivering information with types11.1.3 Type operators11.2 Data kinds and type-level literals11.2.1 Promoting types to kinds and values to types11.2.2 Type-level literals11.3 Computations over types with type families11.3.1 Open and closed type synonym families11.3.2 Example: Avoid character escaping in GHCi11.3.3 Data families11.3.4 Associated families11.4 Generalized algebraic data types11.4.1 Example: Representing dynamically typed values with GADTs11.4.2 Example: Representing arithmetic expressions with GADTs11.5 Arbitrary-rank polymorphism11.5.1 The meaning11.5.2 Use cases11.6 Advice on dealing with type errors11.6.1 Be explicit about types11.6.2 Ask the compiler11.6.3 Saying more about errorsSummary
12.1 Deriving instances12.1.1 Basic deriving strategies12.1.2 The problem of type safety and generalized newtype deriving12.1.3 Deriving by an example with DerivingVia12.2 Data-type-generic programming12.2.1 Generic data-type representation12.2.2 Example: Generating SQL queries12.3 Template Haskell and quasiquotes12.3.1 A tutorial on Template Haskell12.3.2 Example: Generating remote function callsSummary
13.1 Types for specifying a web API13.1.1 Implementing a web API from scratch13.1.2 Implementing a web service with servant13.2 Toward dependent types with singletons13.2.1 Safety in Haskell programs13.2.2 Example: Unsafe interface for elevators13.2.3 Dependent types and substituting them with singletons13.2.4 Example: Safe interface for elevatorsSummary
14.1 Streaming data14.1.1 General components and naive implementation14.1.2 The streaming package14.2 Approaching an implementation of pipeline stages14.2.1 Reading and writing data efficiently14.2.2 Parsing data with parser combinators14.2.3 Accessing data with lenses14.3 Example: Processing COVID-19 data14.3.1 The task14.3.2 Processing data14.3.3 Organizing the pipelineSummary
15.1 Setting up an example15.1.1 Sample database15.1.2 Sample queries15.1.3 Data representation in Haskell15.2 Haskell database connectivity15.2.1 Connecting to a database15.2.2 Relating Haskell data types to database types15.2.3 Constructing and executing SELECT queries15.2.4 Manipulating data in a database15.2.5 Solving tasks by issuing many queries15.3 The postgresql-simple library15.3.1 Connecting to a database15.3.2 Relating Haskell data types to database types15.3.3 Executing queries15.4 The hasql ecosystem15.4.1 Structuring programs with hasql15.4.2 Constructing type-safe SQL statements15.4.3 Implementing database sessions15.4.4 Running database sessions15.4.5 The need for low-level operations and decoding data manually15.5 Generating SQL with opaleye15.5.1 Structuring programs with opaleye15.5.2 Describing database tables and their fields15.5.3 Writing queries15.5.4 Running queriesSummary
16.1 Running computations concurrently16.1.1 An implementation of concurrency in GHC16.1.2 Low-level concurrency with threads16.1.3 High-level concurrency with the async package16.2 Synchronization and communication16.2.1 Synchronized mutable variables and channels16.2.2 Software transactional memory (STM)Summary
BooksResearch papers

Overview

Turn the corner from “Haskell student” to “Haskell developer.” Haskell in Depth explores the important language features and programming skills you’ll need to build production-quality software using Haskell. And along the way, you’ll pick up some interesting insights into why Haskell looks and works the way it does. Get ready to go deep!

About the Technology
Software for high-precision tasks like financial transactions, defense systems, and scientific research must be absolutely, provably correct. As a purely functional programming language, Haskell enforces a mathematically rigorous approach that can lead to concise, efficient, and bug-free code. To write such code you’ll need deep understanding. You can get it from this book!

About the Book
Haskell in Depth unlocks a new level of skill with this challenging language. Going beyond the basics of syntax and structure, this book opens up critical topics like advanced types, concurrency, and data processing. You’ll discover key parts of the Haskell ecosystem and master core design patterns that will transform how you write software.

What's Inside

Building applications, web services, and networking apps
Using sophisticated libraries like lens, singletons, and servant
Organizing projects with Cabal and Stack
Error-handling and testing
Pure parallelism for multicore processors

About the Reader
For developers familiar with Haskell basics.

About the Author
Vitaly Bragilevsky has been teaching Haskell and functional programming since 2008. He is a member of the GHC Steering Committee.

Quotes
A clearly written guide. It’ll take your Haskell skills beyond the ‘getting started’ level.
- Phillip Sorensen, Cornell University

Packed full of practical knowledge to level up your design skills.
- Jose Luis Garcia, Nielsen

A practical book for real-world Haskell programs. It expands your Haskell knowledge to new frontiers.
- David Paccoud, Bioclinica

One of the most richly-detailed books on programming that I’ve encountered. Rewarding on many levels.
- Charles Earl, Automattic