View source for Haskell in 5 Schritten

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

__TOC__

== 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.

{| class="wikitable"
|[http://www.haskell.org/ghc/ GHC]
|Compiler und Interpreter (GHCi)
|Wahrscheinlich das vollständigste System.
|-
|[http://www.haskell.org/hugs/ 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
[[Mac OS X|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.

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

    Loading package base-1.0 ... linking ... done.
    Prelude>
</pre>
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.

<haskell>
Prelude> "Hello, World!"
"Hello, World!"
</haskell>

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

<haskell>
Prelude> putStrLn "Hello World"
Hello World
</haskell>

Mit einem Haskell-Compiler wie dem [http://haskell.org/ghc GHC] kannst
du den Quellcode zu einer lauffähigen Einzelanwendung kompilieren.
Erstelle eine Datei '''hello.hs''' mit dem Inhalt:

<haskell>
main = putStrLn "Hello, World!"
</haskell>

Und kompiliere sie mit:

<pre>
    $ ghc -o hello hello.hs
</pre>

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

<pre>
    $ ./hello
    Hello, World!
</pre>

== Haskell als Taschenrechner ==

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

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

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

Wir können nun '''fac''' mit einem Argument aufrufen:
<haskell>
Prelude> fac 42
1405006117752879898543142606244511569936384000000000
</haskell>

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

<haskell>
fac n = if n == 0 then 1 else n * fac (n-1)
</haskell>

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

<haskell>
Hugs.Base> :load fac.hs
Main> fac 42
1405006117752879898543142606244511569936384000000000
</haskell>

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:

<haskell>
fac 0 = 1
fac n = n * fac (n-1)

main = print (fac 42)
</haskell>

Dies kann dann kompiliert und ausgeführt werden:

<pre>
    $ ghc -o fac fac.hs
    $ ./fac
    1405006117752879898543142606244511569936384000000000
</pre>

'''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.

<haskell>
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)
</haskell>

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

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

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

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

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'''
* [http://book.realworldhaskell.org/ Real World Haskell]
* [[Learn_Haskell_in_10_minutes|Haskell in 10 minutes]]
* [http://www.cs.utah.edu/~hal/htut/ Yet Another Haskell Tutorial] (English)
* [http://www.haskell.org/tutorial/ A Gentle Introduction to Haskell] (Englisch)
* [http://learnyouahaskell.com/ 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:

* [http://haskell.org/mailman/listinfo/haskell-cafe Haskell-Cafe mailinglist] 
* [[IRC channel]]

[[Category:Tutorials]]
Languages: [[Haskell in 5 Schritten|de]] [[Haskell in 5 steps|en]] [[5 adımda Haskell|tur]] [[Cn/Haskell 入门五步走|zh/cn]]
[[Tw/Haskell入門的5個步驟|zh/tw]] [[Haskell入門 5ステップ|ja]]