Parallel and Concurrent Programming in Haskell
introduces the main programming models available for concurrent and
parallel
programming in Haskell. This tutorial takes a deliberately practical
approach: most of the examples are real Haskell programs that you can
compile, run, measure, modify and experiment with.

Chapters cover:

Parallel programming with the Eval monad

Evaluation Strategies

Dataow parallelism with the Par monad

Basic Concurrent Haksell

Asynchronous exceptions

Software Transactional Memory

Concurrency and the Foreign Function Interface

High-speed concurrent servers

In order to follow this tutorial you should have a basic
knowledge of Haskell, including programming with monads.

A Gentle Introduction to Haskell Version 98 is
intended to serve as a supplement to the Haskell Report. The authors
aim to offer a general introduction to Haskell for anyone who has some
experience of another language.

Chapters cover:

Introduction

Values, Types, and Other Goodies - all
computations are done via the evaluation of expressions (syntactic
terms) to yield values

Functions - looks at several aspects of functions in
Haskell

Case Expressions and Pattern Matching - looks at the
pattern-matching process in greater detail

Type Classes and Overloading

Types, Again - examines some of the more
advanced aspects of type declarations

Input/Output - the I/O system in Haskell is purely
functional, yet has all of the expressive power found in conventional
programming languages

Standard Haskell Classes - introduces the
predefined standard type classes in Haskell

Monads - addresses not only the language features
that involve monads but also tries to reveal the bigger picture: why
monads are such an important tool and how they are used

Numbers - Haskell provides a rich collection of
numeric types, based on those of Scheme, which in turn are based on
Common Lisp

Modules - serves the dual purpose of
controlling name-spaces and creating abstract data types

Typing Pitfalls - gives an intuitive
description of a few common problems that novices run into using
Haskell's type system

Arrays - index types, array creation, accumulation,
incremental updates, and an example: matrix multiplication

The aim of this book is to introduce the reader to both
the Haskell language and to computer programming in general. The book
covers all stages, from the very basics to the most advanced features
of Haskell. It is divided into 3 sections: The Beginner's
Track, the Advanced Track, and Practical Haskell.

Beginner's Track

The first section introduces the reader to the very
basics of the language and some of the more frequently used libraries.

Haskell Basics:

Getting set up - explore how to install the
programs you will need to start coding in Haskell

Variables and functions - keep track of
intermediate results. A function takes an argument value (or
parameter) and gives a result value, like a variable, that takes its
place

Truth values - equality and other comparisons,
boolean values, introduction to types, infix operators, boolean
operations, and guards

Type basics - Types in programming are a way of
grouping similar values into categories. In Haskell, the type system is
a powerful way of ensuring there are fewer mistakes in your code

Lists and tuples - the two most fundamental ways of
manipulating several values together, by grouping them into a single
value

Type basics II - the num class, numeric types, and
classes beyond numbers

Building vocabulary - discusses the importance of
acquiring a vocabulary of functions and how this book, along with other
resources, can help you with that

Next steps - introduces pattern matching, if
expressions and let bindings

Simple input and output - actions, and actions
under the microscope

Elementary Haskell:

Recursion - a form of repetition, looks at numeric
recursion, other recursive functions, and list-based recursion

More about lists - rebuilding lists, generalizing,
the map function, tips and tricks

List processing - folds, scans, filter, and list
comprehensions (a powerful, concise and expressive syntactic construct)

Type declarations - data and constructor functions,
deconstructing types, and type for making type synonyms

Pattern matching - takes a deeper look at pattern
matching

Control structures - introduces a new control
structure, case expressions

More on functions - let and where revisited,
anonymous functions - lambdas, operators and sections

Higher order functions and Currying - Higher-order
functions are functions that take other functions as arguments.
Currying is a technique that lets you partially apply a multi-parameter
function

Using GHCi effectively - describes several ways
that GHCi can make you work faster

Intermediate Haskell:

Modules - Haskell modules are a useful way to group
a set of related functionalities into a single
package and manage a set of different functions that have the same name

Indentation - helps the reader to get a grip with
the indentation rules

More on datatypes - enumerations, named fields
(record syntax), and parameterized types

Other data structures - trees, and other datatypes

Classes and types - see how to define and implement
type classes, and how to use them to our advantage

The Functor class - introduces the very important
Functor class, use it as a simple example of how type classes can be
useful tools for solving problems in a more general way

Monads:

Understanding monads - introduces the basic notions
with the example of the Maybe monad, the simplest monad for handling
exceptions

