Personal tools

Haskell in 5 Schritten

From HaskellWiki

Revision as of 11:20, 9 April 2010 by Wittmann P (Talk | contribs)

Jump to: navigation, search

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

Contents


1 Haskell Installieren

Haskell gibt es, wie viele andere Sprachen, in zwei verschiedene Arten: stapelweise verarbeitet (Kompiler) 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 Kompiler 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. Nichtsdestotroz, GHC wird aktiver entwickelt und unterhalten, außerdem scheint Konsens darüber zu herrschen, dass der GHC für Einsteiger und alte Hasen die Entwicklungsumgebung der Wahl ist. Es sind auch Informationen über die Installation von Haskell Software auf Mac OS X.

2 Haskell starten

Öffne ein Terminal. Tippe ghci (der Name de 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.

3 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 Kompiler, 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!

4 Haskell der 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 das 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 ausfü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 Date fac.hs folgendes schreiben.

fac 0 = 1
fac n = n * fac (n-1)
 
main = print (fac 42)

Welche dann kompiliert und ausgeführt werden kann.

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

Prima!

4.1 Schreibe dein erstes paralleles Haskell Programm

Haskell hat eine gute Unterstützung für parallele und multicore Programmierung. Ein paralleles Haskell Programm schreiben wir in dem 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!

5 Wie es weitergeht

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

Tutorials

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

Join the community!

Unterhalte dich mit Mitgliedern der Haskell Gemeinschaft:

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