Programmieren in Haskell - WS 2011/2012

Universität Bielefeld
Programmieren
in Haskell
Giegerich
Programmieren in Haskell
WS 2011/2012
Administratives
Haskell
Syntax
Notation
Typsystem
Robert Giegerich
Universität Bielefeld
AG Praktische Informatik
October 17, 2012
Auswertung
Sprechstunden
Universität Bielefeld
Programmieren
in Haskell
Giegerich
Administratives
GZI-Arbeitsraum (V2-240)
Tutoren-Sprechstunden (V2-228)
http://www.techfak.uni-bielefeld.de/ags/pi/
lehre/AuDIWS12/#ueb
http://www.techfak.uni-bielefeld.de/ags/rbg/
de/gzi-tutoren.html
Haskell
Syntax
Notation
Typsystem
Auswertung
Haskell
Universität Bielefeld
Programmieren
in Haskell
seit 1990
benannt nach dem Logiker Haskell Curry, aufbauend auf
den Sprachen von ML und Miranda
funktional (pure) – d.h. keine “Behälter”, keine
Anweisungen, kein vorher-nachher
lazy evaluation (alias verzögerte Auswertung)
polymorph und stark typisiert
Typinferenz
Layout-sensitiv
Die wichtigsten Implementierungen: Hugs (Interpreter),
GHC (Compiler)
Giegerich
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Bürger erster Klasse
Universität Bielefeld
Programmieren
in Haskell
Giegerich
Funktionen gibt es in allen Programmiersprachen.
In einer funktionalen Sprache sind Funktionen “first class
citizens”: Funktionen sind den Daten gleichberechtigt. Sie
können
Haskell
Syntax
Notation
Argumente von (anderen) Funktionen sein
Typsystem
Ergebnisse von (anderen) Funktionen sein
Auswertung
anonym oder benannt sein
über beliebigen Datentypen definiert werden
1
Administratives
Funktionen “höherer Ordnung” ersetzen Kontrollstruktur
map :: ( a -> b ) -> [ a ] - >[ b ]
Haskell Syntax
Universität Bielefeld
Programmieren
in Haskell
Giegerich
Administratives
Haskell
Syntax
Es folgt eine kurze Zusammenfassung der Haskell Syntax.
Vieles davon wird erst später gebraucht.
Notation
Typsystem
Auswertung
Schlüsselwörter
1
2
3
case class data default deriving do else
if import in infix infixl infixr instance
let module newtype of then type where _
Universität Bielefeld
Programmieren
in Haskell
Giegerich
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Schlüsselwörter
1
2
3
Universität Bielefeld
case class data default deriving do else
if import in infix infixl infixr instance
let module newtype of then type where _
Programmieren
in Haskell
Giegerich
Administratives
Haskell
Vergleich
Syntax
Notation
Sprache
#Keywords
Haskell
Scheme
C (C89)
Java
Ada
C++
21
23
32
50
72
74
Typsystem
Auswertung
Groß- und Kleinschreibung
Universität Bielefeld
Programmieren
in Haskell
Giegerich
Modulname
erster Buchstabe großgeschrieben
Modulname == Dateiname
Administratives
Haskell
Syntax
Datentypnamen: Großgeschrieben
Datentyp-Konstrukturen: Großgeschrieben
(z.B. Datentype Bool → Konstruktoren: True und False
Funktionsnamen: Kleingeschrieben
Operatorzeichen → Infix
Sonstige Funktionsnamen: Prefix
Prioritäten und Assoziation definierbar
Notation
Typsystem
Auswertung
Keine (!) Anweisungen
Universität Bielefeld
Programmieren
in Haskell
keine Statements in Haskell
keine Wertzuweisung, kein FOR, kein WHILE ...
Giegerich
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Keine (!) Anweisungen
Universität Bielefeld
Programmieren
in Haskell
keine Statements in Haskell
keine Wertzuweisung, kein FOR, kein WHILE ...
→ da funktionale Programmiersprache
Giegerich
Administratives
Haskell
Syntax
Es wird beschrieben, WAS berechnet werden soll, aber nicht
WIE. So wie in
(1 + f (2)) ∗ 32 ∗ (4 + g(5)).
Notation
Typsystem
Auswertung
Keine (!) Anweisungen
Universität Bielefeld
Programmieren
in Haskell
keine Statements in Haskell
keine Wertzuweisung, kein FOR, kein WHILE ...
→ da funktionale Programmiersprache
Giegerich
Administratives
Haskell
Syntax
Es wird beschrieben, WAS berechnet werden soll, aber nicht
WIE. So wie in
(1 + f (2)) ∗ 32 ∗ (4 + g(5)).
1
2
3
Ein Haskell-Programm besteht im wesentlichen aus einer
Menge von Definitionen a la
f x y z = ... ein Ausdruck der x ,y , z benutzt
g []
= 0
-- hier mit
g ( x : xs ) = 1 + g xs
-- pattern matching
Notation
Typsystem
Auswertung
Präfix, Infix, Postfix-Notation
Universität Bielefeld
Programmieren
in Haskell
Viele Schreibweisen für Ausdrücke:
Giegerich
Administratives
Haskell
Notation
Präfix
Infix
Postfix
Mixfix
mathematisch
−1, f (x , y , z)
x < y , n2 , 2x + 5
n!, f 0
---
Grafix
q
3
1−
Rb
a
√
y
f (x ) dx
in Haskell
-1, f x y z
x<y, nˆ2, 2*x+5
--if a then b else c
anstatt IfThenElse a b c
root 3 (1 - (root 2 y))
integral a b f
Syntax
Notation
Typsystem
Auswertung
Operatoren
Boolsche Operatoren vordefiniert:
|| oder
&& und
‘not‘
Vergleichsoperatoren:
<
<=
==
/=
...
reguläre Funktionen in Haskell
Universität Bielefeld
Programmieren
in Haskell
Giegerich
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Operatoren
Boolsche Operatoren vordefiniert:
|| oder
&& und
‘not‘
Vergleichsoperatoren:
<
<=
==
/=
...
reguläre Funktionen in Haskell
Example
Hugs> :t (&&)
(&&) :: Bool -> Bool -> Bool
Universität Bielefeld
Programmieren
in Haskell
Giegerich
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Beispiel
Universität Bielefeld
Programmieren
in Haskell
1
2
> inbetween a b c =
>
if a <= b && b <= c then True else False
Giegerich
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Beispiel
Universität Bielefeld
Programmieren
in Haskell
1
2
> inbetween a b c =
>
if a <= b && b <= c then True else False
Eleganter
Giegerich
Administratives
Haskell
Syntax
1
> inbetween a b c = a <= b && b <= c
Notation
Typsystem
Geht’s noch eleganter?
1
inbetween a b c = a <= b <= c
Auswertung
Beispiel
Universität Bielefeld
Programmieren
in Haskell
1
2
> inbetween a b c =
>
if a <= b && b <= c then True else False
Eleganter
Giegerich
Administratives
Haskell
Syntax
1
> inbetween a b c = a <= b && b <= c
Notation
Typsystem
Geht’s noch eleganter?
1
1
2
3
4
Auswertung
inbetween a b c = a <= b <= c
allequal . lhs :7:20:
Precedence parsing error
cannot mix ‘ <= ’ [ infix 4] and
‘ <= ’ [ infix 4] in the same infix expression
Prefix/Infix-Konversion
Funktionen als Operatoren
Operatoren als Funktionen
Universität Bielefeld
Programmieren
in Haskell
Giegerich
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Prefix/Infix-Konversion
Funktionen als Operatoren
Operatoren als Funktionen
‘fn‘ konvertiert nach Infix
(op) konvertiert nach Prefix
Universität Bielefeld
Programmieren
in Haskell
Giegerich
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Prefix/Infix-Konversion
Funktionen als Operatoren
Operatoren als Funktionen
‘fn‘ konvertiert nach Infix
(op) konvertiert nach Prefix
Example
Universität Bielefeld
Programmieren
in Haskell
Giegerich
Administratives
Haskell
Syntax
Notation
Typsystem
Main>
23
Main>
23
Test>
23
Test>
23
21 + 2
(+) 21 2
div 69 3
69 ‘div‘ 3
Auswertung
Prefix/Infix: Prioritäten
Universität Bielefeld
Programmieren
in Haskell
Giegerich
Flexible Anwendung von Funktionen
Administratives
Deklaration von Prioritäten möglich
Haskell
Syntax
meist geeignet vordefiniert
Notation
Funktionsanwendung in Präfix hat höchste Priorität
1
> f x + g y * 2
ist
( f x ) + (( g y ) *2)
Typsystem
Auswertung
2
3
Achtung bei Definitionen :
4
5
> f ( x : xs ) ys = x : f xs ys
braucht Klammern !!
Bedingter Ausdruck
Universität Bielefeld
Programmieren
in Haskell
1
if expr1 then expr2 else expr3
Giegerich
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Bedingter Ausdruck
Universität Bielefeld
Programmieren
in Haskell
1
if expr1 then expr2 else expr3
Giegerich
Kein If-Statement!
Administratives
if expr1 then expr2 ?
Haskell
Syntax
Notation
Typsystem
Auswertung
Bedingter Ausdruck
Universität Bielefeld
Programmieren
in Haskell
1
if expr1 then expr2 else expr3
Giegerich
Kein If-Statement!
Administratives
if expr1 then expr2 ?
Fehler!
Haskell
Syntax
Notation
→ hier wäre der Wert des Ausdrucks im else-Fall nicht
definiert
Typsystem
Auswertung
Bedingter Ausdruck
Universität Bielefeld
Programmieren
in Haskell
1
if expr1 then expr2 else expr3
Giegerich
Kein If-Statement!
Administratives
if expr1 then expr2 ?
Fehler!
Haskell
Syntax
Notation
→ hier wäre der Wert des Ausdrucks im else-Fall nicht
definiert
Vergleichbar mit dem Bedingungsoperator in C/Java:
cond_expr ? expr2 : expr3
Typsystem
Auswertung
Bedingter Ausdruck
Universität Bielefeld
Programmieren
in Haskell
1
if expr1 then expr2 else expr3
Giegerich
Kein If-Statement!
Administratives
if expr1 then expr2 ?
Fehler!
Haskell
Syntax
Notation
→ hier wäre der Wert des Ausdrucks im else-Fall nicht
definiert
Vergleichbar mit dem Bedingungsoperator in C/Java:
cond_expr ? expr2 : expr3
Example
1
func a b
= if a <= b then a else b
Typsystem
Auswertung
Case-Ausdruck
Universität Bielefeld
Programmieren
in Haskell
vielfache Fallunterscheidung
statt verschachtelte If-Expressions
Giegerich
Administratives
überall wo ein Ausdruck stehen kann
Haskell
Pattern matching
Syntax
Notation
Typsystem
Auswertung
Case-Ausdruck
Universität Bielefeld
Programmieren
in Haskell
vielfache Fallunterscheidung
statt verschachtelte If-Expressions
Giegerich
Administratives
überall wo ein Ausdruck stehen kann
Haskell
Pattern matching
Syntax
Notation
1
2
3
4
5
case expr of
pat1 | guard1 -> expr1
pat2 | guard2 -> expr2
pat3 | guard3 -> expr3
...
Typsystem
Auswertung
Case-Ausdruck
Universität Bielefeld
Programmieren
in Haskell
vielfache Fallunterscheidung
statt verschachtelte If-Expressions
Giegerich
Administratives
überall wo ein Ausdruck stehen kann
Haskell
Pattern matching
Syntax
Notation
1
2
3
4
5
case expr of
pat1 | guard1 -> expr1
pat2 | guard2 -> expr2
pat3 | guard3 -> expr3
...
Pattern kann leer sein
statt pat | True -> gilt auch die Konvention pat ->
otherwise als default
Typsystem
Auswertung
Case-Ausdruck
Universität Bielefeld
Programmieren
in Haskell
Giegerich
Administratives
Example
Haskell
Syntax
1
2
3
4
5
> laststr xs = case reverse xs of
>
[]
-> " leer "
>
( l : ls ) | l == 1 -> " eins "
>
( l : ls ) | l == 2 -> " zwei "
>
otherwise
-> " ganz viele "
Notation
Typsystem
Auswertung
Sichtbarkeitsbereiche
Universität Bielefeld
Programmieren
in Haskell
Giegerich
Alle (modernen) Programiersprachen haben
Sichtbarkeitsbereiche (scopes).
Jeder Name ist in dem Bereich sichtbar
Administratives
Haskell
Syntax
Notation
in dem er definiert wurde
Typsystem
und in allen darin eingebetteteten Bereichen
Auswertung
Scopes in einem Programm sind also “verschachtelt”.
Explizite Regeln gelten für Sichtbarkeit über Modulgrenzen
hinweg.
Let Expression
1
2
3
4
let decl1
decl2
...
in expr
Universität Bielefeld
Programmieren
in Haskell
Giegerich
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Let Expression
1
2
3
4
let decl1
decl2
...
in expr
Universität Bielefeld
Kann überall dort stehen wo ein
Ausdruck stehen kann
lokaler Scope (Sichtbarkeitsbereich)
Programmieren
in Haskell
Giegerich
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Let Expression
let decl1
decl2
...
in expr
1
2
3
4
Universität Bielefeld
Kann überall dort stehen wo ein
Ausdruck stehen kann
lokaler Scope (Sichtbarkeitsbereich)
Programmieren
in Haskell
Giegerich
Administratives
Haskell
Syntax
Example
Notation
1
2
3
> func a b
>
>
= let square x = x * x
plus a b = a + b
in plus ( square a ) ( square b )
Typsystem
Auswertung
Let Expression
let decl1
decl2
...
in expr
1
2
3
4
Universität Bielefeld
Kann überall dort stehen wo ein
Ausdruck stehen kann
lokaler Scope (Sichtbarkeitsbereich)
Programmieren
in Haskell
Giegerich
Administratives
Haskell
Syntax
Example
Notation
3
> func a b
>
>
= let square x = x * x
plus a b = a + b
in plus ( square a ) ( square b )
1
Versus:
> square x
= x * x
> plus a b
= a + b
> func a b
= plus ( square a ) ( square b )
1
2
2
3
4
5
Typsystem
Auswertung
Where-Notation
lokale Definitionen
Universität Bielefeld
Programmieren
in Haskell
Giegerich
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Where-Notation
lokale Definitionen
bei Funktionsdefinitionen
case-Ausdrücken
Universität Bielefeld
Programmieren
in Haskell
Giegerich
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Where-Notation
lokale Definitionen
bei Funktionsdefinitionen
case-Ausdrücken
Module-Definition . . .
Universität Bielefeld
Programmieren
in Haskell
Giegerich
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Where-Notation
lokale Definitionen
bei Funktionsdefinitionen
case-Ausdrücken
Module-Definition . . .
Example
Universität Bielefeld
Programmieren
in Haskell
Giegerich
Administratives
Haskell
Syntax
Notation
1
2
3
> f x = square x + square x
>
where
>
square x = x * x
Typsystem
Auswertung
Where-Notation
lokale Definitionen
bei Funktionsdefinitionen
case-Ausdrücken
Module-Definition . . .
Example
Universität Bielefeld
Programmieren
in Haskell
Giegerich
Administratives
Haskell
Syntax
Notation
1
2
3
> f x = square x + square x
>
where
>
square x = x * x
vs. let Ausdruck
notationelle Betonung
syntaktischer Zucker
where kann nicht überall stehen
Typsystem
Auswertung
Where-Notation
Universität Bielefeld
Programmieren
in Haskell
Giegerich
Administratives
1
2
3
4
5
Schachtelungen auch möglich:
> foo x = ... f ...
>
where
>
f x = ... g ...
>
where
>
g x = ....
Haskell
Syntax
Notation
Typsystem
Auswertung
Layout und Abseitsregel
Universität Bielefeld
Programmieren
in Haskell
Haskell-Programme sind whitespace-sensitive
→ Verzicht auf Trennzeichen wie ; {}
es gilt die Offside-Rule (Abseitsregel)
→ die Einrückung ist entscheidend
Giegerich
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Layout und Abseitsregel
Universität Bielefeld
Programmieren
in Haskell
Haskell-Programme sind whitespace-sensitive
→ Verzicht auf Trennzeichen wie ; {}
es gilt die Offside-Rule (Abseitsregel)
→ die Einrückung ist entscheidend
explizite Verwendung von ; {} ist möglich
Giegerich
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Layout und Abseitsregel
Universität Bielefeld
Programmieren
in Haskell
Haskell-Programme sind whitespace-sensitive
→ Verzicht auf Trennzeichen wie ; {}
es gilt die Offside-Rule (Abseitsregel)
→ die Einrückung ist entscheidend
explizite Verwendung von ; {} ist möglich
Giegerich
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Example (Fehler)
1
2
3
4
5
> laststr xs = case reverse xs of
>
[]
-> " leer "
>
( l : ls ) | l == 1 -> " eins "
>
( l : ls ) | l == 2 -> " zwei "
>
otherwise
-> " ganz viele "
Layout
Definitionen gleicher Stufe stehen in der gleichen Einrücktiefe.
Example (korrigiert)
1
2
3
4
5
> laststr xs = case reverse xs of {
>
[]
-> " leer " ;
>
( l : ls ) | l == 1 -> " eins " ;
>
( l : ls ) | l == 2 -> " zwei " ;
>
otherwise
-> " ganz viele " }
Universität Bielefeld
Programmieren
in Haskell
Giegerich
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Layout
Universität Bielefeld
Definitionen gleicher Stufe stehen in der gleichen Einrücktiefe.
Giegerich
Example (korrigiert)
1
2
3
4
5
> laststr xs = case reverse xs of {
>
[]
-> " leer " ;
>
( l : ls ) | l == 1 -> " eins " ;
>
( l : ls ) | l == 2 -> " zwei " ;
>
otherwise
-> " ganz viele " }
Example
1
2
3
4
5
> f x = g x +
>
where { g
> f x = g x +
>
where g x
h x
Programmieren
in Haskell
h
x
h
=
=
x
= x * x ; h x = x + x }
x
x * x
x + x
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Allgemeine Abseitsregel
Universität Bielefeld
Programmieren
in Haskell
Giegerich
alle Definitionen eines Scope stehen in der gleichen
Einrücktiefe
Administratives
Haskell
tieferes Einrücken bedeutet Fortsetzung der aktuellen
Definitionszeile
Syntax
nach let, where, of, do bestimmt der nächste
Buchstabe die neue Einrücktiefe
Typsystem
Ausrücken nach links beendet den aktuellen Scope
Notation
Auswertung
Allgemeine Abseitsregel
Universität Bielefeld
Programmieren
in Haskell
Giegerich
alle Definitionen eines Scope stehen in der gleichen
Einrücktiefe
Administratives
Haskell
tieferes Einrücken bedeutet Fortsetzung der aktuellen
Definitionszeile
Syntax
nach let, where, of, do bestimmt der nächste
Buchstabe die neue Einrücktiefe
Typsystem
Ausrücken nach links beendet den aktuellen Scope
Vorteile ??
Nachteile ??
Notation
Auswertung
Fehlerbehandlung
Universität Bielefeld
Programmieren
in Haskell
Giegerich
mehrere Möglichkeiten Fehler zu behandeln in Haskell
Programmen (mindestens 8)
Administratives
Haskell
einfachster Mechanismus: error
Syntax
Signature: error :: String -> a
Notation
weitere Mechanismen in folgenden Vorlesungen
Typsystem
Auswertung
Fehlerbehandlung
Universität Bielefeld
Programmieren
in Haskell
Giegerich
mehrere Möglichkeiten Fehler zu behandeln in Haskell
Programmen (mindestens 8)
Administratives
Haskell
einfachster Mechanismus: error
Syntax
Signature: error :: String -> a
Notation
weitere Mechanismen in folgenden Vorlesungen
Typsystem
Auswertung
Example
1
2
3
> divide a b =
>
if b == 0 then error " divide by zero "
>
else div a b
Modul-Aufbau
Modulname
Imports
Definitionen
Universität Bielefeld
Programmieren
in Haskell
Giegerich
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Modul-Aufbau
Modulname
Imports
Definitionen
1
2
> module Meinmodul
> where
Universität Bielefeld
Programmieren
in Haskell
Giegerich
Administratives
Haskell
Syntax
Notation
3
4
> import Data . List
Typsystem
Auswertung
5
6
> splits n = [ splitAt k [1.. n ] | k < -[1.. n -1]]
Modul-Aufbau
Universität Bielefeld
Programmieren
in Haskell
Modulname
Imports
Definitionen
1
2
Giegerich
Administratives
Haskell
> module Meinmodul
> where
Syntax
Notation
3
4
Typsystem
> import Data . List
Auswertung
5
6
> splits n = [ splitAt k [1.. n ] | k < -[1.. n -1]]
Main> splits
[ ( [1
( [1,2
( [1,2,3
( [1,2,3,4
5
],[
],[
],[
],[
2,3,4,5]
3,4,5]
4,5]
5]
)
)
)
)
,
,
,
]
Wächter (Guards) in Funktionsdefinitionen
1
2
3
4
> fn pat1 pat2 ...
>
| guard1 = expr1
>
| guard2 = expr2
>
...
Universität Bielefeld
Programmieren
in Haskell
Giegerich
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Wächter (Guards) in Funktionsdefinitionen
1
2
3
4
> fn pat1 pat2 ...
>
| guard1 = expr1
>
| guard2 = expr2
>
...
syntaktische Zucker für Funktionsdefinitionen
Universität Bielefeld
Programmieren
in Haskell
Giegerich
Administratives
Haskell
Syntax
Notation
ersetzt geschachtelte if-Anweisungen
Typsystem
guards (Wächter) sind Ausdrücke (vom Typ Bool)
Auswertung
Wächter (Guards) in Funktionsdefinitionen
1
2
3
4
> fn pat1 pat2 ...
>
| guard1 = expr1
>
| guard2 = expr2
>
...
syntaktische Zucker für Funktionsdefinitionen
2
3
4
Programmieren
in Haskell
Giegerich
Administratives
Haskell
Syntax
Notation
ersetzt geschachtelte if-Anweisungen
Typsystem
guards (Wächter) sind Ausdrücke (vom Typ Bool)
Auswertung
Example
1
Universität Bielefeld
howManyEqual n m p
| ( n == m ) && ( m == p )
= 3
| ( n == m ) || ( m == p ) || ( n == p ) = 2
| otherwise
= 0
Pattern matching
Universität Bielefeld
Programmieren
in Haskell
Pattern Matching auf
natürlichen Zahlen
Werten
Datentyp-Konstruktoren
Joker
Giegerich
Administratives
Haskell
Syntax
Notation
auf der linken Seite von Funktionsdefinitionen
Typsystem
in case-Ausdrücken
Auswertung
Pattern matching
Universität Bielefeld
Programmieren
in Haskell
Pattern Matching auf
natürlichen Zahlen
Werten
Datentyp-Konstruktoren
Joker
2
3
Administratives
Haskell
Syntax
Notation
auf der linken Seite von Funktionsdefinitionen
Typsystem
in case-Ausdrücken
Auswertung
Example
1
Giegerich
> take ’
:: Int -> [ a ] -> [ a ]
> take ’ ( n +1) ( a : as ) = a : take ’ n as
> take ’ _
_
= []
Pattern matching
Universität Bielefeld
Programmieren
in Haskell
Giegerich
Example
1
2
3
4
>
>
>
>
f
f
f
f
( a : b : c : d : ds )
( a : as )
( a :[])
[a]
Administratives
=
=
=
=
...
...
...
...
5
6
7
8
> g 0
> g 1
> g _
= ...
= ...
= ...
Haskell
Syntax
Notation
Typsystem
Auswertung
Datentypen
Ein Datentyp ist eine Mengen von Werten, worauf Operationen
(Funktionen) definiert werden können.
Universität Bielefeld
Programmieren
in Haskell
Giegerich
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Datentypen
Ein Datentyp ist eine Mengen von Werten, worauf Operationen
(Funktionen) definiert werden können.
“Eingebaute” Datentypen in Haskell sind zum Beispiel:
Ganze Zahlen (Integer, Int)
Funktionen darauf sind z.B.: +, div, square
Universität Bielefeld
Programmieren
in Haskell
Giegerich
Administratives
Haskell
Syntax
Notation
Fließkommazahlen (Float, Double)
+, /, square
Wahrheitswerte (Bool): True, False
&&, ||
Listen ([a])
++, reverse, take
Zeichen (Char)
Zeichenketten (String), wobei String = [Char]
Typsystem
Auswertung
Datentypen
Universität Bielefeld
Programmieren
in Haskell
Giegerich
Administratives
1
2
3
4
5
6
Ausdrücke haben Typen:
42
::
3 + 4
::
4.2
::
True
::
" Hallo Welt ! " ::
[1 ,2 ,3]
::
Haskell
Int
Int
Float
Bool
String -- bzw . [ Char ]
[ Int ]
Syntax
Notation
Typsystem
Auswertung
Datentypen
In der Haskell Shell (z.B. Hugs) Typ-Inferenz von Ausdrücken:
Hugs> :t (1+2)
1 + 2 :: Num a => a
Hugs> :t (4.2)
4.2 :: Fractional a => a
Hugs> :t 2/3
2 / 3 :: Fractional a => a
Universität Bielefeld
Programmieren
in Haskell
Giegerich
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Datentypen
Universität Bielefeld
In der Haskell Shell (z.B. Hugs) Typ-Inferenz von Ausdrücken:
Hugs> :t (1+2)
1 + 2 :: Num a => a
Hugs> :t (4.2)
4.2 :: Fractional a => a
Hugs> :t 2/3
2 / 3 :: Fractional a => a
Typen Einschränken:
Hugs> (2::Int)
ERROR - Cannot
*** Instance
*** Expression
/ (3::Int)
infer instance
: Fractional Int
: 2 / 3
Programmieren
in Haskell
Giegerich
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Datentypen
Universität Bielefeld
In der Haskell Shell (z.B. Hugs) Typ-Inferenz von Ausdrücken:
Hugs> :t (1+2)
1 + 2 :: Num a => a
Hugs> :t (4.2)
4.2 :: Fractional a => a
Hugs> :t 2/3
2 / 3 :: Fractional a => a
Typen Einschränken:
Hugs> (2::Int)
ERROR - Cannot
*** Instance
*** Expression
/ (3::Int)
infer instance
: Fractional Int
: 2 / 3
Hugs> (2::Int) ‘div‘ (3::Int)
0
Programmieren
in Haskell
Giegerich
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Typklassen
In Haskell sind Typen in Klassen organisiert. Typen sind dabei
Instanzen von Klassen.
Universität Bielefeld
Programmieren
in Haskell
Giegerich
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Typklassen
In Haskell sind Typen in Klassen organisiert. Typen sind dabei
Instanzen von Klassen.
Beispiele für Typklassen
Eq Überprüfung auf Gleichheit. In der Klasse Eq sind die
Operationen == und /= definiert.
Instanzen z.B.: Int, Float, Double, String
Universität Bielefeld
Programmieren
in Haskell
Giegerich
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Typklassen
In Haskell sind Typen in Klassen organisiert. Typen sind dabei
Instanzen von Klassen.
Beispiele für Typklassen
Eq Überprüfung auf Gleichheit. In der Klasse Eq sind die
Operationen == und /= definiert.
Instanzen z.B.: Int, Float, Double, String
Ord Ordnungsrelation. In der Klasse Ord sind die Operationen
<,>,<=,>= definiert.
Instanzen z.B.: Int, Float, Double, String
Universität Bielefeld
Programmieren
in Haskell
Giegerich
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Typklassen
In Haskell sind Typen in Klassen organisiert. Typen sind dabei
Instanzen von Klassen.
Beispiele für Typklassen
Eq Überprüfung auf Gleichheit. In der Klasse Eq sind die
Operationen == und /= definiert.
Instanzen z.B.: Int, Float, Double, String
Ord Ordnungsrelation. In der Klasse Ord sind die Operationen
<,>,<=,>= definiert.
Instanzen z.B.: Int, Float, Double, String
Num Umfasst die numerischen Typen, z.B. Int, Float, Double
Operationen: +,-,*
Universität Bielefeld
Programmieren
in Haskell
Giegerich
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Typklassen
In Haskell sind Typen in Klassen organisiert. Typen sind dabei
Instanzen von Klassen.
Beispiele für Typklassen
Eq Überprüfung auf Gleichheit. In der Klasse Eq sind die
Operationen == und /= definiert.
Instanzen z.B.: Int, Float, Double, String
Ord Ordnungsrelation. In der Klasse Ord sind die Operationen
<,>,<=,>= definiert.
Instanzen z.B.: Int, Float, Double, String
Num Umfasst die numerischen Typen, z.B. Int, Float, Double
Operationen: +,-,*
Show Werte eines Typs der Instanz der Klasse Show ist, lassen
sich ausgeben
Z.B. Int, Float, Double, String
Universität Bielefeld
Programmieren
in Haskell
Giegerich
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Listen
Universität Bielefeld
Notation:
[1,2,3,4]
1:2:3:4:[]
Programmieren
in Haskell
Giegerich
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Listen
Universität Bielefeld
Notation:
[1,2,3,4]
1:2:3:4:[]
Konstruktoren: : (cons)
[] (nil)
Programmieren
in Haskell
Giegerich
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Listen
Universität Bielefeld
Notation:
[1,2,3,4]
1:2:3:4:[]
Konstruktoren: : (cons)
[] (nil)
[1..10]
Signature: [a], [Int] usw.
Programmieren
in Haskell
Giegerich
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Listen
Universität Bielefeld
Notation:
[1,2,3,4]
1:2:3:4:[]
Konstruktoren: : (cons)
[] (nil)
[1..10]
Signature: [a], [Int] usw.
Programmieren
in Haskell
Giegerich
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Main> 1:2:3:4:[]
[1,2,3,4]
Listen
Universität Bielefeld
Notation:
[1,2,3,4]
1:2:3:4:[]
Konstruktoren: : (cons)
[] (nil)
[1..10]
Signature: [a], [Int] usw.
Programmieren
in Haskell
Giegerich
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Main> 1:2:3:4:[]
[1,2,3,4]
Example
1
2
3
> length ’
:: [ a ] -> Int
> length ’ []
= 0
> length ’ ( a : as ) = 1 + length ’ as
Tupel
Universität Bielefeld
Signatur: ( a1, a2, a3, ... )
vordefinierte Funktionen:
fst
snd
...
Komponenten können verschiedene Typen haben
Programmieren
in Haskell
Giegerich
Administratives
Haskell
Syntax
Notation
Typsystem
vs. Liste
Auswertung
Tupel
Universität Bielefeld
Signatur: ( a1, a2, a3, ... )
vordefinierte Funktionen:
fst
snd
...
Komponenten können verschiedene Typen haben
Programmieren
in Haskell
Giegerich
Administratives
Haskell
Syntax
Notation
Typsystem
vs. Liste
Example
1
2
fst
:: (a , b ) -> a
fst (x , y ) = x
3
4
5
snd
:: (a , b ) -> a
snd (_ , y ) = y
Auswertung
Void
Universität Bielefeld
Programmieren
in Haskell
Giegerich
Administratives
Haskell
Syntax
Unit-Datentyp in Haskell: ()
Notation
einziges Element: ()
Typsystem
vergleichbar mit void in C/Java
Auswertung
Auswertung
Universität Bielefeld
Programmieren
in Haskell
Giegerich
Administratives
Haskell
Syntax
Auswertung von Haskell Programmen
⇒ Ausrechnen von einem funktionalen Programm
Notation
Typsystem
Auswertung
Ausdrücke und Werte
Universität Bielefeld
Programmieren
in Haskell
Giegerich
Administratives
Haskell
1
2
3
4
Ausdrücke repräsentieren Werte. Ausdrücke sind zum Beispiel:
42
6*7
answer
reverse [2 , 4]
Syntax
Notation
Typsystem
Auswertung
Ausdrücke
Universität Bielefeld
Programmieren
in Haskell
Giegerich
1
1
Ausdrücke können einfach sein oder komplex. Einfach:
49
Komplex:
square (3+4)
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Ausdrücke
Universität Bielefeld
Programmieren
in Haskell
Giegerich
1
1
1
2
Ausdrücke können einfach sein oder komplex. Einfach:
49
Komplex:
square (3+4)
Definition von square:
square
:: Int -> Int
square x = x * x
Die “einfachste” Form eines Ausdrucks wird Normalform
genannt.
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Reduktion von Ausdrücken
Reduktion, Auswertung, Vereinfachung sind synonyme Begriffe
und beschreiben den Prozess, einen Ausdruck in seine
einfachste Form (Normalform) zu überführen.
Universität Bielefeld
Programmieren
in Haskell
Giegerich
Administratives
Haskell
Example
1
2
square
:: Int -> Int
square x = x * x
Syntax
Notation
Typsystem
Auswertung
Reduktion von Ausdrücken
Reduktion, Auswertung, Vereinfachung sind synonyme Begriffe
und beschreiben den Prozess, einen Ausdruck in seine
einfachste Form (Normalform) zu überführen.
Universität Bielefeld
Programmieren
in Haskell
Giegerich
Administratives
Haskell
Example
1
2
square
:: Int -> Int
square x = x * x
Reduktion von: square (3+4)
Syntax
Notation
Typsystem
Auswertung
Reduktion von Ausdrücken
Reduktion, Auswertung, Vereinfachung sind synonyme Begriffe
und beschreiben den Prozess, einen Ausdruck in seine
einfachste Form (Normalform) zu überführen.
Universität Bielefeld
Programmieren
in Haskell
Giegerich
Administratives
Haskell
Example
1
2
square
:: Int -> Int
square x = x * x
Reduktion von: square (3+4)
square (3 + 4) => square 7 (+)
=> 7 * 7
(square)
=> 49
(*)
Syntax
Notation
Typsystem
Auswertung
Reduktion von Ausdrücken
Reduktion, Auswertung, Vereinfachung sind synonyme Begriffe
und beschreiben den Prozess, einen Ausdruck in seine
einfachste Form (Normalform) zu überführen.
Universität Bielefeld
Programmieren
in Haskell
Giegerich
Administratives
Haskell
Example
1
2
square
:: Int -> Int
square x = x * x
Reduktion von: square (3+4)
square (3 + 4) => square 7 (+)
=> 7 * 7
(square)
=> 49
(*)
In Haskell: Left-to-right, outermost first (lazy evaluation)
Syntax
Notation
Typsystem
Auswertung
Reduktionsvarianten
Universität Bielefeld
Programmieren
in Haskell
Giegerich
Haskell wertet aus: Left-to-right, outermost first
Alternativ: Left-to-right, innermost first (eager evaluation)
→ non-lazy
square
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Reduktionsvarianten
Universität Bielefeld
Programmieren
in Haskell
Giegerich
Haskell wertet aus: Left-to-right, outermost first
Alternativ: Left-to-right, innermost first (eager evaluation)
→ non-lazy
1
2
3
4
square
square (3 + 4) = >
=>
=>
=>
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
(3 + 4) * (3 + 4) ( square )
7 * (3 + 4)
(+)
7 * 7
(+)
49
(*)
Reduktionsvarianten
Universität Bielefeld
Programmieren
in Haskell
Giegerich
Example
Administratives
1
2
3
take 0 xs
= []
take n []
= []
take n ( x : xs ) = x : take (n -1) xs
Haskell
Syntax
Notation
Typsystem
non-lazy: take 2 [1..]
Auswertung
Reduktionsvarianten
Universität Bielefeld
Programmieren
in Haskell
Giegerich
Example
Administratives
1
2
3
take 0 xs
= []
take n []
= []
take n ( x : xs ) = x : take (n -1) xs
Haskell
Syntax
Notation
Typsystem
non-lazy: take 2 [1..]
take 2 [1..] =>
=>
=>
=>
take 2 (1:[2..])
(..)
take 2 (1:2:[3..])
(..)
take 2 (1:2:3:[4..]) (..)
...
Auswertung