In Haskell, when do we use in with let?

by

Short answer: Use let without in in the body of a do-block, and in the part after the | in a list comprehension. Anywhere else, use let ... in ....

The keyword let is used in three ways in Haskell.

  1. The first form is a let-expression.

    let variable = expression in expression

    This can be used wherever an expression is allowed, e.g.

    > (let x = 2 in x*2) + 3
7

  2. The second is a let-statement. This form is only used inside of do-notation, and does not use in.

    do statements
   let variable = expression
   statements

  3. The third is similar to number 2 and is used inside of list comprehensions. Again, no in.

    > [(x, y) | x <- [1..3], let y = 2*x]
[(1,2),(2,4),(3,6)]

    This form binds a variable which is in scope in subsequent generators and in the expression before the |.

The reason for your confusion here is that expressions (of the correct type) can be used as statements within a do-block, and let .. in .. is just an expression.

Because of the indentation rules of haskell, a line indented further than the previous one means it’s a continuation of the previous line, so this

do let x = 42 in
     foo

gets parsed as

do (let x = 42 in foo)

Without indentation, you get a parse error:

do (let x = 42 in)
   foo

In conclusion, never use in in a list comprehension or a do-block. It is unneccesary and confusing, as those constructs already have their own form of let.

More Related Contents:

  1. Haskell: Where vs. Let
  2. Why shouldn’t I mix tabs and spaces?
  3. Expressing do block using only monadic bind syntax
  4. making permutation from two list but not using full number [closed]
  5. Answer to this Haskell expression [closed]
  6. Haskell, tuple (double, string) [closed]
  7. scrambling txt file using compiler [closed]
  8. Applicatives compose, monads don’t
  9. A Haskell function of type: IO String-> String
  10. Haskell: Parse error in pattern
  11. IO happens out of order when using getLine and putStr
  12. What is indexed monad?
  13. What does $ mean/do in Haskell?
  14. Why are polymorphic values not inferred in Haskell?
  15. Cabal not installing dependencies when needing profiling libraries?
  16. Library function to compose a function with itself n times
  17. Should do-notation be avoided in Haskell?
  18. Why doesn’t Haskell sequence these IO actions properly?
  19. Why doesn’t this function work if I use “[xs]” instead of “xs”?
  20. Understanding the Haskell as-pattern
  21. Haskell: How to create most generic function possible that applies a function to tuple items
  22. Concrete example showing that monads are not closed under composition (with proof)?
  23. How to use (->) instances of Monad and confusion about (->)
  24. Why can a Num act like a Fractional?
  25. Composing function composition: How does (.).(.) work?
  26. Why doesn’t TypeSynonymInstances allow partially applied type synonyms to be used in instance heads?
  27. How do I convert a list to a tuple in Haskell?
  28. Implement zip using foldr
  29. How to enumerate a recursive datatype in Haskell?
  30. Return specific type within Haskell

Leave a Comment