Haskell in Depth

Description

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. Haskell in Depth brief contents contents foreword preface Functional programming Type system Lazy evaluation Tooling around Haskell What can be done using Haskell: Libraries acknowledgments about this book Who should read this book How this book is organized: A roadmap About the code Getting the sources Using cabal Using stack liveBook discussion forum about the author about the cover illustration Part 1: Core Haskell Chapter 1: Functions and types 1.1 Solving problems in the GHCi REPL with functions 1.2 From GHCi and String to GHC and Text 1.3 Functional programs as sets of IO actions 1.4 Embracing pure functions 1.4.1 Separating I/O from pure functions 1.4.2 Computing the most frequent words by sorting them 1.4.3 Formatting reports 1.4.4 Rule them all with IO actions Chapter 2: Type classes 2.1 Manipulating a radar antenna with type classes 2.1.1 The problem at hand 2.1.2 Rotating a radar antenna with Eq, Enum, and Bounded 2.1.3 Combining turns with Semigroup and Monoid 2.1.4 Printing and reading data with Show and Read 2.1.5 Testing functions with Ord and Random 2.2 Issues with numbers and text 2.2.1 Numeric types and type classes 2.2.2 Numeric conversions 2.2.3 Computing with fixed precision 2.2.4 More about Show and Read 2.2.5 Converting recursive types to strings 2.3 Abstracting computations with type classes 2.3.1 An idea of a computational context and a common behavior 2.3.2 Exploring different contexts in parallel 2.3.3 The do notation 2.3.4 Folding and traversing Chapter 3: Developing an application: Stock quotes 3.1 Setting the scene 3.1.1 Inputs 3.1.2 Outputs 3.1.3 Project structure 3.2 Exploring design space 3.2.1 Designing the user interface 3.2.2 Dealing with input data 3.2.3 Formatting reports 3.2.4 Plotting charts 3.2.5 Project dependencies overview 3.3 Implementation details 3.3.1 Describing data 3.3.2 Plotting charts 3.3.3 Preparing reports 3.3.4 Implementing the user interface 3.3.5 Connecting parts Part 2: Introduction to application design Chapter 4: Haskell development with modules, packages, and projects 4.1 Organizing Haskell code with modules 4.1.1 Module structure, imports and exports, and module hierarchy 4.1.2 Custom Preludes 4.1.3 Example: containers-mini 4.2 Understanding Haskell packages 4.2.1 Packages at the GHC level 4.2.2 Cabal packages and Hackage 4.3 Tools for project development 4.3.1 Dependency management 4.3.2 Haskell projects as a collection of packages 4.3.3 Common project management activities and tools Chapter 5: Monads as practical functionality providers 5.1 Basic monads in use: Maybe, Reader, Writer 5.1.1 Maybe monad as a line saver 5.1.2 Carrying configuration all over the program with Reader 5.1.3 Writing logs via Writer 5.2 Maintaining state via the State monad 5.2.1 Basic examples with the State monad 5.2.2 Parsing arithmetic expressions with State 5.2.3 RWS monad to rule them all: The game of dice 5.3 Other approaches to mutability 5.3.1 Mutable references in the IO monad 5.3.2 Mutable references in the ST monad Chapter 6: Structuring programs with monad transformers 6.1 The problem of combining monads 6.1.1 Evaluating expressions in reverse Polish notation 6.1.2 Introducing monad transformers and monad stacks 6.2 IO-based monad transformer stacks 6.2.1 Describing a monad stack 6.2.2 Exploiting monad stack functionality 6.2.3 Running an application 6.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 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 Part 3: Quality assurance Chapter 7: Error handling and logging 7.1 Overview of error-handling mechanisms in Haskell 7.1.1 The idea of exceptions 7.1.2 To use or not to use? 7.1.3 Programmable exceptions vs. GHC runtime exceptions 7.2 Programmable exceptions in monad stacks 7.2.1 The ExceptT monad transformer 7.2.2 Example: Evaluating RPN expressions 7.3 GHC runtime exceptions 7.3.1 An idea of extensible exceptions 7.3.2 Throwing exceptions 7.3.3 Catching exceptions 7.4 Example: Accessing web APIs and GHC exceptions 7.4.1 Application components 7.4.2 Exception-handling strategies 7.5 Logging 7.5.1 An overview of the monad-logger library 7.5.2 Introducing logging with monad-logger into the suntimes project Chapter 8: Writing tests 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 testing 8.3.1 Testing functions à la the REPL with doctest 8.3.2 Lightweight verification with LiquidHaskell 8.3.3 Code quality with hlint Chapter 9: Haskell data and code at run time 9.1 A mental model for Haskell memory usage at run time 9.1.1 General memory structure and closures 9.1.2 Primitive unboxed data types 9.1.3 Representing data and code in memory with closures 9.1.4 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 Optimizing code manually 9.3.2 Looking at GHC Core Chapter 10: Benchmarking and profiling 10.1 Benchmarking functions with criterion 10.1.1 Benchmarking implementations of a simple function 10.1.2 Benchmarking an 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 time 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 Part 4: Advanced Haskell Chapter 11: Type system advances 11.1 Haskell types 101 11.1.1 Terms, types, and kinds 11.1.2 Delivering information with types 11.1.3 Type operators 11.2 Data kinds and type-level literals 11.2.1 Promoting types to kinds and values to types 11.2.2 Type-level literals 11.3 Computations over types with type families 11.3.1 Open and closed type synonym families 11.3.2 Example: Avoid character escaping in GHCi 11.3.3 Data families 11.3.4 Associated families 11.4 Generalized algebraic data types 11.4.1 Example: Representing dynamically typed values with GADTs 11.4.2 Example: Representing arithmetic expressions with GADTs 11.5 Arbitrary-rank polymorphism 11.5.1 The meaning 11.5.2 Use cases 11.6 Advice on dealing with type errors 11.6.1 Be explicit about types 11.6.2 Ask the compiler 11.6.3 Saying more about errors Chapter 12: Metaprogramming in Haskell 12.1 Deriving instances 12.1.1 Basic deriving strategies 12.1.2 The problem of type safety and generalized newtype deriving 12.1.3 Deriving by an example with DerivingVia 12.2 Data-type-generic programming 12.2.1 Generic data-type representation 12.2.2 Example: Generating SQL queries 12.3 Template Haskell and quasiquotes 12.3.1 A tutorial on Template Haskell 12.3.2 Example: Generating remote function calls Chapter 13: More about types 13.1 Types for specifying a web API 13.1.1 Implementing a web API from scratch 13.1.2 Implementing a web service with servant 13.2 Toward dependent types with singletons 13.2.1 Safety in Haskell programs 13.2.2 Example: Unsafe interface for elevators 13.2.3 Dependent types and substituting them with singletons 13.2.4 Example: Safe interface for elevators Part 5: Haskell toolkit Chapter 14: Data-processing pipelines 14.1 Streaming data 14.1.1 General components and naive implementation 14.1.2 The streaming package 14.2 Approaching an implementation of pipeline stages 14.2.1 Reading and writing data efficiently 14.2.2 Parsing data with parser combinators 14.2.3 Accessing data with lenses 14.3 Example: Processing COVID-19 data 14.3.1 The task 14.3.2 Processing data 14.3.3 Organizing the pipeline Chapter 15: Working with relational databases 15.1 Setting up an example 15.1.1 Sample database 15.1.2 Sample queries 15.1.3 Data representation in Haskell 15.2 Haskell database connectivity 15.2.1 Connecting to a database 15.2.2 Relating Haskell data types to database types 15.2.3 Constructing and executing SELECT queries 15.2.4 Manipulating data in a database 15.2.5 Solving tasks by issuing many queries 15.3 The postgresql-simple library 15.3.1 Connecting to a database 15.3.2 Relating Haskell data types to database types 15.3.3 Executing queries 15.4 The hasql ecosystem 15.4.1 Structuring programs with hasql 15.4.2 Constructing type-safe SQL statements 15.4.3 Implementing database sessions 15.4.4 Running database sessions 15.4.5 The need for low-level operations and decoding data manually 15.5 Generating SQL with opaleye 15.5.1 Structuring programs with opaleye 15.5.2 Describing database tables and their fields 15.5.3 Writing queries 15.5.4 Running queries Chapter 16: Concurrency 16.1 Running computations concurrently 16.1.1 An implementation of concurrency in GHC 16.1.2 Low-level concurrency with threads 16.1.3 High-level concurrency with the async package 16.2 Synchronization and communication 16.2.1 Synchronized mutable variables and channels 16.2.2 Software transactional memory (STM) appendix: Further reading Books Research papers index Symbols A B C D E F G H I J K L M N O P Q R S T U V W X Y Z