Real World Haskell · Code You Can Believe In by O'Sullivan, Bryan -- Read -- Imperial Library of Trantor

Index

Real World Haskell Dedication A Note Regarding Supplemental Files Preface

Have We Got a Deal for You!

Novelty Power Enjoyment

What to Expect from This Book

A Little Bit About You

What to Expect from Haskell

Compared to Traditional Static Languages Compared to Modern Dynamic Languages Haskell in Industry and Open Source Compilation, Debugging, and Performance Analysis Bundled and Third-Party Libraries

A Brief Sketch of Haskell’s History

Prehistory Early Antiquity The Modern Era

Helpful Resources

Reference Material Applications and Libraries The Haskell Community

Conventions Used in This Book Using Code Examples Safari® Books Online How to Contact Us Acknowledgments

Bryan John Don Thank You to Our Reviewers

1. Getting Started

Your Haskell Environment Getting Started with ghci, the Interpreter Basic Interaction: Using ghci as a Calculator

Simple Arithmetic An Arithmetic Quirk: Writing Negative Numbers Boolean Logic, Operators, and Value Comparisons Operator Precedence and Associativity Undefined Values, and Introducing Variables Dealing with Precedence and Associativity Rules

Command-Line Editing in ghci Lists

Operators on Lists

Strings and Characters First Steps with Types A Simple Program

2. Types and Functions

Why Care About Types? Haskell’s Type System

Strong Types Static Types Type Inference

What to Expect from the Type System Some Common Basic Types Function Application Useful Composite Data Types: Lists and Tuples Functions over Lists and Tuples

Passing an Expression to a Function

Function Types and Purity Haskell Source Files, and Writing Simple Functions

Just What Is a Variable, Anyway? Conditional Evaluation

Understanding Evaluation by Example

Lazy Evaluation A More Involved Example Recursion Ending the Recursion Returning from the Recursion What Have We Learned?

Polymorphism in Haskell

Reasoning About Polymorphic Functions Further Reading

The Type of a Function of More Than One Argument Why the Fuss over Purity? Conclusion

3. Defining Types, Streamlining Functions

Defining a New Data Type

Naming Types and Values

Type Synonyms Algebraic Data Types

Tuples, Algebraic Data Types, and When to Use Each Analogues to Algebraic Data Types in Other Languages

The structure The enumeration The discriminated union

Pattern Matching

Construction and Deconstruction Further Adventures Variable Naming in Patterns The Wild Card Pattern Exhaustive Patterns and Wild Cards

Record Syntax Parameterized Types Recursive Types Reporting Errors

A More Controlled Approach

Introducing Local Variables

Shadowing The where Clause Local Functions, Global Variables

The Offside Rule and Whitespace in an Expression

A Note About Tabs Versus Spaces The Offside Rule Is Not Mandatory

The case Expression Common Beginner Mistakes with Patterns

Incorrectly Matching Against a Variable Incorrectly Trying to Compare for Equality

Conditional Evaluation with Guards

4. Functional Programming

Thinking in Haskell A Simple Command-Line Framework Warming Up: Portably Splitting Lines of Text

A Line-Ending Conversion Program

Infix Functions Working with Lists

Basic List Manipulation Safely and Sanely Working with Crashy Functions Partial and Total Functions More Simple List Manipulations Working with Sublists Searching Lists Working with Several Lists at Once Special String-Handling Functions

How to Think About Loops

Explicit Recursion Transforming Every Piece of Input Mapping over a List Selecting Pieces of Input Computing One Answer over a Collection The Left Fold Why Use Folds, Maps, and Filters? Folding from the Right Left Folds, Laziness, and Space Leaks Further Reading

Anonymous (lambda) Functions Partial Function Application and Currying

Sections

As-patterns Code Reuse Through Composition

Use Your Head Wisely

Tips for Writing Readable Code Space Leaks and Strict Evaluation

Avoiding Space Leaks with seq Learning to Use seq

5. Writing a Library: Working with JSON Data

A Whirlwind Tour of JSON Representing JSON Data in Haskell The Anatomy of a Haskell Module Compiling Haskell Source Generating a Haskell Program and Importing Modules Printing JSON Data Type Inference Is a Double-Edged Sword A More General Look at Rendering Developing Haskell Code Without Going Nuts Pretty Printing a String Arrays and Objects, and the Module Header Writing a Module Header Fleshing Out the Pretty-Printing Library

