Programmieren in Haskell - WS 2011/2012

Werbung
Universität Bielefeld
Programmieren
in Haskell
Sauthoff
Programmieren in Haskell
Administratives
Haskell
WS 2011/2012
Syntax
Notation
Typsystem
Georg Sauthoff1
Universität Bielefeld
AG Praktische Informatik
October 18, 2011
1
[email protected]
Auswertung
Neue Übungsgruppen
Universität Bielefeld
Programmieren
in Haskell
Sauthoff
Administratives
Haskell
Syntax
neue Übungsgruppen
Notation
Typsystem
neue Tutoren
Auswertung
Sprechstunden
Universität Bielefeld
Programmieren
in Haskell
Sauthoff
Administratives
GZI-Arbeitsraum (V2-240)
Haskell
Syntax
Tutoren-Sprechstunden (V2-228)
http://www.techfak.uni-bielefeld.de/ags/pi/
lehre/AuDIWS11/#ueb
http://www.techfak.uni-bielefeld.de/ags/rbg/
de/gzi-tutoren.html
Notation
Typsystem
Auswertung
Haskell
Universität Bielefeld
seit 1990
benannt nach dem Logiker Haskell Curry
Beeinflusst von
ML
Miranda
Programmieren
in Haskell
Sauthoff
Administratives
Haskell
Syntax
Notation
funktional (pure)
Typsystem
lazy evaluation
Auswertung
stark typisiert
notationelles Juwel
Typinferenz
Die wichtigsten Implementierungen
Hugs
GHC
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
Sauthoff
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
Sauthoff
Administratives
Haskell
Vergleich
Syntax
Notation
Sprache
#Keywords
Haskell
Scheme
C (C89)
Java
Ada
C++
21
23
32
50
72
74
Typsystem
Auswertung
Ausdrücke
Universität Bielefeld
Programmieren
in Haskell
Sauthoff
Administratives
Haskell
Syntax
keine Statements in Haskell
Notation
Typsystem
Auswertung
Ausdrücke
Universität Bielefeld
Programmieren
in Haskell
Sauthoff
Administratives
Haskell
Syntax
keine Statements in Haskell
→ da funktionale Programmiersprache
Notation
Typsystem
Auswertung
Ausdrücke
Universität Bielefeld
Programmieren
in Haskell
Sauthoff
Administratives
Haskell
Syntax
keine Statements in Haskell
→ da funktionale Programmiersprache
(Ausnahme: Monaden)
Notation
Typsystem
Auswertung
Bedingter Audruck
Universität Bielefeld
Programmieren
in Haskell
1
if expr1 then expr2 else expr3
Sauthoff
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Bedingter Audruck
Universität Bielefeld
Programmieren
in Haskell
1
if expr1 then expr2 else expr3
Kein If-Statement
if expr1 then expr2 ?
Sauthoff
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Bedingter Audruck
Universität Bielefeld
Programmieren
in Haskell
1
if expr1 then expr2 else expr3
Kein If-Statement
if expr1 then expr2 ?
Fehler!
→ sonst wäre Ausdruck im else-Zweig nicht definiert
Sauthoff
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Bedingter Audruck
Universität Bielefeld
Programmieren
in Haskell
1
if expr1 then expr2 else expr3
Kein If-Statement
if expr1 then expr2 ?
Fehler!
→ sonst wäre Ausdruck im else-Zweig nicht definiert
Vergleichbar mit dem Bedingungsoperator in C/Java:
cond_expr ? expr2 : expr3
Sauthoff
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Bedingter Audruck
Universität Bielefeld
Programmieren
in Haskell
1
if expr1 then expr2 else expr3
Kein If-Statement
if expr1 then expr2 ?
Fehler!
→ sonst wäre Ausdruck im else-Zweig 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
Sauthoff
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Operatoren
Boolsche Operatoren vordefiniert:
|| oder
&& und
‘not‘
Vergleichsoperatoren:
<
<=
==
/=
...
reguläre Funktionen in Haskell
Universität Bielefeld
Programmieren
in Haskell
Sauthoff
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
Sauthoff
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Beispiel
Universität Bielefeld
Programmieren
in Haskell
Sauthoff
Administratives
Haskell
1
2
> allequal a b c =
>
if a == b && b == c then True else False
Syntax
Notation
Typsystem
Auswertung
Beispiel
Universität Bielefeld
Programmieren
in Haskell
Sauthoff
Administratives
Haskell
1
2
> allequal a b c =
>
if a == b && b == c then True else False
Eleganter
1
> allequal a b c = a == b && b == c
Syntax
Notation
Typsystem
Auswertung
Case-Ausdruck
Universität Bielefeld
Programmieren
in Haskell
vielfache Fallunterscheidung
Sauthoff
statt verschachtelte If-Expressions
Administratives
überall wo ein Ausdruck stehen kann
Haskell
Pattern matching
Syntax
Notation
Typsystem
Auswertung
Case-Ausdruck
Universität Bielefeld
Programmieren
in Haskell
vielfache Fallunterscheidung
Sauthoff
statt verschachtelte If-Expressions
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
Sauthoff
statt verschachtelte If-Expressions
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
Sauthoff
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
Let Expression
1
2
3
4
let decl1
decl2
...
in expr
Universität Bielefeld
Programmieren
in Haskell
Sauthoff
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
Ausruck stehen kann
lokaler Scope (Sichtbarkeitsbereits)
Programmieren
in Haskell
Sauthoff
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
Ausruck stehen kann
lokaler Scope (Sichtbarkeitsbereits)
Programmieren
in Haskell
Sauthoff
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
Ausruck stehen kann
lokaler Scope (Sichtbarkeitsbereits)
Programmieren
in Haskell
Sauthoff
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
Fehlerbehandlung
Universität Bielefeld
Programmieren
in Haskell
Sauthoff
mehrere Möglichkeiten Fehler zu behandeln in Haskell
Programmen (mindestens 8)
Administratives
einfachster Mechanismus: error
Syntax
Signature: error :: String -> a
Notation
weitere Mechanismen in folgenden Vorlesungen
Haskell
Typsystem
Auswertung
Fehlerbehandlung
Universität Bielefeld
Programmieren
in Haskell
Sauthoff
mehrere Möglichkeiten Fehler zu behandeln in Haskell
Programmen (mindestens 8)
Administratives
einfachster Mechanismus: error
Syntax
Signature: error :: String -> a
Notation
weitere Mechanismen in folgenden Vorlesungen
Example
1
2
3
> divide a b =
>
if b == 0 then error " divide by zero "
>
else div a b
Haskell
Typsystem
Auswertung
Notation
Universität Bielefeld
Programmieren
in Haskell
Sauthoff
Modulname
erster Buchstabe großgeschrieben
Modulname == Dateiname
Datentypnamen: Beginn mit Großbuchstaben
Datentyp-Konstrukturen: Beginn mit Großbuchstaben
(z.B. Datentype Bool → Konstruktoren: True und False
Funktionsnamen: Beginn mit Kleinbuchstaben
Operatorzeichen → Infix
Sonstige Funktionsnamen: Prefix
Prioritätive und Assoziation definierbar
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Modul-Aufbau
Modulname
Imports
Definitionen
Universität Bielefeld
Programmieren
in Haskell
Sauthoff
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Modul-Aufbau
Modulname
Imports
Definitionen
1
2
> module Meinmodul
> where
Universität Bielefeld
Programmieren
in Haskell
Sauthoff
Administratives
Haskell
Syntax
Notation
3
Typsystem
4
> import Data . List
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
Sauthoff
Administratives
Haskell
> module Meinmodul
> where
Syntax
Notation
3
Typsystem
4
> 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]
)
)
)
)
,
,
,
]
Where-Notation
lokale Definitionen
Universität Bielefeld
Programmieren
in Haskell
Sauthoff
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Where-Notation
lokale Definitionen
bei Funktionsdefinitionen
case-Ausdrücken
Universität Bielefeld
Programmieren
in Haskell
Sauthoff
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Where-Notation
lokale Definitionen
bei Funktionsdefinitionen
case-Ausdrücken
Module-Definition . . .
Universität Bielefeld
Programmieren
in Haskell
Sauthoff
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Where-Notation
lokale Definitionen
bei Funktionsdefinitionen
case-Ausdrücken
Module-Definition . . .
Example
1
2
3
> f x = square x + square x
>
where
>
square x = x * x
Universität Bielefeld
Programmieren
in Haskell
Sauthoff
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Where-Notation
lokale Definitionen
bei Funktionsdefinitionen
case-Ausdrücken
Module-Definition . . .
Example
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
Universität Bielefeld
Programmieren
in Haskell
Sauthoff
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Where-Notation
Universität Bielefeld
Programmieren
in Haskell
Sauthoff
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
Guards
1
2
3
4
> fn pat1 pat2 ...
>
| guard1 = expr1
>
| guard2 = expr2
>
...
Universität Bielefeld
Programmieren
in Haskell
Sauthoff
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Guards
1
2
3
4
> fn pat1 pat2 ...
>
| guard1 = expr1
>
| guard2 = expr2
>
...
syntaktische Zucker für Funktionsdefinitionen
Universität Bielefeld
Programmieren
in Haskell
Sauthoff
Administratives
Haskell
Syntax
Notation
ersetzt geschachtelte if-Anweisungen
Typsystem
guards (Wächter) sind Ausdrücke (vom Typ Bool)
Auswertung
Guards
1
2
3
4
> fn pat1 pat2 ...
>
| guard1 = expr1
>
| guard2 = expr2
>
...
syntaktische Zucker für Funktionsdefinitionen
2
3
4
Programmieren
in Haskell
Sauthoff
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
Layout
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 entscheident
Sauthoff
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Layout
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 entscheident
Sauthoff
Administratives
Haskell
Syntax
Notation
explizite Verwendung ; {} ist möglich
Typsystem
Auswertung
Layout
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 entscheident
Sauthoff
Administratives
Haskell
Syntax
Notation
explizite Verwendung ; {} ist möglich
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
Example
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
Sauthoff
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Layout
Example
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
Sauthoff
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Example
1
2
> f x = g x + h x
>
where { g x = x * x ; h x = x + x }
Layout
Example
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
Sauthoff
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Example
1
2
> f x = g x + h x
>
where { g x = x * x ; h x = x + x }
Vorteile
Nachteile
Prefix/Infix-Notation
Funktionen
Operatoren
Universität Bielefeld
Programmieren
in Haskell
Sauthoff
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Prefix/Infix-Notation
Funktionen
Operatoren
‘fn‘ konvertiert nach Infix
(op) koverniert nach Prefix
Universität Bielefeld
Programmieren
in Haskell
Sauthoff
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Prefix/Infix-Notation
Funktionen
Operatoren
‘fn‘ konvertiert nach Infix
(op) koverniert nach Prefix
Example
Universität Bielefeld
Programmieren
in Haskell
Sauthoff
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-Notation
Universität Bielefeld
Programmieren
in Haskell
Sauthoff
Administratives
Haskell
Syntax
Flexible Anwendung von Funktionen
Notation
Typsystem
Deklaration von Prioritäten
Auswertung
Pattern matching
Universität Bielefeld
Programmieren
in Haskell
Pattern Matching auf
natürlichen Zahlen
Werten
Datentyp-Konstruktoren
Joker
Sauthoff
Administratives
Haskell
Syntax
Notation
auf der linken Seite von Funktionsdefinitionen
Typsystem
in case-Ausdrücken
Auswertung
Pattern matching
Universität Bielefeld
Programmieren
in Haskell
Sauthoff
Pattern Matching auf
natürlichen Zahlen
Werten
Datentyp-Konstruktoren
Joker
Administratives
Haskell
Syntax
Notation
auf der linken Seite von Funktionsdefinitionen
Typsystem
in case-Ausdrücken
Auswertung
Example
1
2
3
> take ’
:: Int -> [ a ] -> [ a ]
> take ’ ( n + 1) ( a : as ) = a : take ’ n as
> take ’ _
_
= []
Pattern matching
Universität Bielefeld
Programmieren
in Haskell
Sauthoff
Example
Administratives
Haskell
1
2
3
4
>
>
>
>
f
f
f
f
( a : b : c : d : ds )
( a : as )
( a :[])
[a]
=
=
=
=
...
...
...
...
5
6
7
8
> g 0
> g 1
> g _
= ...
= ...
= ...
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
Sauthoff
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
Fließkommazahlen (Float, Double)
+, /, square
Wahrheitswerte (Bool): True, False
&&, ||
Listen ([a])
++, reverse, take
Zeichen (Char)
Zeichenketten (String), wobei String = [Char]
Universität Bielefeld
Programmieren
in Haskell
Sauthoff
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Datentypen
Universität Bielefeld
Programmieren
in Haskell
Sauthoff
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
Sauthoff
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
Sauthoff
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
Sauthoff
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
Sauthoff
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
Sauthoff
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
Sauthoff
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
Sauthoff
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
Sauthoff
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Listen
Universität Bielefeld
Notation:
[1,2,3,4]
1:2:3:4:[]
Programmieren
in Haskell
Sauthoff
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
Sauthoff
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Listen
Universität Bielefeld
Notation:
[1,2,3,4]
1:2:3:4:[]
Konstruktoren: : (cons)
[] (nil)
[1..10]
Programmieren
in Haskell
Sauthoff
Administratives
Haskell
Syntax
Notation
Signature: [a], [Int] usw.
Typsystem
Auswertung
Listen
Universität Bielefeld
Notation:
[1,2,3,4]
1:2:3:4:[]
Konstruktoren: : (cons)
[] (nil)
[1..10]
Programmieren
in Haskell
Sauthoff
Administratives
Haskell
Syntax
Notation
Signature: [a], [Int] usw.
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]
Programmieren
in Haskell
Sauthoff
Administratives
Haskell
Syntax
Notation
Signature: [a], [Int] usw.
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
Sauthoff
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
Sauthoff
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
Sauthoff
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
Sauthoff
Administratives
Haskell
Syntax
Auswertung von Haskell Programmen
⇒ Ausrechnen von einem funktionalem Programm
Notation
Typsystem
Auswertung
Ausdrücke und Werte
Universität Bielefeld
Programmieren
in Haskell
Sauthoff
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
Sauthoff
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
Sauthoff
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
Sauthoff
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
Sauthoff
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
Sauthoff
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
Sauthoff
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
Sauthoff
Administratives
Haskell wertet aus: Left-to-right, outermost first
Alternativ: Left-to-right, innermost first (eager evaluation)
→ non-lazy
square
Haskell
Syntax
Notation
Typsystem
Auswertung
Reduktionsvarianten
Universität Bielefeld
Programmieren
in Haskell
Sauthoff
Administratives
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) = >
=>
=>
=>
Haskell
Syntax
Notation
Typsystem
Auswertung
(3 + 4) * (3 + 4) ( square )
7 * (3 + 4)
(+)
7 * 7
(+)
49
(*)
Reduktionsvarianten
Universität Bielefeld
Programmieren
in Haskell
Sauthoff
1
2
3
take 0
take n
take n
non-lazy:
xs
= []
[]
= []
( x : xs ) = x : take (n -1) xs
take 2 [1..]
take 2 [1..] =>
=>
=>
=>
take 2 (1:[2..])
(..)
take 2 (1:2:[3..])
(..)
take 2 (1:2:3:[4..]) (..)
...
Administratives
Haskell
Syntax
Notation
Typsystem
Auswertung
Herunterladen