Beginning Haskell by Mena, Alejandro Serrano -- Read -- Imperial Library of Trantor

Index

Cover Title Copyright Dedication Contents at a Glance Contents About the Author About the Technical Reviewer Acknowledgments Introduction Part 1: 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

Installing on Windows Installing on Mac OS X Installing on Linux Installing on Linux from Source Checking That the Installation is Successful Installing EclipseFP

First steps with GHCi The Time Machine Store Summary

Chapter 2: Declaring the Data Model

Working with Characters, Numbers, and Lists

Characters Numbers Strings Lists Lists Operations

Creating a New Project

Creating a Project from the Command Line Creating a Project from EclipseFP Understanding Modules

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: Reusing Code Through Lists

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 Packages with Cabal and EclipseFP Sandboxed Environments

Containers: Maps, Sets, Trees, Graphs

Maps Sets Trees Graphs Obtaining Help

Ad-hoc Polymorphism: Type Classes

Declaring Classes and Instances Built-in Type Classes

Binary Tress 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 2: 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 Rules 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, 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

Cloud Haskell

Looking for Galaxies Looking for Typed Galaxies Extra Features

Summary

Part 3: 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

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 Frameworks Compilation to Javascript

RESTful Structure Backend with Scotty

Simple Skeleton Showing Products from the Database Inserting New Products Using Forms

Frontend with Fay

Foreign Function Interface Fay and jQuery

Summary

Part 4: 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 Dependent Typing

Introducing Idris Enforcing the Presents Rule in Idris

Type-level Programming in Haskell

Two Styles of Programming Representing Natural Numbers

Functional Dependencies

Categories of Products with FDs Enforcing the Presents Rule with FDs

Type Families

Enforcing the Presents Rule with TFs Categories of Products with TFs

Data Type Promotion and Singletons

A Further Refinement to the Presents Rule 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

Executing the Attribute Grammar

Integrating UUAGC in Your Package Installing UUAGC UUAGC and Cabal

Expressions Interpretation

Using an Attribute Grammar Precomputing Some Values A Different (Monadic) View

Offer Interpretations

Checking the Presents Rule Showing a HTML Description

Origami Programming Over Any Data Type Summary

Part 5: 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 Idris Summary

Chapter 16: Architecting Your Application

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)

Tools

Project and Dependency Management Code Style Documentation Test and Verification Benchmarking Profiling Coverage Remote Monitoring

Projects

Data Mining Library Store Network Client Administration Interface and Tetris Roll Your Own Monad

Summary

Appendix A: Looking Further

Haskell Resources

Other Functional Languages

Appendix B: Time Traveling with Haskell

Index

← Prev
Back
Next →

← Prev
Back
Next →