Haskell: Where vs. Let

by

1: The problem in the example

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

is the parameter x. Things in the where clause can refer only to the parameters of the function f (there are none) and things in outer scopes.

2: To use a where in the first example, you can introduce a second named function
that takes the x as a parameter, like this:

f = State f'
f' x = y
    where y = ... x ...

or like this:

f = State f'
    where
    f' x = y
        where y = ... x ...

3: Here is a complete example without the ...‘s:

module StateExample where

data State a s = State (s -> (a, s))

f1 :: State Int (Int, Int)
f1 = State $ \state@(a, b) ->
    let
        hypot = a^2 + b^2
        result = (hypot, state)
    in result

f2 :: State Int (Int, Int)
f2 = State f
    where
    f state@(a, b) = result
        where
        hypot = a^2 + b^2
        result = (hypot, state)

4: When to use let or where is a matter of taste. I use let to emphasize a computation (by moving it to the front) and where to emphasize the program flow (by moving the computation to the back).

More Related Contents:

  1. In Haskell, when do we use in with let?
  2. `String’ is applied to too many type arguments
  3. How do I define Lisp’s apply in Haskell?
  4. Operating on a return from a Maybe that contains “Just”
  5. A monad is just a monoid in the category of endofunctors, what’s the problem?
  6. Is there a Haskell idiom for updating a nested data structure?
  7. What’s so bad about Lazy I/O?
  8. Positive integer type
  9. Explicitly import instances
  10. How to compare two functions for equivalence, as in (λx.2*x) == (λx.x+x)?
  11. Why do 3 and x (which was assigned 3) have different inferred types in Haskell? [duplicate]
  12. How do I use fix, and how does it work?
  13. List of different types?
  14. What is Levity polymorphism
  15. How to infer the type of an expression manually
  16. Understanding the Haskell as-pattern
  17. Type Constraints in Data Declaration Haskell
  18. Haskell: How to create most generic function possible that applies a function to tuple items
  19. Concrete example showing that monads are not closed under composition (with proof)?
  20. How to use (->) instances of Monad and confusion about (->)
  21. Why can a Num act like a Fractional?
  22. Composing function composition: How does (.).(.) work?
  23. Why doesn’t TypeSynonymInstances allow partially applied type synonyms to be used in instance heads?
  24. How do I convert a list to a tuple in Haskell?
  25. Implement zip using foldr
  26. How to enumerate a recursive datatype in Haskell?
  27. Why does OCaml sometimes require eta expansion?
  28. Does Haskell have return type overloading?
  29. Explanation of “tying the knot”
  30. Return specific type within Haskell

Leave a Comment