Haskell "donde" sangría: ¿por qué debe ser indentado pasado identificador?

Question

este código:

import Data.Char (digitToInt) 

myInt :: String -> Int 
myInt [] = error "bad input: empty string" 
myInt (x:xs) 
    | x == '-' = -1 * myInt xs 
    | otherwise = foldl convert 0 (x:xs) 
    where convert acc x 
     | x `elem` ['0'..'9'] = 10 * acc + digitToInt x 
     | otherwise   = error ("bad input: not an int - " ++ [x]) 

falla:

Prelude> :l safeListFs.hs 
[1 of 1] Compiling Main    (safeListFs.hs, interpreted) 

safeListFs.hs:9:8: parse error (possibly incorrect indentation) 
Failed, modules loaded: none. 

Pero esta versión:

import Data.Char (digitToInt) 

myInt :: String -> Int 
myInt [] = error "bad input: empty string" 
myInt (x:xs) 
    | x == '-' = -1 * myInt xs 
    | otherwise = foldl convert 0 (x:xs) 
    where convert acc x 
      | x `elem` ['0'..'9'] = 10 * acc + digitToInt x 
      | otherwise   = error ("bad input: not an int - " ++ [x]) 

está bien:

Prelude> :l safeListFs.hs 
[1 of 1] Compiling Main    (safeListFs.hs, interpreted) 
Ok, modules loaded: Main. 

no puedo entender por qué los dos últimos en las abolladuras importan

Answer 1

Básicamente, porque Haskell toma nota de la columna en la que el primer carácter no-espacio después de where aparece (en este caso, el c de convert) y trata la siguiente líneas que comienzan en esa columna como nuevas definiciones dentro de la where.

Una línea que continúa con la definición de la línea anterior (como las protecciones |) debe sangrarse a la derecha de c, como en su versión que funciona.

Una línea sangrada a la izquierda de c (no hay ninguna en su ejemplo) estaría fuera del where (por ejemplo, el inicio de su próxima función de nivel superior).

Es la columna del primer carácter siguiente where que es crucial, aunque sea en una nueva línea:

where 
    convert acc x 
     | ... 
    anotherFunction x y 

    ^

Answer 2

Porque siempre debe sangrar las definiciones de las funciones. (En su caso, todo lo que comenzó en la misma columna en where se considera definición de "mismo nivel").

Answer 3

Un contexto anidado debe sangrarse más que el contexto adjunto (n> m). De lo contrario, L falla y el compilador debe indicar un error de diseño.

De http://www.haskell.org/onlinereport/syntax-iso.html.

Esto también sería un fracaso:

import Data.Char (digitToInt) 

myInt :: String -> Int 
myInt [] = error "bad input: empty string" 
myInt (x:xs) 
| x == '-' = -1 * myInt xs 
| otherwise = foldl convert 0 (x:xs) 
where convert acc x 
     | x `elem` ['0'..'9'] = 10 * acc + digitToInt x 
     | otherwise   = error ("bad input: not an int - " ++ [x]) 

Uh, soy malo en explicar las cosas. Hay un nuevo contexto después de la palabra clave where, porque puede especificar más de una función allí; recuerde que su programa comienza con module Main where implícito, así que creo que es lógico requerir que el cuerpo de la función se sancione, al igual que en el nivel del módulo (compilador espera que otro identificador en las columnas M y N, y los cuerpos de declaración sean más indentados).

fun = ... 
^ where fun' = ... 
M  ^
     N 
     fun'' = ... 
fun2 = ...