Haskell in 5 Schritten

Haskell ist eine universelle und rein funktionale Programmiersprache. Diese Seite soll dir helfen, so schnell wie möglich loszulegen.

Haskell installieren

Haskell gibt es, wie viele andere Sprachen, in zwei verschiedene Arten: stapelweise verarbeitet (Compiler) und interaktiv (Interpreter). Ein interaktives System stellt dir eine Kommandozeile zur Verfügung, in der du direkt experimentieren und Ausdrücke auswerten kannst. Es ist wahrscheinlich eine gute Wahl, damit zu beginnen.

GHC	Compiler und Interpreter (GHCi)	Wahrscheinlich das vollständigste System.
Hugs	Nur Interpreter	Sehr portabel und leichtgewichtiger als der GHC.

Während sowohl GHC und Hugs auf Windows laufen, ist Hugs wahrscheinlich am besten in Windows integriert. Nichtsdestotrotz wird GHC aktiver entwickelt und unterhalten. Außerdem scheint Konsens darüber zu bestehen, dass der GHC für Einsteiger und alte Hasen die Entwicklungsumgebung der Wahl ist. Es gibt auch Informationen über die Installation von Haskell Software auf Mac OS X.

Haskell starten

Öffne ein Terminal. Tippe ghci (der Name der ausführbaren Datei des GHC-Interpreters) ein, falls du GHC installiert hast. Solltest du Hugs installiert haben, gebe hugs ein.

    $ ghci
       ___         ___ _
      / _ \ /\  /\/ __(_)
     / /_\// /_/ / /  | |      GHC Interactive, version 6.4, for Haskell98.
    / /_\\/ __  / /___| |      http://www.haskell.org/ghc/
    \____/\/ /_/\____/|_|      Type :? for help.

    Loading package base-1.0 ... linking ... done.
    Prelude>

Dir wird ein Prompt angezeigt und Haskell erwartet nun deine Eingaben.

Schreibe dein erstes Haskell Programm

Solltest du eine andere Programmiersprache gelernt haben, war dein erstes Programm vermutlich "Hello, World!". Lass uns damit beginnen.

Prelude> "Hello, World!"
"Hello, World!"

Haskell wertet den String aus und zeigt das Ergebnis an. Wir können auch variieren und es direkt über die Standardausgabe anzeigen lassen:

Prelude> putStrLn "Hello World"
Hello World

Mit einem Haskell-Compiler wie dem GHC kannst du den Quellcode zu einer lauffähigen Einzelanwendung kompilieren. Erstelle eine Datei hello.hs mit dem Inhalt:

main = putStrLn "Hello, World!"

Und kompiliere sie mit:

    $ ghc -o hello hello.hs

Du kannst das Resultat nun ausführen (./hello unter Unix Systemen, hello.exe unter Windows):

    $ ./hello
    Hello, World!

Haskell als Taschenrechner

Nun zu etwas interessanterem. Dein erstes richtiges Haskell Programm ist die Fakultätsfunktion.

Prelude> let fac n = if n == 0 then 1 else n * fac (n-1)

Dies definiert eine neue Funktion fac welche die Fakultät einer Ganzzahl berechnet.

Wir können nun fac mit einem Argument aufrufen:

Prelude> fac 42
1405006117752879898543142606244511569936384000000000

Gratulation! Programmieren leicht gemacht. Beachte, dass du in Hugs die Definition von fac aus einer Datei fac.hs laden musst, die folgendes beinhaltet:

fac n = if n == 0 then 1 else n * fac (n-1)

In Hugs muss es so ausgeführt werden (dies funktioniert auch in GHCi):

Hugs.Base> :load fac.hs
Main> fac 42
1405006117752879898543142606244511569936384000000000

Wir können dieses Programm natürlich auch kompilieren, um ein eigenständiges Programm zu erzeugen. Wir können jetzt unter Verwendung von Pattern Matching in die Datei fac.hs folgendes schreiben:

fac 0 = 1
fac n = n * fac (n-1)

main = print (fac 42)

Dies kann dann kompiliert und ausgeführt werden:

    $ ghc -o fac fac.hs
    $ ./fac
    1405006117752879898543142606244511569936384000000000

Prima!

Schreibe dein erstes paralleles Haskell Programm

Haskell hat eine gute Unterstützung für parallele und Multicore-Programmierung. Ein paralleles Haskell Programm schreiben wir, indem wir `par` zum jeweiligen Ausdruck hinzufügen.

import Control.Parallel

main = a `par` b `par` c `pseq` print (a + b + c)
    where
        a = ack 3 10
        b = fac 42
        c = fib 34

fac 0 = 1
fac n = n * fac (n-1)

ack 0 n = n+1
ack m 0 = ack (m-1) 1
ack m n = ack (m-1) (ack m (n-1))

fib 0 = 0
fib 1 = 1
fib n = fib (n-1) + fib (n-2)

Dieses Programm wird dann mit dem Flag -threaded und Optimierungen kompiliert:

$ ghc -O2 --make A.hs -threaded
[1 of 1] Compiling Main             ( A.hs, A.o )
Linking A ...

Nun können wir unser Programm ausführen, in diesem Beispiel mit zwei Kernen:

$ time ./A +RTS -N2
1405006117752879898543142606244511569936384005711076
./A +RTS -N2  2.14s user 0.02s system 149% cpu 1.449 total

Gratulation! Nun programmierst du deinen Multicore-Prozessor!

Wie es weitergeht

Es gibt viele gute Haskell-Tutorials und Bücher. Hier sind einige, die wir empfehlen:

Tutorials

• Real World Haskell
• Haskell in 10 minutes
• Yet Another Haskell Tutorial (English)
• A Gentle Introduction to Haskell (English)
• Learn You A Haskell For Great Good!

Eine komplette Liste der Lehr- und Fachbücher sowie Tutorials und andere Empfehlungen findet sich hier:

• Books and tutorials

Join the community!

Unterhalte dich mit Mitgliedern der Haskell-Gemeinschaft:

• Haskell-Cafe mailinglist
• IRC channel

Languages: de en tur zh/cn zh/tw ja