# Let vs. Where

Haskell programmers often wonder, whether to use `let`

or `where`

.
This seems to be only a matter of taste in the sense of "Declaration vs. expression_style",
however there is more about it.

It is important to know that `let ... in ...`

is an expression,
that is, it can be written whereever expressions are allowed.
In contrast to that, `where`

is bound to a surrounding syntactic construct,
like the pattern matching line of a function definition.

Consider you have the function

```
f :: s -> (a,s)
f x = y
where y = ... x ...
```

and later you decide to put this into the `Control.Monad.State`

monad.
However, transforming to

```
f :: State s a
f = State $ \x -> y
where y = ... x ...
```

will not work, because `where`

refers to the pattern matching `f =`

,
where no `x`

is in scope.

In contrast, if you had started with `let`

, then you wouldn't have trouble.

```
f :: s -> (a,s)
f x =
let y = ... x ...
in y
```

This is easily transformed to:

```
f :: State s a
f = State $ \x ->
let y = ... x ...
in y
```