Compact Rendering True Pretty Printing Following the Pretty Printer

Creating a Package

Writing a Package Description GHC’s Package Manager Setting Up, Building, and Installing

Practical Pointers and Further Reading

6. Using Typeclasses

The Need for Typeclasses What Are Typeclasses? Declaring Typeclass Instances Important Built-in Typeclasses

Show Read Serialization with read and show Numeric Types Equality, Ordering, and Comparisons

Automatic Derivation Typeclasses at Work: Making JSON Easier to Use

More Helpful Errors Making an Instance with a Type Synonym

Living in an Open World

When Do Overlapping Instances Cause Problems? Relaxing Some Restrictions on Typeclasses How Does Show Work for Strings?

How to Give a Type a New Identity

Differences Between Data and Newtype Declarations Summary: The Three Ways of Naming Types

JSON Typeclasses Without Overlapping Instances The Dreaded Monomorphism Restriction Conclusion

7. I/O

Classic I/O in Haskell

Pure Versus I/O Why Purity Matters

Working with Files and Handles

More on openFile Closing Handles Seek and Tell Standard Input, Output, and Error Deleting and Renaming Files Temporary Files

Extended Example: Functional I/O and Temporary Files Lazy I/O

hGetContents readFile and writeFile A Word on Lazy Output interact

Filters with interact

The IO Monad

Actions Sequencing The True Nature of Return

Is Haskell Really Imperative? Side Effects with Lazy I/O Buffering

Buffering Modes Flushing The Buffer

Reading Command-Line Arguments Environment Variables

8. Efficient File Processing, Regular Expressions, and Filename Matching

Efficient File Processing

Binary I/O and Qualified Imports Text I/O

Filename Matching Regular Expressions in Haskell

The Many Types of Result

More About Regular Expressions

Mixing and Matching String Types Other Things You Should Know

Translating a glob Pattern into a Regular Expression An important Aside: Writing Lazy Functions Making Use of Our Pattern Matcher Handling Errors Through API Design Putting Our Code to Work

9. I/O Case Study: A Library for Searching the Filesystem

The find Command Starting Simple: Recursively Listing a Directory

Revisiting Anonymous and Named Functions Why Provide Both mapM and forM?

A Naive Finding Function Predicates: From Poverty to Riches, While Remaining Pure Sizing a File Safely

The Acquire-Use-Release Cycle

A Domain-Specific Language for Predicates

Avoiding Boilerplate with Lifting Gluing Predicates Together Defining and Using New Operators

Controlling Traversal Density, Readability, and the Learning Process Another Way of Looking at Traversal Useful Coding Guidelines

Common Layout Styles

10. Code Case Study: Parsing a Binary Data Format

Grayscale Files Parsing a Raw PGM File Getting Rid of Boilerplate Code Implicit State

The Identity Parser Record Syntax, Updates, and Pattern Matching A More Interesting Parser Obtaining and Modifying the Parse State Reporting Parse Errors Chaining Parsers Together

Introducing Functors

Constraints on Type Definitions Are Bad Infix Use of fmap Flexible Instances Thinking More About Functors

Writing a Functor Instance for Parse Using Functors for Parsing Rewriting Our PGM Parser Future Directions

11. Testing and Quality Assurance

QuickCheck: Type-Based Testing

Testing for Properties Testing Against a Model

Testing Case Study: Specifying a Pretty Printer

Generating Test Data Testing Document Construction Using Lists as a Model Putting It All Together

Measuring Test Coverage with HPC

12. Barcode Recognition

A Little Bit About Barcodes

EAN-13 Encoding

Introducing Arrays

Arrays and Laziness Folding over Arrays Modifying Array Elements

Encoding an EAN-13 Barcode Constraints on Our Decoder Divide and Conquer Turning a Color Image into Something Tractable

Parsing a Color Image Grayscale Conversion Grayscale to Binary and Type Safety

What Have We Done to Our Image? Finding Matching Digits

Run Length Encoding Scaling Run Lengths, and Finding Approximate Matches List Comprehensions Remembering a Match’s Parity

Another kind of laziness, of the keyboarding variety

Chunking a List Generating a List of Candidate Digits

Life Without Arrays or Hash Tables

A Forest of Solutions A Brief Introduction to Maps

Type constraints Partial application awkwardness Getting started with the API