¿Por qué esta afirmación de Haskell no se evalúa perezosamente?

Question

que tienen la siguiente función definida:

ex 1 x = 1 
ex 0 x = 0 
ex b x = b ** x 

Entonces, cuando yo haga lo siguiente:

1 `ex` (sum [1..]) 

que trata de calcular la suma de la secuencia infinita, en lugar de ser perezoso y regresar 1. ¿Por qué?

---

EDIT: Tras realizar investigaciones adicionales, he encontrado que la pereza ocurre si defino la función ex en un archivo, pero no si lo defino en GHCi:

$ ghci 
GHCi, version 6.8.2: http://www.haskell.org/ghc/ :? for help 
Loading package base ... linking ... done. 
Prelude> let ex 1 x = 1 
Prelude> let ex b x = b ** x 
Prelude> ex 1 (sum [1..]) 
<interactive>: out of memory (requested 1048576 bytes) 

Si me tire de la definición ex en un archivo (en este caso, test.hs):

$ ghci 
GHCi, version 6.8.2: http://www.haskell.org/ghc/ :? for help 
Loading package base ... linking ... done. 
Prelude> :load test.hs 
[1 of 1] Compiling Main    (test.hs, interpreted) 
Ok, modules loaded: Main. 
*Main> ex 1 (sum [1..]) 
1.0 

La nueva pregunta, entonces, es ¿por qué?

Answer 1

En GHCi, cada let declaración introduce una definición nueva de ex, en lugar de múltiples casos de patrones como se espera. Por lo tanto, se bloquea porque, cuando ingresa ex 1 (sum [1..]) después, solo existe la versión final ex b x = b ** x.

Si desea definir una función con múltiples casos de patrón en GHCi, tendrá que ponerlo en una sola let declaración, así:

let ex 1 x = 1; ex 0 x = 0; ex b x = b ** x 

Lo mismo se aplica para cualquier otra cosa que normalmente se escribirá en varias líneas, como la notación do. Por ejemplo, una función como esta:

f x = do 
    y <- get 
    put (x + y) 
    return y 

tendría que ser escrita como este en GHCi:

let f x = do { y <- get; put (x + y); return y } 

Answer 2

Perdí un punto de pereza, lo que hace que la respuesta a continuación sea falsa.

---

Debido sum calcula la suma total de todos los elementos de la secuencia. Que es, en tu caso, interminable.

es probable que desee

map ((curry ex) 1) [1..] 

Eso es

map -- map each item x to y 
    (
     (
      curry ex -- curry ex, to transform (x, y) -> z into x -> y -> z 
     ) 
     1 -- then invoke it with 1, which results in y -> z, x being 1 
    ) 
    [1..] -- the infinite sequence to be mapped. 

Answer 3

Prelude> let ex 1 x = 1 
Prelude> let ex b x = b ** x 

No está definiendo una función con dos casos aquí. Define una función con un caso y luego la define de nuevo anulando la definición anterior.

Para definir una función con dos patrones, utilice let ex 1 x = 1; ex b x = b ** x, es decir, separe las cajas con un punto y coma.