The Maybe monads - represents computations which
might "go wrong", in the sense of not returning a value

The List monad - taken as monads, lists are used to
model nondeterministic computations which may return an arbitrary
number of result

do Notation

The IO monad - solves some problems for Haskell
having simple input/output

The State monad - introduced to allow states of any
complexity to be represented

Additive monads (MonadPlus) - defines two methods.
mzero is the monadic value standing for zero results; while
mplus is a binary function which combines two computations

Monadic parser combinators - Monads provide a clean
means of embedding a domain specific parsing language directly
into Haskell without the need for external tools or code generators

Monad transformers - special types that allow us to
roll two monads into a single one that shares the behaviour of both

Practical monads - parsing monads and generic monads

Advanced
Track

This section introduces wider functional programming
concepts such as
different data structures and type theory. It also covers more
practical topics like concurrency.

Advanced Haskell:

Arrows - a generalization of monads: every
monad gives rise to an arrow, but not all arrows give rise to monads

Understanding arrows - presents arrows from the
perspective of stream processors, using the
factory metaphor from the monads module as a support

Continuation passing style (CPS) - a format for
expressions such that no function ever returns,
instead they pass control onto a continuation

Zippers - Theseus and the Zipper, differentiation
of data types

Applicative Functors - functors with some extra
properties, the most important one is
that it allows you to apply functions inside the functor (hence the
name) to other values

Monoids - a more detailed look into monoids and the
monoid type class

Mutable objects - discusses advanced programming
techniques for using imperative constructs, such as references
and mutable arrays, without compromising (too much) purity

Concurrency - in Haskell is mostly done with
Haskell threads

Fun with Types:

Polymorphism basics - parametric polymorphism, the
forall keyword, example: heterogeneous lists, explaining the term
existential, and example: runST

Advanced type classes - multi-parameter type
classes, functional dependencies, and examples

Phantom types - a way to embed a language with a
stronger type system than Haskell's

Generalised algebraic data-types (GADT) - allows
you to explicitly write down the types of the constructors. This
chapter explains why this is useful and how to declare them

Type constructors & Kinds

Wider Theory:

Denotational semantics - explains how to formalize
the meaning of Haskell programs, the
denotational semantics

Category theory - gives an overview of category
theory, in so far as it applies to Haskel

The Curry-Howard isomorphism - a striking
relationship connecting two seemingly
unrelated areas of mathematics — type theory and structural logic

fix and recursion

Haskell Performance:

Introduction - execution model, algorithms
& data structures, and parallelism

Step by Step Examples

Graph reduction - evaluating expressions by lazy
evaluation, controlling space, reasoning about time, and implementation
of graph reduction

Laziness

Strictness - difference between strict and lazy
evaluation, why laziness can be problematic

Algorithm complexity

Data structures

Parallelism

Haskell in Practice:

This section covers the more day-to-day issues of
working with Haskell,
issues such as making use of the standard library, building graphical
interfaces or working with databases.

Topics cover:

Libraries Reference:

The Hierarchical Libraries

Lists - the List datatype is the fundamental data
structure in Haskell

Arrays - the libraries support 9 types of array
constructors: Array, UArray, IOArray, IOUArray, STArray, STUArray,
DiffArray,
DiffUArray and StorableArray

Maybe - the Maybe data type

Maps - the module Data.Map provides the Map
datatype, which allows you to store values attached to specific keys

IO - looks at the IO library

Random Numbers - includes the standard random
number generator, and using QuickCheck to generate random data

General Practices:

Building a standalone application

Debugging - shows how to use the Debug.Trace module

Testing - testing with QuickCheck

Packing your software (Cabal) - a guide to the best
practice for creating a new Haskell project or program

Using the Foreign Function Interface (FFI) - using
libraries written in other languages

Generic Programming: Scrap your boilerplate - a way
to allow your data structures to
be traversed by so-called "generic" function

Specialised Tasks:

Graphical user interfaces - focuses on the
wxHaskell toolkit

Databases - general workflow, running queries

Web programming

Working with XML - examines libraries for parsing
and generating XML

Using Regular Expressions - a pointer to some good
tutorials

Parsing Mathematical Expression - discusses how to
turn strings of text such as "3*sin x + y" into an abstract
syntactic representation like Plus (Times (Number 3) (Apply "sin"
(Variable "x"))) (Variable "y")

The book is licensed under the Creative Commons
Attribution-ShareAlike 3.0 Unported license.