Polecenia wieloliniowe w GHCi

Mam problem z wprowadzaniem poleceń wielowierszowych w ghci.

Poniższy dwuwierszowy kod działa z pliku:

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

Ale kiedy wchodzę w ghci, pojawia się błąd:

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

Próbowałem też umieścić kod w środku :{ ... :}, ale one również nie działają w tym przykładzie, ponieważ jest to po prostu dołączanie wierszy do jednej linii, co nie powinno mieć miejsca.

Używam WinGHCi w wersji 2011.2.0.1

W większości przypadków możesz polegać na wnioskowaniu o typie, aby opracować podpis za Ciebie. W Twoim przykładzie wystarczy:

Prelude> let addTwo x y = x + y

Jeśli naprawdę potrzebujesz definicji z podpisem typu lub jeśli twoja definicja obejmuje wiele linii, możesz to zrobić w ghci:

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

Zauważ, że możesz również wcisnąć to w jedną linię:

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

Więcej informacji na temat interakcji z ghci można znaleźć w interaktywnej ocenie w sekcji instrukcji w dokumentacji.

Rozwiąż ten problem, uruchamiając GHCI i wpisując :set +m:

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

Bum.

To, co się tutaj dzieje (i mówię głównie do ciebie , osoby szukającej pomocy podczas pracy w Learn You A Haskell ), to fakt, że GHCI to interaktywne środowisko, w którym zmieniasz wiązania nazw funkcji w locie. Musisz zawinąć definicje funkcji w letblok, aby Haskell wiedział, że masz zamiar coś zdefiniować. To :set +mjest skrótem dla konstrukcji :{ kodu wielowierszowego :}.

Białe znaki są również istotne w blokach, więc musisz dodać wcięcie definicji funkcji po definicji typu o cztery spacje, aby uwzględnić cztery spacje w let.

Zastosowanie let:

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

Począwszy od GHCI wersji 8.0.1 , letnie jest już wymagane do zdefiniowania funkcji na REPL.

Więc to powinno działać dobrze dla Ciebie:

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

Wnioskowanie o typie Haskella zapewnia uogólnione typowanie, które działa również dla pływaków:

λ: addTwo 2.0 1.0
3.0

Jeśli musisz podać własne wpisywanie, wydaje się, że będziesz musiał użyć letpołączenia z wejściem wielowierszowym (użyj, :set +maby włączyć wprowadzanie wielowierszowe w GHCI):

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

Ale pojawią się błędy, jeśli spróbujesz przekazać coś innego niż z Intpowodu niepolimorficznego pisania:

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

Aby rozwinąć odpowiedź Aarona Halla , przynajmniej w wersji GHCi 8.4.4 nie musisz używać letz deklaracjami typu, jeśli używasz :{ :}stylu. Oznacza to, że nie musisz się martwić dodawaniem wcięcia z 4 spacjami w każdym kolejnym wierszu w celu uwzględnienia let, co znacznie ułatwi wpisywanie dłuższych funkcji lub w wielu przypadkach kopiowanie i wklejanie (ponieważ oryginalne źródło prawdopodobnie nie będzie miało prawidłowe wcięcie):

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

Aktualizacja

Alternatywnie możesz włączyć wielowierszowy tryb wprowadzania za pomocą :set +m, a następnie wpisać letsamodzielnie, nacisnąć Enter, a następnie wkleić definicje bez konieczności wcięcia.

Jednak wydaje się, że nie działa to z niektórymi blokami kodu, takimi jak:

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

Ale :{, :}technika robi.