# seq

While its name might suggest otherwise, the `seq`

function's purpose is to introduce *strictness* to a Haskell program. As indicated by its type signature:

```
seq :: a -> b -> b
```

it takes two arguments of any type, and returns the second. However, it also has the important property that it is always strict in its first argument. In essence, `seq`

is defined by the following two equations:

```
⊥ `seq` b = ⊥
a `seq` b | a ≠ ⊥ = b
```

(See Bottom for an explanation of the `⊥`

symbol.)

A common misconception regarding `seq`

is that `seq x`

"evaluates" `x`

. Well, sort of. `seq`

doesn't evaluate anything just by virtue of existing in the source file, all it does is introduce an artificial data dependency of one value on another: when the result of `seq`

is evaluated, the first argument must also (sort of; see below) be evaluated. As an example, suppose `x :: Integer`

, then `seq x b`

behaves essentially like `if x == 0 then b else b`

– unconditionally equal to `b`, but forcing `x`

along the way. In particular, the expression `x `seq` x`

is completely redundant, and always has exactly the same effect as just writing `x`

.

Strictly speaking, the two equations of `seq`

are all it must satisfy, and if the compiler can statically prove that the first argument is not ⊥, or that its second argument *is*, it doesn't have to evaluate anything to meet its obligations. In practice, this almost never happens, and would probably be considered highly counterintuitive behaviour on the part of GHC (or whatever else you use to run your code). So for example, in `seq a b`

it is perfectly legitimate for `seq`

to:

- 1. evaluate
`b`

- its*second*argument,

- 2. before evaluating
`a`

- its first argument,

- 3. then returning
`b`

.

In this larger example:

```
let x = ... in
let y = sum [0..47] in
x `seq` 3 + y + y^2
```

`seq`

immediately evaluating its second argument (`3 + y + y^2`

) avoids having to allocate space to store `y`

:

```
let x = ... in
case sum [0..47] of
y -> x `seq` 3 + y + y^2
```

However, sometimes this ambiguity is undesirable, which is why `pseq`

also exists (but that's another story).

### Common uses of `seq`

`seq`

is typically used in the semantic interpretation of other strictness techniques, like strictness annotations in data types, or GHC's `BangPatterns` extension. For example, the meaning of this:

```
f !x !y = z
```

is this:

```
f x y | x `seq` y `seq` False = undefined
| otherwise = z
```

although that literal translation may not actually take place.

`seq`

is frequently used with accumulating parameters to ensure that they don't become huge thunks, which will be forced at the end anyway. For example, strict `foldl`

:

```
foldl' :: (a -> b -> a) -> a -> [b] -> a
foldl' _ z [] = z
foldl' f z (x:xs) = let z' = f z x in z' `seq` foldl' f z' xs
```

It's also used to define strict application:

```
($!) :: (a -> b) -> a -> b
f $! x = x `seq` f x
```

which is useful for some of the same reasons.

### Controversy!

Note that `seq`

is the *only* way to force evaluation of a value with a function type (except by applying it, which is liable to cause other problems). As such, it is the only reason why Haskell programs are able to distinguish between the following two values:

```
undefined :: a -> b
const undefined :: a -> b
```

This violates the principle from lambda calculus of extensionality of functions, or eta-conversion, because `f`

and `\x -> f x`

are distinct functions, even though they return the same output for *every* input. For this reason, `seq`

, and this distinction, is sometimes ignored e.g. when assessing the correctness of optimisation techniques or type class instances.