Different let in for lines in do block

Question

I want to create some tests with varying values, using hspec. I wrote the following code which does not compile but give an idea of what I am aiming at:

spec :: Spec
spec = do
    describe "productOneLine" $ do
        let
            inVector = Data.Vector.replicate 0 0
            inInteger = 3
            outVector = Data.Vector.replicate 1 0
        in
            it "must manage empty vector" $ productOneLine inVector inInteger `shouldBe` outVector
        let
            inVector = Data.Vector.fromList [2, 4, 5]
            inInteger = 4
            outVector = Data.Vector.fromList [9, 6, 1, 2]
        in
            it "must multiply a vector by an integer" $ productOneLine inVector inInteger `shouldBe` outVector

How can I create different sets of inVector, inInteger et outVector for each ligne beginning with it ?

Answer 1

Assuming you're getting the error:

parse error on input `in'

the problem is just indentation, as per @n.`pronouns'm.'s comment.

In most cases, a let block can be written with the let and in keywords lining up:

foo a b = let a2 = a*a
              b2 = b*b
          in a2 + b2
          ^
          `- let and in starting at same column

In fact, the in can be less indented than the let, it just needs to be indented more than the foo:

foo a b = let a2 = a*a
              b2 = b*b
  in a2 + b2

However, in a do block, an in-less let statement is allowed:

main = do
  let s = "Hello"
  putStrLn s

If you try to write:

main = do
  let s = "Hello"
  in PutStrLn s

the let s = "Hello" is parsed as a let statement, and the in PutStrLn s is parsed as a second do statement, with invalid syntax as it starts with the reserved word in.

You can write:

main = do
  let s = "Hello" in
    putStrLn s

or:

main = do
  let s = "Hello"
    in putStrLn s

or:

main = do
  let s = "Hello"
    in 
    putStrLn s

In each case, the indention will cause the entire expression let ... in ... to be parsed as a single expression, which is itself a valid do-statement. Combining two such statements is easy enough:

main = do
  let s = "Hello"
    in
    putStrLn s
  let s = "Goodbye"
    in
    putStrLn s

Answer 2

K. A. Buhr's answer is entirely correct. I'm adding this answer as a complementary description of what's going on in terms of Haskell's layout rules, which may help reason it out when a similar problem happens in a different context.

Almost all of Haskell's syntax is completely insensitive to indentation, but there are a few constructs that use alignment to indicate the entries within blocks of statements or definitions. do blocks are one such context. The rules are the same for all of them, though.

1. Each block has an alignment position for its entries. The position is set by the first non-whitespace character following the keyword introducing the block (regardless of whether it's own the same line or a following line).
2. A line indented to exactly the same alignment is the beginning of an "entry" in the block.
3. A line indented more than the alignment has no particular meaning; it's just part of an entry that started on an earlier line.
4. A line indented less than the alignment position indicates the end of the block (and is not itself part of the block, so it must be part of some enclosing syntax, which may or may not be an aligned block)

A consequence of this that may not be obvious is that when an entry in a block spans more than one line itself, every one of the continuation lines must be further indented than the first. If a continuation line was indented the same as the first, it would be taken as starting a new entry in the block instead of continuing an existing one, and if it was indented less it would be taken as indicating the end of the entire block.

How this applies to the OP's example is pretty straightforward.

spec :: Spec
spec = do
    describe "productOneLine" $ do
        let
            inVector = Data.Vector.replicate 0 0
            inInteger = 3
            outVector = Data.Vector.replicate 1 0
        in
            it "must manage empty vector" $ productOneLine inVector inInteger `shouldBe` outVector
        let
            inVector = Data.Vector.fromList [2, 4, 5]
            inInteger = 4
            outVector = Data.Vector.fromList [9, 6, 1, 2]
        in
            it "must multiply a vector by an integer" $ productOneLine inVector inInteger `shouldBe` outVector

The first character following the do keyword is the l in let (on the next line). So we can immediately see that this do block has 4 entries, starting with let, in, let, and in.

That's not what the OP intended; they wanted there to be 2 entries, each of which is a complete let ... in ... expression. To make that happen, the in keywords need to be further indented.

It does not matter that let ... in ... itself is a construct that uses aligned indentation. There's nothing in the above rules that would require in to be aligned with the let. The alignment position is the first character of the first declaration inside them (the i in inVector in each case), not the position of the l and it applies only to the block of declarations, not to the in part of the overall let ... in ... expression.

And in fact the in keyword of let ... in ... is totally insensitive to indentation. It can go anywhere (so long as it doesn't fall foul of an alignment set by an enclosing block, as happened in the OP's example). You can do this¹:

three = let x = 1
            y = 2
  in x + y

Or this²:

five = let x = 2
           y = 3 in x + y

Either way layout rules aren't necessary to tell that in keyword isn't part of the declaration block, only to tell where the beginning of each declaration in the block is.

---

¹ There is only one constraint on the placement of the in in this example. It can't go right at the beginning of the line, which is only because the global definitions in the module (spanning the entire file) actually are an aligned block! You just usually don't notice this, because it's conventional to use an alignment of zero indentation for this block.

² My usual style is this:

seven
  = let x = 3
        y = 4
     in x + y

which happens to work inside a do block without adjustment, a bonus I had never noticed before.