Practical Haskell: A Real-World Guide to Functional Programming

Table of Contents
About the Author
About the Technical Reviewer
Acknowledgments
Introduction
Chapter 1: Going Functional
	Why Haskell?
		Why Pure Functional Programming?
		Why Strong Static Typing?
		The Haskell Ecosystem
	The History of Haskell
	Your Working Environment
	First Steps with GHCi
	The Time Machine Store
	Summary
Chapter 2: Declaring the Data Model
	Characters, Numbers, and Lists
		Characters
		Numbers
		Strings
		Lists
	Creating a New Project
		Creating a Project with Cabal
		Creating a Project with Stack
		Understanding Modules
		Cabal and Stack
	Defining Simple Functions
		Creating a Simple Function
		Specifying the Function’s Type
		Developing a Robust Example
		Returning More Than One Value
	Working with Data Types
		Pattern Matching
			Simple Patterns
			Lists and Tuples
			Guards
			View Patterns
		Records
			Creation and Use
			The Default Values Idiom
	Summary
Chapter 3: Increasing Code Reuse
	Parametric Polymorphism
	Functions As Parameters
		Higher-Order Functions
		Anonymous Functions
		Partial Application of a Function
	More on Modules
		Module Imports
		Smart Constructors and Views
	Diving into Lists
		Folds
		Lists and Predicates
		Lists Containing Tuples
		List Comprehensions
	Haskell Origami
	Summary
Chapter 4: Using Containers and Type Classes
	Using Packages
		Managing Dependencies
		Building Packages
			Building Packages with Cabal
			Building Packages with Stack
		Obtaining Help
	Containers: Maps, Sets, Trees, Graphs
		Maps
		Sets
		Trees
		Graphs
	Ad Hoc Polymorphism: Type Classes
		Declaring Classes and Instances
		Built-In Type Classes
	Binary Trees for the Minimum Price
		Step 1: Simple Binary Trees
		Step 2: Polymorphic Binary Trees
		Step 3: Binary Trees with Monoidal Cache
	Container-Related Type Classes
		Functors
		Foldables
	Summary
Chapter 5: Laziness and Infinite Structures
	An Infinite Number of Time Machines
	Lazy Evaluation Model
		Understanding Evaluation in Haskell
		Problems with Laziness
		Pattern Matching and Laziness
		Profiling with GHC
	Strictness Annotations
	Summary
Chapter 6: Knowing Your Clients Using Monads
	Data Mining
		Implementing K-means
		Lenses
	Discovering Monads
		Watching Out for Incomplete Data
		Combinators for State
		Dissecting the Combinators
		do Notation
		Monad Laws
	Different Sorts of State
		State and Lenses
		Reader, Writer, and RWS
		Mutable References with ST
	Summary
Chapter 7: More Monads: Now for Recommendations
	Returning More Than One Value
		The List Monad
		A New View over Monads
		Failures and Alternatives
	Association Rule Learning
		Flattening Values into Transactions
		The Apriori Algorithm
	Search Problems
		Paths in a Graph
		The Logic Monad
	Monads and Lists, Redux
		Combining Values Under a Monad
		Monad Comprehensions
	Combining Monads
		Monad Transformers
		Monad Classes
	Summary
Chapter 8: Working in Several Cores
	Parallelism, Concurrency, and Distribution
	The Par Monad
		Futures
		Dataflow Parallelism with IVars
		Parallelizing the Apriori Algorithm
	Software Transactional Memory
		Concurrent Use of Resources
		Atomic Transactions
		Rolling Back Transactions
	Producer-Consumer Queues
		Single-Process Queues
		Message Queues Using AMQP
		AMQP in Haskell
	Summary
Chapter 9: Dealing with Files: IO and Conduit
	Basic Input and Output
	Randomness
	Working with Files
		Reading and Writing
		Handling Files
	Error Handling
		Pure Errors
		Catching Exceptions
		Throwing Exceptions
	Streaming Data with Conduit
		Problems with Lazy Input/Output
		Introducing Conduits
		Accessing Files via Conduit
	Looking Further Than Text Files
		Basic Networking
		Binary Serialization
		Comma-Separated Values
	Summary
Chapter 10: Building and Parsing Text
	The Five Textual Data Types
	Building As Fast As the Wind
	Parsing with attoparsec
	Introducing New Type Classes
		Applicative
		Functors, Applicatives, and Monads
		Alternative
		Traversable
	Don’t Overengineer: Just Use JSON
	Summary
Chapter 11: Safe Database Access
	Database Access Landscape
		Abstracting Over Several DBMSs
		Introducing Persistent and Esqueleto
	Connection
	Schemas and Migrations
		Describing the Entities
		Creating the Database
	Queries
		Queries by Identifier or Uniqueness
		Selecting Several Entities
		SQL Queries with Esqueleto
	Insertions, Updates, and Deletions
	Summary
Chapter 12: Web Applications
	Haskell Web Ecosystem
		Web Applications
		Compilation to JavaScript
	RESTful Structure
	Back End with WAI
		Simple Skeleton
		Showing Products from the Database
		Inserting New Products Using Forms
	Front End with Elm
		Retrieving Products
	Summary
Chapter 13: Strong Types for  Describing Offers
	Domain-Specific Languages
		Embedding Your Language in Haskell
	The Offers Language
		Adding Safety to the Expression Language
	Type-Level Programming
		Two Styles of Programming
		Representing Natural Numbers
	Functional Dependencies
		Categories of Products with FDs
		Vectors Using FDs
		Enforcing the Presents Rule with FDs
	Type Families
		Vectors Using TFs
		Enforcing the Presents Rule with TFs
		Categories of Products with TFs
	Data Type Promotion and Singletons
		A Further Refinement to the Presents Rule
		Cooking with Singletons
		Enforcing the Duration Rule
	Summary
Chapter 14: Interpreting Offers with Attributes
	Interpretations and Attribute Grammars
		A Simple Interpretation
		Introducing Attribute Grammars
	Your First Attribute Grammar
		Synthesizing the Result
		Integrating UUAGC in Your Package
		Executing the Attribute Grammar
	Expression Interpretation
		Using an Attribute Grammar
		Precomputing Some Values
		A Different (Monadic) View
	Offer Interpretations
		Checking the Presents Rule
		Showing an HTML Description
	Programming with Data Types
		Origami Programming over Any Data Type
		Data Type–Generic Programming
	Summary
Chapter 15: Documenting, Testing, and Verifying
	Documenting Binary Trees with Haddock
	Unit Testing with HUnit
		Declaring Tests in Cabal
		Writing Unit Tests
	Randomized Testing with QuickCheck
		Testing List Properties
		Testing Binary Tree Properties
	Formal Verification with LiquidHaskell
		Describing Binary Search Trees
	Summary
Chapter 16: Architecting Your Application
	Tools
		Project and Dependency Management
		Code Style
		Documentation
		Test and Verification
		Benchmarking
		Profiling
		Coverage
		Remote Monitoring
	Design Patterns and Functional Programming
	Medium-Level Guidelines
		Use Higher-Order Combinators
		Refactor
		Use Type Classes Wisely
		Enforce Invariants via the Type System
		Stay (As) Pure and Polymorphic (As Possible)
	Patterns with Monads
		Summary of Monads
		Restrictive Monad Classes
		Roll Your Own Monad
	Summary
Chapter 17: Looking Further
	Projects
		Data Mining Library
		Store Network Client
		Administration Interface and Tetris
	Additional Haskell Resources
		Other Functional Languages
Appendix A
Index