GHC¶

Der Haskell-Compiler GHC (The Glorious Glasgow Haskell Compilation system) kann direkt aus den Quellen installiert werden: ^[1]

• ghc (universe)

Befehl zum Installieren der Pakete:

sudo apt-get install ghc 

Oder mit apturl installieren, Link: apt://ghc

Er bietet mit dem Befehl ghci einen interaktiven Modus, um Code direkt im Interpreter auszuführen.

Haskell-Platform¶

Stattdessen kann auch direkt die Haskell-Platform, eine Zusammenstellung von Werkzeugen und Bibliotheken rund um Haskell, installiert werden:

• haskell-platform (universe)

Befehl zum Installieren der Pakete:

sudo apt-get install haskell-platform 

Oder mit apturl installieren, Link: apt://haskell-platform

Inbegriffen sind u.a.:

• GHC

• Alex, ein Generator für lexikalische Scanner, ähnlich zu Lex

• Happy, ein Generator für Parser/Compiler, ähnlich zu Yacc

• Cabal, ein Paketmanager

• Haddock, ein Dokumentationswerkzeug

• hsc2hs, ein Vorprozessor um Haskell- und C-Code gemeinsam zu nutzen

• weitere Bibliotheken, wie zlib, cgi und OpenGL

Weitere Compiler¶

Weitere Compiler sind auf Wikipedia zusammengefasst: Haskell - Implementations - Die meisten davon sind nicht in den Standardquellen verfügbar.

Interpreter¶

Der interaktive Interpreter kann mit dem Aufruf von

ghci 

im Terminal^[2] gestartet werden. Der Interpreter erfasst die Befehle erst mal nur zeilenweise. Mehrzeilige Anweisungen müssen in einem speziellen Block :{ :} geschrieben werden.

let factorial n = product [1..n] 

factorial 10 

:{
let {
factorial 0 = 1;
factorial n = n * factorial (n - 1);
}
:} 

take 10 [x | x <- [0..], x `mod` 2 == 0] 

Quelldatei¶

Wie bei anderen Skriptsprachen, kann auch Haskellcode direkt in eine Datei geschrieben und ausgeführt werden. Die Datei wird dann mit dem Interpreter direkt ausgeführt^[2]:

ghc HASKELLDATEI.hs 

1
2
3

-- Einfaches Hello-World Beispiel.
main :: IO ()
main = putStrLn "Hello, World!"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

factorial :: Int -> Int
factorial n                -- anstatt "Pattern matching" werden
    | n == 0    = 1        -- hier "Guards" (mit '|') verwendet
    | otherwise = n * factorial (n - 1)

main :: IO ()
main = do
    putStrLn "Welche Fakultät soll berechnet werden?"
    n <- getLine
    putStrLn . show $ factorial $ read n

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

import Data.Maybe

factorial :: Integer -> Integer  -- Integer hat keine Größenbeschränkung
factorial 0 = 1                  -- im Gegensatz zu Int
factorial n = n * factorial (n - 1)

maybeRead :: Read a => String -> Maybe a
maybeRead s = case reads s of
                [(x, "")] -> Just x
                _         -> Nothing

getIntfromString :: String -> Maybe Integer
getIntfromString str = maybeRead str

main :: IO ()
main = do
    putStrLn "Welche Fakultät soll berechnet werden?"
    input <- getLine
    let maybeInt = getIntfromString input in
        case maybeInt of
            Just n  -> if (n >= 0)
                        then putStrLn $ "Das Ergebnis von " ++ show n ++ "! ist: "
                                    ++ show (factorial n)
                        else error "Keine positive Zahl übergeben!"
            Nothing -> error "Keine Ganze Zahl übergeben!"