Comandos multilínea en GHCi

Tengo problemas para ingresar comandos de varias líneas en ghci.

El siguiente código de 2 líneas funciona desde un archivo:

addTwo :: Int -> Int -> Int
addTwo x y = x + y

Pero cuando entro en ghci, aparece un error:

<interactive>:1:1: error:
    Variable not in scope: addTwo :: Int -> Int -> Int

También intenté poner el código dentro :{ ... :}, pero tampoco funcionan para este ejemplo, porque esto solo agrega las líneas en una línea, lo que no debería ser el caso.

Estoy usando WinGHCi, versión 2011.2.0.1

La mayoría de las veces, puede confiar en la inferencia de tipos para elaborar una firma para usted. En su ejemplo, lo siguiente es suficiente:

Prelude> let addTwo x y = x + y

Si realmente desea una definición con una firma de tipo, o su definición abarca varias líneas, puede hacerlo en ghci:

Prelude> :{
Prelude| let addTwo :: Int -> Int -> Int
Prelude|     addTwo x y = x + y 
Prelude| :}
Prelude> addTwo 4 7
11

Tenga en cuenta que también puede exprimir esto en una línea:

Prelude> let addTwo :: Int -> Int -> Int ; addTwo x y = x + y

Puede encontrar más información sobre cómo interactuar con ghci en la evaluación interactiva en la sección de solicitud de la documentación.

Resuelva este problema activando GHCI y escribiendo :set +m:

Prelude> :set +m
Prelude> let addTwo :: Int -> Int -> Int
Prelude|     addTwo x y = x + y
Prelude| 
Prelude> addTwo 1 3
4

Auge.

Lo que está sucediendo aquí (y te estoy hablando principalmente a ti , persona buscando ayuda en Google mientras te abres paso a través de Learn You A Haskell ) es que GHCI es un entorno interactivo donde estás cambiando enlaces de nombres de funciones sobre la marcha. Debe ajustar las definiciones de sus funciones en un letbloque, para que Haskell sepa que está a punto de definir algo. El :set +mmaterial es una abreviatura para la construcción del :{ código multilínea :}.

El espacio en blanco también es significativo en los bloques, por lo que debe sangrar la definición de su función después de su definición de tipo en cuatro espacios para tener en cuenta los cuatro espacios let.

Uso let:

Prelude> :{
Prelude| let addTwo :: Int -> Int -> Int
Prelude|     addTwo x y = x + y
Prelude| :}
Prelude> addTwo 2 3
5

A partir de GHCI versión 8.0.1 , letya no es necesario definir funciones en el REPL.

Entonces esto debería funcionar bien para usted:

λ: addTwo x y = x + y
λ: addTwo 1 2
3
λ: :t addTwo
addTwo :: Num a => a -> a -> a

La inferencia de tipos de Haskell proporciona una tipificación generalizada que también funciona para flotantes:

λ: addTwo 2.0 1.0
3.0

Si debe proporcionar su propio tipeo, parece que tendrá que usarlo letcombinado con entrada multilínea (use :set +mpara habilitar la entrada multilínea en GHCI):

λ: let addTwo :: Int -> Int -> Int
 |     addTwo x y = x + y
 | 
λ: addTwo 1 2
3

Pero obtendrá errores si intenta pasar cualquier cosa menos Intdebido a su escritura no polimórfica:

λ: addTwo 2.0 1.0

<interactive>:34:8: error:
    • No instance for (Fractional Int) arising from the literal ‘2.0’
    • In the first argument of ‘addTwo’, namely ‘2.0’
      In the expression: addTwo 2.0 1.0
      In an equation for ‘it’: it = addTwo 2.0 1.0

Para ampliar la respuesta de Aaron Hall , al menos en la versión GHCi 8.4.4, no necesita usar letdeclaraciones de tipo si usa el :{ :}estilo. Esto significa que no tiene que preocuparse por agregar la sangría de 4 espacios en cada línea posterior para tener en cuenta let, haciendo que las funciones más largas sean mucho más fáciles de escribir, o en muchos casos, copiar y pegar (ya que la fuente original probablemente no tendrá la sangría correcta):

λ: :{
 | addTwo :: Int -> Int -> Int
 | addTwo x y = x + y
 | :}
λ: addTwo 1 2
3

Actualizar

Como alternativa, puede activar el modo de entrada multilínea :set +m, luego escribir letsolo, presionar Entrar y luego pegar definiciones sin necesidad de sangría.

Sin embargo, esto no parece funcionar con algunos bloques de código, como:

class Box a where
  mkBox :: a -> Boxes.Box

Pero el :{, :}técnica hace.