Haskell in Depth
Vitaly Bragilevsky
  • MEAP began June 2018
  • Publication in Fall 2020 (estimated)
  • ISBN 9781617295409
  • 360 pages (estimated)
  • printed in black & white

Finally, a truly great book for Haskell programming in the real-world.

William E. Wheeler
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

As software becomes more complex, it’s essential to program efficiently using tools and techniques that guarantee your applications will run correctly, grow easily, and last a long time. Haskell is a functional programming language that blends a mathematically-rigorous approach to software design with a tested ecosystem of tools and libraries you can use to build deployable applications.

About the book

Haskell in Depth is the perfect second book on Haskell. After a quick refresher on Haskell basics, this hands-on guide dives into examples and application scenarios designed to teach how Haskell works and how to apply it correctly. You’ll learn about managing projects with Cabal and Stack, tackle error-handling and testing, and package programs and libraries for production deployment.

You’ll appreciate coverage of advanced Haskell features including programming polymorphically, working effectively with types, concurrent programming, data processing, web services, and more. Because it’s organized to make specific topics easy to find, you’ll return to this book again and again as your go-to Haskell reference.

Table of Contents detailed table of contents

0 Haskell in Depth: How to work with the source code examples

0.1 Getting the sources

0.2 Using Stack

0.2.1 Building

0.2.2 Running

0.2.3 Exploring in GHCi

0.3 Using Cabal sandbox

0.3.1 Building

0.3.2 Running

0.3.3 Exploring in GHCi

0.4 Using Cabal new-*

0.4.1 Building

1 Haskell nowadays

1.1 Language features and programming styles

1.1.1 Functional programming

1.1.2 Type system

1.1.3 Lazy evaluation

1.2 Tooling around Haskell

1.3 What can be done using Haskell: Libraries

1.4 What is in this book

1.5 Summary

Part 1: Core Haskell

2 Functional programming with types and type classes

2.1 Basic text processing in functional style

2.1.1 First attempt: Exploring the problem in a REPL with Strings

2.1.2 Moving away from REPL and Strings

2.1.3 Designing a functional program as a set of IO actions

2.1.4 Embracing pure functions

2.2 Type classes and their instances

2.2.1 Equality and order, enumerating and boundedness

2.2.2 Example: Programming a locator with type classes and instances

2.2.3 Numeric types and type classes

2.2.4 The type classes Show, Read, and beyond

2.2.5 Demystifying the OverloadedStrings GHC extension

2.3 Abstracting computations with type classes

2.3.1 The only operation, (<>)

2.3.2 Mapping, applying, and sequencing in a computational context

2.3.3 Folding and traversing

2.4 Summary

3 Processing stock quote data: An example

3.1 Setting the scene

3.2 Exploring design space

3.2.1 Dealing with dates and times

3.2.2 Computing with fixed precision

3.2.3 Parsing data

3.2.4 Formatting texts

3.2.5 Other tasks and the corresponding packages

3.2.6 External packages in the project

3.3 Implementing stockquotes project

3.3.1 Describing data

3.3.2 Computing statistics

3.3.3 Formatting statistical report

3.3.4 Drawing charts

3.3.5 Designing user interface

3.3.6 Connecting the parts

3.4 Extending project with reports in HTML

3.4.1 Changes in user interface

3.4.2 Generating reports in HTML format with blaze-html

3.4.3 Changes in the Main module

3.5 Summary

Part 2: Developing Projects in Haskell

4 Structuring programs with modules and packages

4.1 Haskell programs as collections of modules

4.1.1 Module structure, imports, and exports

4.1.2 Using custom preludes for encouraging best practices

4.2 Understanding Haskell packaging

4.2.1 Packaging at the compiler level

4.2.2 Cabal packages and Hackage

4.2.3 Versioning packages

4.3 Tools for Haskell project management

4.3.1 Traditional package management with cabal-install

4.3.2 Nix-style local package management with cabal-install

4.3.3 Using stack and Stackage for Haskell development

4.3.4 Continuous integration for Haskell projects

4.4 Summary

5 Monads as practical functionality providers

5.1 A teaser: Maybe monad as a line saver

5.2 Reading and writing

5.2.1 Access to the configuration via Reader

5.2.2 Writing logs via Writer

5.2.3 Running Writer computations

5.3 Maintaining state via State monad

5.3.1 Random numbers in Haskell and State monad

5.3.2 Exploring Rock-Paper-Scissors

5.3.3 Parsing arithmetic expressions with State

5.3.4 RWS monad to rule them all: the game of dices

5.4 Other approaches to mutability

5.4.1 Mutable references in the IO monad

5.4.2 Mutable references in the ST monad

5.5 Summary

6 Structuring programs with monad transformers

6.1 The problem of combining monads: State + Maybe

6.1.1 Evaluating expressions in the reversed polish notation

6.1.2 Analyzing flaws

6.1.3 An attempt to fix the flaws: report Nothing in case of error

