[Haskell-beginners] Parse error in pattern

[Daniel Fischer]

Am Freitag 26 Februar 2010 18:34:35 schrieb Florian Duret:
> It seems that both your suggestions have worked ! Thank you very much.
> But I still can't figure out what went wrong.

Did you change anything besides removing the "do" and "return ()" from the 
then-branch and insert the "do" in the else-branch?
If not, you've been bitten by a somewhat less than obvious aspect of layout 
- although it's pretty clear with an explanation.
A new layout-block isn't opened by a larger indentation, but by the 
keywords do, let, of and where.
So, when you write

... = do
  xxx
  if blah
    then do
      foo
      bar
    else
      baz
      zap

the "do" after the then opens a new layout-block inside the big do-block, 
since you didn't insert an explicit  brace. The indentation level thereof 
is determined by the 'f' of "foo", bar is indented to the same level as 
foo, so it's a new expression in that same block.
The else is indented less than the foo, so that ends the inner layout-block 
and we return to the layout-block of the big do-block. The indentation 
level thereof is determined by the first 'x', and the "if" is indented to 
the same level.
The else, the baz and the zap are all indented further than the if, so they 
all belong to the if-expression (as intended).
But since there's no "do" after the "else", all that is on one logical 
line, it's parsed as

... = do
  xxx
  if blah then do { foo; bar } else baz zap

Not what was intended, but it parses just fine.

Now you didn't have

      baz
      zap

but

      baz <- bong
      zap

and since we're still having only one logical line for the if-expression,
the parser sees that as

... = do
  xxx
  if blah then do { foo; bar } else baz <- bong zap

But the syntax is

  pattern <- expression

so the parser tries to parse

  if blah then do { foo; bar } else baz

as a pattern. But it doesn't conform to the pattern productions, hence the 
parse error.

>
> My initial goal was to keep the minimum inside the if ... then ... else
> statement. Basically, if the list is empty, then stop. If not, then
> assign the argument to sacFile1, and go on with the rest.

It would be cleanest to have

realWork :: FileName -> IO ()
realWork file = do
    sacFile1 <- openBinaryFile file ReadMode
    ...

main :: IO ()
main = do
    argList <- getArgs
    case argList of
      []    -> putStrLn "No filename ..."
      (f:_) -> realWork f

or

    if null argList
      then putStrLn "..."
      else realWork (head argList)

, je pense.

>
> Here is what it looks like now:
> module Main () where
>
> import System.IO
> import System.Environment(getArgs)
> import Data.Char(intToDigit)
>
> import SAC_Type
> import SAC_IO
>
> main :: IO()
> main = do
>      -- On commence par ouvrir le fichier SAC en mode binaire
>      argsList <- getArgs
>      if (null argsList)
>         then
>               putStrLn $ "No filename given to the program.\n $
> ProgramName file.sac"
>         else do
>            sacFile1 <- openBinaryFile (head argsList) ReadMode
>
>            position <- hTell sacFile1
>            putStrLn $ "Position 1: " ++ [intToDigit( fromInteger
> (position) )]
>
>            hSeek sacFile1 AbsoluteSeek 440
>            position2 <- hTell sacFile1
>            putStrLn $ "Position 2: " ++ [intToDigit( fromInteger
> (position2) )]

I don't think that's what you really want:

Prelude Data.Char> intToDigit 440
*** Exception: Char.intToDigit: not a digit 440

perhaps you wanted

        putStrLn $ "Position 2: " ++ show position2

?

>
>            -- A la fin, il faut evidemment le fermer
>            hClose sacFile1
>
>
> Thank you, Danke, 谢谢, merci, etc...