Indented import statement causes parsing error in stylish-haskell

Question

When trying to format the following test programme Char.hs, stylish-haskell reports a parsing error:

module Char (caesarCipher, caesarDecipher)
    where

    import Data.Char (ord, chr)

    caesarCipher :: Int -> [Char] -> [Char]
    caesarCipher shift msg = map (chr) $ map (+ shift) $ map (ord) msg

    caesarDecipher :: Int -> [Char] -> [Char]
    caesarDecipher shift msg = map (chr) $ map (subtract shift) $ map (ord) msg

Part of the verbose log by stylish-haskell:

$ stylish-haskell -v Char.hs          
...
Stylish Haskell will work basing on LANGUAGE pragmas in source files.
Enabled Cases step
Enabled Imports (ghc-lib-parser) step
Enabled LanguagePragmas step
Enabled TrailingWhitespace step
Extra language extensions: []
Char.hs: <string>:6:5: error: parse error on input `caesarCipher'

Where stylish-haskell has not been configured with any config files as reflected in the folded part of the verbose report; Char.hs is a standalone non-project file, and nothing did GHC complain throughout compilation:

$ ghc Char.hs   
[1 of 1] Compiling Char             ( Char.hs, Char.o )

---

After some testing, the problem seems to be about the import statement, in which:

• Stylish-haskell works fine after removing all the indents:

  module Char (caesarCipher, caesarDecipher)
  where
  
  import Data.Char (ord, chr)
  
  caesarCipher :: Int -> [Char] -> [Char]
  caesarCipher shift msg = map (chr) $ map (+ shift) $ map (ord) msg
  
  caesarDecipher :: Int -> [Char] -> [Char]
  caesarDecipher shift msg = map (chr) $ map (subtract shift) $ map (ord) msg
  

• Stylish-haskell also works when only removing the import statement, even though GHC complains about this:

  module Char (caesarCipher, caesarDecipher)
  where
  
      -- import Data.Char (chr, ord)
  
      caesarCipher :: Int -> [Char] -> [Char]
      caesarCipher shift msg = map (chr) $ map (+ shift) $ map (ord) msg
  
      caesarDecipher :: Int -> [Char] -> [Char]
      caesarDecipher shift msg = map (chr) $ map (subtract shift) $ map (ord) msg
  

Where the only thing making stylish-haskell unhappy seems to be the indented import statement. Just to clarify, I know import statements must be on the same indentation level as the others and I did not violate that in any situation; I've always been using the space character instead of tabs and I never mix them in any instances.

---

Therefore, my questions are:

• Is it syntactically accepted to indent the whole module body an extra level forward? I have not seen many code examples doing this, but neither some articles saying "don't do this"
• If yes, then what causes stylish-haskell not to work while the code is syntactically correct?
• If no, then why GHC says nothing about it?
• Is it possible to keep the indent while making stylish-haskell working on it?

To whom may be interested in, I'm using GHC 8.10.7 and stylish-haskell 0.14.1.0. Just shout to me if you need more info.

Answer 1

The indentation rules of Haskell are formally specified in section 10.3 of the Haskell report and a simplified version is given in section 2.7.

My understanding is the following (in the context of your programs).

1. The body of your program is a list of imports and top level declarations.
2. When using the layout rule all of these must have the same indentation.
3. The level of indentation is determined by the first declaration after the where from module.

So based on this all of the above programs should be correct. Though with a rather unconventional indentation.

Notes:

1. The body is everything that comes after module ...... where
2. The alternative to using the layout rule is to manually add braces {, } and semicolons ; to separate declarations, similar to how this is done in languages like C. This gives you a 'layout-insensitive program'
3. The actual definition of the Haskell syntax uses braces and semi-colons. The specification describes how the layout of your file can be translated into a layout-insensitive. See again 1 for the complete description of the algorithm and the following section 10.5 for the actual Haskell syntax definition.