6.1.4 Introducing monad transformers and monad stacks

6.1.5 Hiding explicit Nothing manipulations with Alternative

6.2 IO-based monad transformer stacks

6.2.1 Describing monad stack: an application

6.2.2 Computing file space usage

6.2.3 Configuring and running an application

6.2.4 Extending functionality: file counter

6.2.5 Can we do it without RWST?

6.3 What is a monad transformer

6.3.1 Step 0: defining a type for a transformer

6.3.2 Step 1: turning a monad stack into a monad

6.3.3 Step 2: implementing the full monad stack functionality

6.3.4 Step 3: supplying additional functionality

6.3.5 Using a transformer

6.4 Monad transformers in the Haskell libraries

6.4.1 Identity is where it all starts

6.4.2 An overview of the most common monad transformers

6.5 Summary

7 Exceptions handling and logging

7.1 Overview of exceptions in Haskell

7.1.1 To use or not to use

7.1.2 An idea of exceptions

7.1.3 Programmable exceptions in monad stacks

7.1.4 GHC runtime exceptions

7.2 Evaluating expressions with programmable exceptions

7.2.1 The ExceptT monad transformer and the Except monad

7.2.2 Throwing exceptions

7.2.3 Catching exceptions within the monad stack

7.3 Accessing web APIs and GHC exceptions

7.3.1 Application components

7.3.2 Exceptions handling strategies

7.4 Logging

7.4.1 An overview of the monad-logger library

7.4.2 Introducing logging with monad-logger into the suntimes project

7.5 Summary

8 Quality assurance

8.1 Setting a scene: IPv4 filtering application

8.1.1 Development process overview

8.1.2 Initial implementation

8.2 Testing the IPv4 filtering application

8.2.1 Overview of approaches to testing

8.2.2 Testing Cabal-projects with tasty

8.2.3 Specifications writing and checking with Hspec

8.2.4 Property-based testing with Hedgehog

8.2.5 Golden tests with tasty-golden

8.3 Other approaches to quality assurance in Haskell

8.3.1 Testing functions a-la REPL with doctest

8.3.2 Lightweight verification with Liquid Haskell

8.3.3 Code quality with hlint

8.4 Summary

9 Haskell data and code at runtime

9.1 Mental model for Haskell memory usage at runtime

9.1.1 General memory structure and closures

9.1.2 Primitive unboxed data types

9.1.3 Representing data in memory with closures

9.1.4 Representing code in memory and lazy evaluation

9.1.5 A detour: Lifted types and the concept of strictness

9.2 Control over evaluation and memory usage

9.2.1 Controlling strictness and laziness

9.2.2 Defining data types with unboxed values

9.3 Exploring compiler optimizations by example

9.3.1 Unfolding [..] syntax

9.3.2 Rewriting enumeration

9.3.3 Unfolding all

9.3.4 List fusion

9.3.5 Final optimizations

9.3.6 Looking at GHC Core

9.4 Summary

10 Benchmarking and profiling

10.1 Benchmarking functions with criterion

10.1.1 Cooking cabal-projects for benchmarking

10.1.2 Benchmarking IPv4 filtering application

10.2 Profiling execution time and memory usage

10.2.1 Simulating iplookup usage in the real world

10.2.2 Analyzing execution speed and memory allocation

10.2.3 Analyzing memory usage

10.3 Tuning performance of the IPv4 filtering application

10.3.1 Choosing the right data structure

10.3.2 Squeezing parseIP performance

10.4 Summary

Part 3: Advanced Haskell

11 Type system advances

12 Metaprogramming in Haskell

Part 4: Haskell Toolkit

13 Concurrent programming

14 Effective input-output

15 Working with data

16 Implementing web services

What's inside

  • Organizing your projects with Cabal and Stack
  • Testing and profiling
  • Working with data
  • Building web services and networking apps
  • Using the sophisticated libraries like lens, vinyl, and servant

About the reader

Written for developers familiar with Haskell basics.

About the author

Since 2008, Vitaly Bragilevsky has been teaching Haskell and functional programming to undergraduate students at the Southern Federal University located in Rostov-on-Don, Russia. He is a member of the Haskell 2020 Committee, and has worked on the source code of the Glasgow Haskell Compiler (GHC) and the Idris compiler, both of which are implemented in Haskell.

placing your order...

Don't refresh or navigate away from the page.
Manning Early Access Program (MEAP) Read chapters as they are written, get the finished eBook as soon as it’s ready, and receive the pBook long before it's in bookstores.
print book $24.99 $49.99 pBook + eBook + liveBook
Additional shipping charges may apply
Haskell in Depth (print book) added to cart
continue shopping
go to cart

eBook $19.99 $39.99 3 formats + liveBook
Haskell in Depth (eBook) added to cart
continue shopping
go to cart

Prices displayed in rupees will be charged in USD when you check out.

FREE domestic shipping on three or more pBooks