Lecture 26-1

Evaluation Strategies

inc x = x + 1
square x = x * x

So square (inc 2) = (2 + 1) * (2 + 1) = 9 . How does Haskell evaluate this?

In strict evaluation, we always apply the innermost function first:

square (inc 2)
	square (3)
	3 * 3
	9

Here we first apply inc and then apply square.

This means that when we call a function we first evaluate its argument.

This is the method that imperative languages use to evaluate functions. Haskell does not evaluate this way

In lazy evaluation, we always apply the outermost functions first:

square (inc 2)
	inc 2 * inc 2
	3 * 3
	9

First apply square then apply inc.

This method waits as long as possible until computing values.

In the following, nothing is computed until we ask for the value of z.

> let x = 1 + 1
> let y = x + x
> let z = y / 2
> z
2.0

> let x = 1 + undefined
> let y = x + x
> let z = y / 2
> z
*** Exception: Prelude.undefined

You can see here that the error only occurs when the binding is evaluated.

If a value is never used, it is never computed:

> let f x = 1
> f undefined
1

You can see here that the argument is not evaluated. This results in the program not crashing due to evaluating undefined.

Imperative languages are always strict:

For pure functions the order of evaluation is irrelevant.

Some functional languages are strict by default:

Others are lazy by default:

If strict evaluation finds an answer, the lazy evaluation fill find the same answer.

Sometimes lazy evaluation can find an answer when strict evaluation cannot:

> fst (1, 1 `div` 0)
1

A strict evaluator would crash in this example.

Sometimes lazy evaluation can be more efficient than strict:

Lazy evaluation only ever computed a value when it is needed. This can lead to big efficiency savings:

Strict evaluation:

Lazy evaluation:

1
[5,10,*** Exception: divide by zero

This is due to the fact that it evaluates last so will print the first two elements. This is opposed to crashing immediately.
*** Exception: divide by zero