Comandos de várias linhas no GHCi

Estou tendo problemas ao inserir comandos de várias linhas no ghci.

O seguinte código de duas linhas funciona a partir de um arquivo:

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

Mas quando entro em ghci, recebo um erro:

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

Eu também tentei colocar o código dentro :{ ... :}, mas eles também não estão funcionando neste exemplo, porque isso é apenas anexar as linhas em uma linha, o que não deve ser o caso.

Estou usando o WinGHCi, versão 2011.2.0.1

Na maioria das vezes, você pode confiar na inferência de tipo para elaborar uma assinatura para você. No seu exemplo, o seguinte é suficiente:

Prelude> let addTwo x y = x + y

Se você realmente deseja uma definição com uma assinatura de tipo ou sua definição se estende por várias linhas, você pode fazer isso em ghci:

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

Observe que você também pode compactar isso em uma linha:

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

Você pode descobrir mais sobre como interagir com o ghci na avaliação interativa na seção de prompt da documentação.

Resolva esse problema iniciando o GHCI e digitando :set +m:

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

Estrondo.

O que está acontecendo aqui (e eu estou falando principalmente com você , pesquisando em busca de ajuda enquanto trabalha no Learn You A Haskell ) é que o GHCI é um ambiente interativo no qual você altera as ligações dos nomes das funções em tempo real. Você precisa agrupar suas definições de função em um letbloco, para que Haskell saiba que você está prestes a definir alguma coisa. O :set +mmaterial é uma abreviação para a construção de :{ código de várias linhas:} .

O espaço em branco também é significativo em blocos, portanto, você deve recuar sua definição de função após a definição de tipo por quatro espaços para contabilizar os quatro espaços em let.

Use let:

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

A partir do GHCI versão 8.0.1 , letnão é mais necessário definir funções no REPL.

Portanto, isso deve funcionar bem para você:

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

A inferência de tipo de Haskell fornece digitação generalizada que também funciona para carros alegóricos:

λ: addTwo 2.0 1.0
3.0

Se você precisar fornecer sua própria digitação, parece que precisará usar letcombinado com :set +ma entrada de várias linhas (use para ativar a entrada de várias linhas no GHCI):

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

Mas você receberá erros se tentar passar algo além de uma Intpor causa da sua digitação não 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 expandir a resposta de Aaron Hall , na versão GHCi 8.4.4, pelo menos, você não precisa usar as letdeclarações de tipo se usar o :{ :}estilo. Isso significa que você não precisa se preocupar em adicionar a indentação de quatro espaços em cada linha subseqüente a ser considerada let, facilitando muito a digitação de funções mais longas ou, em muitos casos, copiar e colar (já que a fonte original provavelmente não terá o recuo correto):

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

Atualizar

Como alternativa, você pode ativar o modo de entrada de várias linhas com :set +me digitelet por si próprio, pressionar Enter e colar definições sem recuo necessário.

No entanto, isso não parece funcionar com alguns blocos de código, como:

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

Mas a :{, :}técnica faz.