Chapter 2. Basic Parallelism: The Eval Monad
This chapter will teach you the basics of adding parallelism to your Haskell code. We’ll start with some essential background about lazy evaluation in the next section before moving on to look at how to use parallelism in The Eval Monad, rpar, and rseq.
Lazy Evaluation and Weak Head Normal Form
Haskell is a lazy language which means that expressions are not evaluated until they are required.[1] Normally, we don’t have to worry about how this happens; as long as expressions are evaluated when they are needed and not evaluated if they aren’t, everything is fine. However, when adding parallelism to our code, we’re telling the compiler something about how the program should be run: Certain things should happen in parallel. To be able to use parallelism effectively, it helps to have an intuition for how lazy evaluation works, so this section will explore the basic concepts using GHCi as a playground.
Let’s start with something very simple:
Prelude> let x = 1 + 2 :: Int
This binds the variable x to the expression 1 + 2 (at type Int, to avoid any complications due to overloading). Now, as far as
Haskell is concerned, 1 + 2 is equal to 3: We could have written
let x = 3 :: Int here, and there is no way to tell the difference by
writing ordinary Haskell code. But for the purposes of parallelism,
we really do care about the difference between 1 + 2 and 3,
because 1 + 2 is a computation that has not taken place yet, and we might be able to compute it ...