book

Haskell in Depth

Name: Haskell in Depth
Author: Vitaly Bragilevsky
ISBN: 9781617295409

by Vitaly Bragilevsky

June 2021

Intermediate to advanced

664 pages

17h 16m

English

Manning Publications

Read now

Unlock full access

Haskell in Depth
Copyright
dedication
brief contents
contents
front matter
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
Part 1. Core Haskell
1 Functions and types
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 Type classes
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 Developing an application: Stock quotes
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

Part 2. Introduction to application design
4 Haskell development with modules, packages, and projects
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 Monads as practical functionality providers
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 Structuring programs with monad transformers
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
Part 3. Quality assurance
7 Error handling and logging
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 Writing tests
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 Haskell data and code at run time
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 Benchmarking and profiling
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
Part 4. Advanced Haskell
11 Type system advances
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 Metaprogramming in Haskell
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 More about types
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
Part 5. Haskell toolkit
14 Data-processing pipelines
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 Working with relational databases
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 Concurrency
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
appendix Further reading
BooksResearch papers
index

Content preview from Haskell in Depth

Part 1. Core Haskell

We have many ways to start learning Haskell. You could come to this book from pure mathematics, or from theoretical underpinnings of functional programming, or from practical tutorials. Consequently, Haskell beginners have very different backgrounds. In this part, we’ll fly over the main building blocks for Haskell programs—namely, functions, types, type classes, modules, projects, and external packages—to make sure that we are on the same page before diving deeper into Haskell.

Even though there should be nothing new here for a junior Haskell developer, we’ll still talk about plenty of good practices ranging from using Text instead of String and looking for help to the pragmatics of using abstractions in Haskell. In the ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781617295409Publisher Support Publisher Website Errata Page

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Haskell in Depth

by Vitaly Bragilevsky

Part 1. Core Haskell

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.