Beispiel 1¶

Die Fakultät von einer natürlichen Zahl kann z.B. mit der product-Funktion aus der Standardbibliothek (Prelude) errechnet werden:

1

let factorial n = product [1..n]

Die Funktion kann jetzt für die Zahl 5 aufgerufen werden.

1

factorial 5

Als Ergebnis erhält man als Ausgabe dann 120.

Beispiel 2¶

Ohne die Standardbibliothek zu nutzen, kann folgende rekursive Funktion das Problem lösen:

1
2
3
4
5
6

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

Der Aufruf erfolgt wie bei Beispiel 1. Da der Code zwischen den Blockmarkern in eine einzige Zeile eingelesen wird, müssen die Befehle durch einen Semikolon ; getrennt werden. Eine Einrückung ist im normalen Code zwingend, entfällt aber dadurch, dass alles letztendlich in einer Zeile steht.

Beispiel 3¶

Da Haskell nur bei Bedarf die Ausdrücke auflöst ("lazy evaluation"), kann auf einfache Weise mit unendlich großen Mengen gearbeitet werden. Hier werden die ersten zehn geraden Zahlen aus einer unendlichen Liste (null bis unendlich) ausgegeben:

1

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

Die Befehlssequenz wird direkt ausgeführt, weswegen hier auch das let nicht notwendig. Also Ausgabe dieser Befehlssequenz erhält man als Ausgabe

[0,2,4,6,8,10,12,14,16,18]

Beispiel 1¶

Ein einfaches Hello-World-Programm:

1
2
3

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

Es gehört zum guten Stil, zu allen Funktionen entsprechende Typdeklarationen zu schreiben (entsprechend die erste Zeile main :: IO ()).

Beispiel 2¶

Die Fakultät wird hier je nach Benutzereingabe berechnet:

 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

Beispiel 3¶

Hier wird ebenfalls die Fakultät berechnet, das vorherige Beispiel allerdings noch gegen fehlerhafte Benutzereingaben abgesichert.

 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!"

Ab GHC 7.6 existiert die Funktion maybeRead bereits im Modul Text.Read 🇬🇧.