Comandi multilinea in GHCi

Sto riscontrando problemi nell'inserimento di comandi multilinea in ghci.

Il seguente codice a 2 righe funziona da un file:

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

Ma quando entro in ghci, ricevo un errore:

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

Ho anche provato a inserire il codice all'interno :{ ... :}, ma non funzionano anche per questo esempio, perché questo sta semplicemente aggiungendo le righe in una riga, il che non dovrebbe essere il caso.

Sto usando WinGHCi, versione 2011.2.0.1

Il più delle volte, puoi fare affidamento sull'inferenza del tipo per elaborare una firma per te. Nel tuo esempio, è sufficiente quanto segue:

Prelude> let addTwo x y = x + y

Se vuoi davvero una definizione con una firma di tipo, o la tua definizione si estende su più righe, puoi farlo in ghci:

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

Nota che puoi anche comprimerlo su una riga:

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

Puoi scoprire di più sull'interazione con ghci nella valutazione interattiva nella sezione prompt della documentazione.

Risolvi questo problema accendendo 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

Boom.

Quello che sta succedendo qui (e sto parlando principalmente con te , persona che cerca su Google mentre ti fai strada attraverso Learn You A Haskell ) è che GHCI è un ambiente interattivo in cui stai cambiando i collegamenti dei nomi delle funzioni al volo. Devi racchiudere le definizioni delle funzioni in un letblocco, in modo che Haskell sappia che stai per definire qualcosa. Il :set +mmateriale è una scorciatoia per il costrutto del :{ codice multilinea :}.

Anche lo spazio bianco è significativo in blocchi, quindi è necessario rientrare la definizione della funzione dopo la definizione del tipo di quattro spazi per tenere conto dei quattro spazi in let.

Utilizzare let:

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

A partire dalla versione 8.0.1 di GHCI , letnon è più necessario definire le funzioni sul REPL.

Quindi questo dovrebbe funzionare bene per te:

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

L'inferenza di tipo di Haskell fornisce una tipizzazione generalizzata che funziona anche per i float:

λ: addTwo 2.0 1.0
3.0

Se è necessario fornire la propria digitazione, sembra che sia necessario utilizzare in letcombinazione con l'input multilinea (utilizzare :set +mper abilitare l'input multilinea in GHCI):

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

Ma otterrai errori se provi a passare qualsiasi cosa tranne una a Intcausa della tua digitazione non polimorfica:

λ: 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

Per espandere la risposta di Aaron Hall , almeno nella versione GHCi 8.4.4, non è necessario utilizzare le letdichiarazioni di tipo se si utilizza lo :{ :}stile. Ciò significa che non devi preoccuparti di aggiungere il rientro di 4 spazi su ogni riga successiva da tenere in considerazione let, rendendo le funzioni più lunghe molto più facili da digitare o, in molti casi, copia-incolla (poiché la fonte originale probabilmente non avrà il rientro corretto):

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

Aggiornare

In alternativa è possibile attivare la modalità di input su più righe con :set +m, quindi digitare letautonomamente, premere Invio, quindi incollare le definizioni senza necessità di rientro.

Tuttavia, questo non sembra funzionare con alcuni blocchi di codice, come:

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

Ma il :{, :}tecnica fa.