Practical Haskell: A Real-World Guide to Functional Programming

Table of Contents
About the Author
About the Technical Reviewer
Acknowledgments
Introduction
Part I: First Steps
	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
Part II: Data Mining
	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
Part III: Resource Handling
	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
Part IV: Domain-Specific Languages
	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
Part V: Engineering the Store
	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: Time Travelling with Haskell
Index