Programmieren in Haskell - Algebraische Datentypen

Programmieren
in Haskell
Stefan
Janssen
Programmieren in Haskell
Algebraische Datentypen
Typ-Synonyme
Algebraische
Datentypen
Leftovers
Musik
Stefan Janssen
Universität Bielefeld
AG Praktische Informatik
October 29, 2014
Abstraktion
Typsynonyme
Programmieren
in Haskell
1
2
3
1
Neue Typnamen durch Typsynonyme:
type Pair a b = (a , b )
type Triple a b c = (a ,b , c )
type OrdList a = [ a ]
definiert neue Namen, genannt Typ-Synonyme, für bereits
existieeremde Typen; hier im Beispiel für existierende
Tupel-Typen und Listen. Dient ausschliesslich der
Dokumentation.
newtype MyList a = [ a ]
führt ebenfalls einen NEUEN Typnamen analog zu [a] ein, der
aber nicht als typgleich betrachtet wird. Verhindert
gegenseitige Verwechslung von [a] und MyList a.
Stefan
Janssen
Typ-Synonyme
Algebraische
Datentypen
Leftovers
Musik
Abstraktion
Algebraische Datentypen
Programmieren
in Haskell
Neue Datentypen werden als algebraische Datentypen
eingeführt.
Stefan
Janssen
Typ-Synonyme
Werte des Datentyps sind Formeln, die aus Konstruktoren
zusammengesetzt sind
Konstruktoren sind Funktionen, die man deklarieren, aber
nicht definieren muss.
Konstruktornamen fangen mit Großbuchstaben an.
Algebraische Datentypen können polymorph sein und
Typ-Parameter haben.
Meistens sind sie rekursiv - ein Wert kann einen Teil-Wert
des gleichen Typs enthalten.
Algebraische
Datentypen
Leftovers
Musik
Abstraktion
Beispiel
Programmieren
in Haskell
1
2
data Bool = True |
False
Stefan
Janssen
Typ-Synonyme
Algebraische
Datentypen
Leftovers
Musik
Abstraktion
Beispiel
Programmieren
in Haskell
1
2
data Bool = True |
False
keine Typ-Parameter, nicht rekursiv, nur zwei Werte
Konstruktoren sind True und False
Stefan
Janssen
Typ-Synonyme
Algebraische
Datentypen
Leftovers
Musik
Abstraktion
Beispiel
Programmieren
in Haskell
1
2
data Bool = True |
False
keine Typ-Parameter, nicht rekursiv, nur zwei Werte
Konstruktoren sind True und False
Stefan
Janssen
Typ-Synonyme
Algebraische
Datentypen
Leftovers
Musik
→ beide null-stellig (nullary (data) constructor)
Funktionen nutzen pattern matching auf den
Konstruktoren, z.B. der Operator &&:
1
2
False && y = False
True && y = y
Abstraktion
Apropos Konstruktor
Programmieren
in Haskell
Stefan
Janssen
„Konstruktor“ meint immer (Daten-)Konstruktor.
Typ-Synonyme
Algebraische
Datentypen
Leftovers
Musik
Abstraktion
Apropos Konstruktor
Programmieren
in Haskell
Stefan
Janssen
1
„Konstruktor“ meint immer (Daten-)Konstruktor.
Einen Typnamen mit Parametern nennt man gelegentlich
„Typ-Konstruktor“
data T a b = ...
Typ-Konstruktor T “konstruiert” aus Typen a und b den Typ
T a b
Wir vermeiden die Bezeichnung “Typ-Konstruktor”.
Typ-Synonyme
Algebraische
Datentypen
Leftovers
Musik
Abstraktion
Beispiel
1
2
3
data Einheit
= Celsius
|
Fahrenheit |
Kelvin
Neuer Typ mit genau drei Werten.
Programmieren
in Haskell
Stefan
Janssen
Typ-Synonyme
Algebraische
Datentypen
Leftovers
Musik
Abstraktion
Beispiel
1
2
3
1
data Einheit
= Celsius
|
Fahrenheit |
Kelvin
Neuer Typ mit genau drei Werten.
data Temperatur = Temp Float Einheit
Programmieren
in Haskell
Stefan
Janssen
Typ-Synonyme
Algebraische
Datentypen
Leftovers
Musik
Abstraktion
Beispiel
1
2
3
1
data Einheit
= Celsius
|
Fahrenheit |
Kelvin
Neuer Typ mit genau drei Werten.
data Temperatur = Temp Float Einheit
(Einziger) Konstruktor Temp hat zwei Argumente, deren
Typen deklariert werden.
Programmieren
in Haskell
Stefan
Janssen
Typ-Synonyme
Algebraische
Datentypen
Leftovers
Musik
Abstraktion
Beispiel
1
2
3
1
data Einheit
= Celsius
|
Fahrenheit |
Kelvin
Neuer Typ mit genau drei Werten.
data Temperatur = Temp Float Einheit
(Einziger) Konstruktor Temp hat zwei Argumente, deren
Typen deklariert werden.
1
2
Programmieren
in Haskell
Stefan
Janssen
Typ-Synonyme
Algebraische
Datentypen
Leftovers
Musik
Abstraktion
data Temp = Temp Float Einheit -- erlaubt und
-- ueblich !
Beispiel
1
2
3
1
data Einheit
= Celsius
|
Fahrenheit |
Kelvin
Neuer Typ mit genau drei Werten.
data Temperatur = Temp Float Einheit
(Einziger) Konstruktor Temp hat zwei Argumente, deren
Typen deklariert werden.
1
2
Programmieren
in Haskell
Stefan
Janssen
Typ-Synonyme
Algebraische
Datentypen
Leftovers
Musik
Abstraktion
data Temp = Temp Float Einheit -- erlaubt und
-- ueblich !
→ Typkonstruktoren und (Daten-)Konstruktoren haben
getrennte Namensräume
Beispiel
Programmieren
in Haskell
1
Temp 506 Kelvin
:: Temperatur
Stefan
Janssen
Typ-Synonyme
Algebraische
Datentypen
Leftovers
Musik
Abstraktion
Beispiel
Programmieren
in Haskell
1
Temp 506 Kelvin
:: Temperatur
Stefan
Janssen
Typ-Synonyme
Algebraische
1
2
celsius2kelvin
celsius2kelvin t
Datentypen
:: Float -> Temperatur
Leftovers
= Temp ( t + 273.15) Kelvin
Musik
3
4
5
6
kel vin2fahrenheit
:: Float -> Temperatur
kel vin2fahrenheit t =
Temp ( t *9/5 -459.67) Fahrenheit
Das Beispiel ist inkonsequent, weil das Argument selbst nicht
vom Typ Temperatur ist.
Abstraktion
Beispiel
Programmieren
in Haskell
Stefan
Janssen
1
2
3
4
5
6
7
8
Temperatur-Umrechnung:
conv :: Temperatur -> Einheit -> Temperatur
conv ( Temp t Celsius ) Celsius
=
Temp t Celsius
conv ( Temp t Celsius ) Kelvin
=
Temp ( t + 273.15) Kelvin
conv ( Temp t Kelvin ) Fahrenheit =
Temp ( t *9/5 -459.67) Fahrenheit
...
Typ-Synonyme
Algebraische
Datentypen
Leftovers
Musik
Abstraktion
Algebraische Datentypen
Programmieren
in Haskell
Stefan
Janssen
Allgemeine Form der Deklaration:
data T a1 . . . am = C1 t11 . . . t1n1
...
Cr tr 1 . . . trnr
|
|
Typ-Synonyme
Algebraische
Datentypen
Leftovers
Musik
Abstraktion
Algebraische Datentypen
Programmieren
in Haskell
Stefan
Janssen
Allgemeine Form der Deklaration:
data T a1 . . . am = C1 t11 . . . t1n1
...
Cr tr 1 . . . trnr
|
|
Typ-Synonyme
Algebraische
Datentypen
Leftovers
Musik
Abstraktion
T Typkonstruktor
Ci (Daten-)Konstruktoren
ai Typvariablen
tij Typen oder Typvariablen
Beispiel: Listen
Programmieren
in Haskell
1
2
Wenn man Listen noch einführen müßte ...
data List a = Cons a ( List a ) |
Nil
Stefan
Janssen
Typ-Synonyme
Algebraische
Datentypen
Leftovers
Musik
Abstraktion
Beispiel: Listen
Programmieren
in Haskell
1
2
Wenn man Listen noch einführen müßte ...
data List a = Cons a ( List a ) |
Nil
polymorhper Typ (Typ-Parameter a)
→ Algebraischer Datentyp List ist rekursiv definiert
Stefan
Janssen
Typ-Synonyme
Algebraische
Datentypen
Leftovers
Musik
Abstraktion
Beispiel: Listen
Programmieren
in Haskell
1
2
Wenn man Listen noch einführen müßte ...
data List a = Cons a ( List a ) |
Nil
polymorhper Typ (Typ-Parameter a)
→ Algebraischer Datentyp List ist rekursiv definiert
eingebaute Listentyp erlaubt syntaktischen Zucker:
: — „Cons“als Infix-Operator
[] — „Nil“
[] — Typ-Konstruktor, etwa in [Int]
Spezielle Listen-Notationen
Auf selbstgemachten Datentypen bekommen wir keine so
schöne Notation.
Stefan
Janssen
Typ-Synonyme
Algebraische
Datentypen
Leftovers
Musik
Abstraktion
Daten als Bäume dergestellt
Example
[1..5] = [1,2,3,4,5] = 1:2:3:4:5:[]
Programmieren
in Haskell
Stefan
Janssen
Typ-Synonyme
Algebraische
Datentypen
Leftovers
Musik
Abstraktion
Daten als Bäume dergestellt
Programmieren
in Haskell
Example
[1..5] = [1,2,3,4,5] = 1:2:3:4:5:[]
Typ-Synonyme
Cons
Algebraische
Datentypen
Leftovers
Cons
1
Stefan
Janssen
Musik
Abstraktion
2
Cons
3
Cons
4 Cons
5 Nil
Daten als Bäume dergestellt
Programmieren
in Haskell
Example
Stefan
Janssen
[1..5] = [1,2,3,4,5] = 1:2:3:4:5:[]
Algebraische
Datentypen
1
Cons
1
Typ-Synonyme
:
Cons
Leftovers
:
Musik
2
2
Cons
3
Cons
4 Cons
5 Nil
Abstraktion
:
3
:
4
:
5 []
Typ Maybe – hilft aus einer Verlegenheit
1
2
data Maybe a = Just a |
Nothing
Programmieren
in Haskell
Stefan
Janssen
Typ-Synonyme
Algebraische
Datentypen
Leftovers
Musik
Abstraktion
Typ Maybe – hilft aus einer Verlegenheit
1
2
data Maybe a = Just a |
Nothing
Konstruktor Just ist ein-stellig
Typvariable a als Parameter
Programmieren
in Haskell
Stefan
Janssen
Typ-Synonyme
Algebraische
Datentypen
Leftovers
Musik
Abstraktion
Typ Maybe – hilft aus einer Verlegenheit
1
2
data Maybe a = Just a |
Nothing
Konstruktor Just ist ein-stellig
Typvariable a als Parameter
Eine Form der Fehlerbehandlung bzw. Vorbeugung, wenn
eine Funktion ein Ergebnis liefert, das nicht in jedem Fall
existiert
Programmieren
in Haskell
Stefan
Janssen
Typ-Synonyme
Algebraische
Datentypen
Leftovers
Musik
Abstraktion
Typ Maybe – hilft aus einer Verlegenheit
1
2
data Maybe a = Just a |
Nothing
Konstruktor Just ist ein-stellig
Typvariable a als Parameter
Eine Form der Fehlerbehandlung bzw. Vorbeugung, wenn
eine Funktion ein Ergebnis liefert, das nicht in jedem Fall
existiert
1
2
3
> divide a b =
>
if b == 0 then error " divide by zero "
>
else div a b
Programmieren
in Haskell
Stefan
Janssen
Typ-Synonyme
Algebraische
Datentypen
Leftovers
Musik
Abstraktion
Typ Maybe – hilft aus einer Verlegenheit
1
2
data Maybe a = Just a |
Nothing
Konstruktor Just ist ein-stellig
Typvariable a als Parameter
Eine Form der Fehlerbehandlung bzw. Vorbeugung, wenn
eine Funktion ein Ergebnis liefert, das nicht in jedem Fall
existiert
1
2
3
1
2
3
> divide a b =
>
if b == 0 then error " divide by zero "
>
else div a b
Mit Maybe:
> divide a b
>
| b == 0
= Nothing
>
| otherwise
= Just ( div a b )
Programmieren
in Haskell
Stefan
Janssen
Typ-Synonyme
Algebraische
Datentypen
Leftovers
Musik
Abstraktion
Beispiel: Maybe
Programmieren
in Haskell
Stefan
Janssen
1
Typ von divide:
divide :: ( Num a ) = > a -> a -> Maybe a
Typ-Synonyme
Algebraische
Datentypen
Leftovers
Musik
Abstraktion
Beispiel: Maybe
Programmieren
in Haskell
Stefan
Janssen
1
1
2
3
4
Typ von divide:
divide :: ( Num a ) = > a -> a -> Maybe a
Pattern matching:
f a b = extract ( divide a b ) + ...
where
extract ( Just x ) = x
extract Nothing
= 0
Was ist der Typ von extract?
Typ-Synonyme
Algebraische
Datentypen
Leftovers
Musik
Abstraktion
Derived instance declarations
Programmieren
in Haskell
Optionale deriving Form:
data T a1 . . . am = C1 t11 . . . t1n1
...
Cr tr 1 . . . trnr
deriving (k1 , . . . , ku )
|
|
Stefan
Janssen
Typ-Synonyme
Algebraische
Datentypen
Leftovers
Musik
Abstraktion
Derived instance declarations
Programmieren
in Haskell
Optionale deriving Form:
data T a1 . . . am = C1 t11 . . . t1n1
...
|
|
Cr tr 1 . . . trnr
deriving (k1 , . . . , ku )
Stefan
Janssen
Typ-Synonyme
Algebraische
Datentypen
Leftovers
Musik
Abstraktion
kx Typklassen
für bestimmte Klassen können Instanzen automatisch
erzeugt werden
das heißt, alle Operationen der Klassen werden auf dem
neuen Typ T automatisch implementiert.
Derived instance declarations
Programmieren
in Haskell
Optionale deriving Form:
data T a1 . . . am = C1 t11 . . . t1n1
...
|
|
Cr tr 1 . . . trnr
deriving (k1 , . . . , ku )
Stefan
Janssen
Typ-Synonyme
Algebraische
Datentypen
Leftovers
Musik
Abstraktion
kx Typklassen
für bestimmte Klassen können Instanzen automatisch
erzeugt werden
das heißt, alle Operationen der Klassen werden auf dem
neuen Typ T automatisch implementiert.
→ einfacher als explizite Definition, die auch möglich ist
... deriving ...
Programmieren
in Haskell
Stefan
Janssen
Typ-Synonyme
Example
1
2
3
Algebraische
Datentypen
data Maybe a = Nothing |
Leftovers
Just a
Musik
deriving ( Eq , Ord , Read , Show
)
Abstraktion
Damit sind Operationen wie == oder < auf dem Typ Maybe
implementiert.
Programmieren
in Haskell
Stefan
Janssen
Typ-Synonyme
Algebraische
Datentypen
Und jetzt mal selber eine interessanten algebraischen Datentyp
definieren!!
Leftovers
Musik
Abstraktion
Konstruktoren mit benannten Feldern
Nachtrag (der Vollständigkeit halber):
Programmieren
in Haskell
Stefan
Janssen
Typ-Synonyme
1
2
1
2
3
Konstruktoren können mit Namen (field names) für ihre
Algebraische
Datentypen
Argumente deklariert werden
Leftovers
.. das kennt man aus anderen Sprachen als “records”
Musik
Beispiel: Punkte im Koordinatensystem
Abstraktion
Neben der bisherigen Typ Definition wie z.B.
> data Point = Pt Float Float |
Pol Float Float String deriving ( Show
gibt es auch die Form
> data Point = Pt { pointx , pointy :: Float } |
>
Pol { angle , stretch :: Float ,
>
color :: String } deriving ( Show , Eq )
Verwendung der Konstruktoren
Programmieren
in Haskell
1
2
3
4
Mit oder ohne Verwendung der Feldnamen
> p1 = Pt { pointx =1 , pointy =2}
> p2 = Pt { pointy =2 , pointx =1}
> p3 = Pol 45 1
> p30 = Pol { angle =45 , stretch =1}
Stefan
Janssen
Typ-Synonyme
Algebraische
Datentypen
Leftovers
Musik
5
Abstraktion
6
7
> p4 = Pt { pointx =0 , pointy =1}
> p5 = Pol { angle =90 , stretch =1 , color = " yellow " }
Bei verwendung der Namen:
Die Klammern sind notwendig
die Reihenfolge ist beliebig
Nutzen der Feldnamen
Programmieren
in Haskell
Feldnamen vorwiegend gebraucht bei Konstruktoren mit sehr
vielen Argumenten
Anordnung ist egal: Pt 1 2 =
Pt{pointy=2, pointx=1}
Stefan
Janssen
Typ-Synonyme
Algebraische
Datentypen
Leftovers
Feldnamen dienen als vordefinierte Selektoren
Musik
mirror p = Pt {pointx= pointy p, pointy = pointx p}
gleichnamige Feldnamen unter verschiedenen
Konstruktoren sind erlaubt ... mit gleichem Typ
Nicht alle Felder müssen definiert werden:
p30 = Pol{angle=45, stretch=1}
lässt Feld color undefiniert – im Unterschied zu
p3 = Pol 45 1
Abstraktion
Subtiler Unterschied –was geht hier vor?
Main> p30
Pol {angle = 45.0, stretch = 1.0, color = "
Program error: undefined field: Pol
Programmieren
in Haskell
Stefan
Janssen
Typ-Synonyme
Main> p3
ERROR - Cannot find "show" function for:
*** Expression : p3
*** Of type
: String -> Point
Algebraische
Datentypen
Leftovers
Musik
Abstraktion
Main> p3 "red"
Pol {angle = 45.0, stretch = 1.0, color = "red"}
Main> p30 "red"
ERROR - Type error
*** Expression
*** Term
*** Type
*** Does not match
in application
: p30 "red"
: p30
: Point
: a -> b
Modellierung von Musik
Programmieren
in Haskell
cis
dis
fis
gis
ais
cis
dis
fis
gis
ais
des
es
ges
as
b
des
es
ges
as
b
Stefan
Janssen
Typ-Synonyme
Algebraische
Datentypen
Leftovers
Musik
Abstraktion
c
d
e
f
g
a
h
c
d
e
f
Quelle: http://commons.wikimedia.org/wiki/File:Klaviatur.svg, Public Domain
g
a
h
Modellierung von Musik
1
2
> module Musik where
> import R a t i o
Programmieren
in Haskell
Stefan
Janssen
3
4
5
> infixr 7 :∗:
> i n f i x r 6 :+:
Typ-Synonyme
6
7
8
> type G a n z e Z a h l
> type Bruch
= Int
= Ratio Int
> type Ton
> type Dauer
= GanzeZahl
= Bruch
Algebraische
Datentypen
Leftovers
9
10
11
Musik
Abstraktion
12
13
14
15
16
17
18
19
20
> data Musik
=
>
Note
Ton
Dauer
>
Pause Dauer
>
Musik
:∗:
Musik
>
Musik
:+:
Musik
>
Instr
I n s t r u m e n t Musik
>
Tempo G a n z e Z a h l
Musik
>
deriving
|
|
|
|
|
−− h i n t e r e i n a n d e r
−− g l e i c h z e i t i g
−− S c h l a e g e p r o Minute
Show
Modellierung von Musik
Programmieren
in Haskell
Stefan
Janssen
22
23
24
147
148
149
150
151
> data Instrument =
>
A co usticGrand Pi an o
|
>
B ri ghtAcousti cP i a no |
...
>
TelephoneRing
|
>
Helicopter
|
>
Applause
|
>
Gunshot
>
deriving ( Show , Enum )
Typ-Synonyme
Algebraische
Datentypen
Leftovers
Musik
Abstraktion
Modellierung von Musik
Programmieren
in Haskell
Stefan
Janssen
Sieben Ganztöne: c d e f g a h
c
Halbtöne über den Tönen:
cis dis eis (= f) fis gis ais his (=c)
Typ-Synonyme
Halbtöne unter den Tönen:
ces (=h) des es fes (=e) ges as b
Leftovers
Algebraische
Datentypen
Musik
cis
dis
fis
gis
ais
cis
dis
fis
gis
ais
des
es
ges
as
b
des
es
ges
as
b
d
e
f
g
a
h
c
d
e
f
g
a
Abstraktion
h
Modellierung von Musik
19
> module M u s i k H e l p e r where
Programmieren
in Haskell
20
21
Stefan
Janssen
> import Musik
22
Typ-Synonyme
23
24
25
> ce , c i s , des , de , d i s , es , eh , e i s , f e s
> e f , f i s , ges , ge , g i s , as , ah , a i s , be , ha , h i s
cis
dis
fis
gis
ais
cis
dis
fis
gis
ais
des
es
ges
as
b
des
es
ges
as
b
: : TonAlgebraische
: : TonDatentypen
Leftovers
Musik
Abstraktion
c
d
e
f
g
a
h
c
d
e
f
g
a
h
Modellierung von Musik
19
> module M u s i k H e l p e r where
Programmieren
in Haskell
20
21
Stefan
Janssen
> import Musik
22
Typ-Synonyme
23
24
25
> ce , c i s , des , de , d i s , es , eh , e i s , f e s
> e f , f i s , ges , ge , g i s , as , ah , a i s , be , ha , h i s
Leftovers
26
27
28
29
30
31
32
33
: : TonAlgebraische
: : TonDatentypen
>
>
>
>
>
>
>
ce
de
eh
ef
ge
ah
ha
=
=
=
=
=
=
=
0
2
4
5
7
9
11
;
;
;
;
;
;
;
cis
dis
eis
fis
gis
ais
his
=
=
=
=
=
=
=
1
3
5
6
8
10
12
;
;
;
;
;
;
des
es
fes
ges
as
be
=
=
=
=
=
=
1
3
4
6
8
10
Musik
Abstraktion
Formeln, die Musik bedeuten
1
2
3
Note
0 (1/4)
Note 24 (1/1)
Pause
(1/16)
-- Viertelnote tiefes C
-- ganze Note
c’
-- Sechzehntelpause
4
5
6
Programmieren
in Haskell
Stefan
Janssen
Typ-Synonyme
Algebraische
Datentypen
Note 24 (1/4) :*: Note 26 (1/4) :*: Note 28 (1/4)
Leftovers
-- Anfang der C - Dur Tonleiter
(c
Musik
7
Abstraktion
8
9
Note 24 (1/4) :+: Note 28 (1/4) :+: Note 31 (1/4)
-- C - Dur Akkord (c ,e , g )
10
11
12
13
14
Tempo
Tempo
Instr
Instr
70 m
180 m
Oboe m
VoiceAahs m
-----
Musik
Musik
Musik
Musik
m
m
m
m
als Adagio
als Presto
von Oboe gespielt
gesummt
Abkürzungen
35
> gP , hP , vP , aP , sP :: Musik
36
37
38
39
40
41
>
>
>
>
>
gP
hP
vP
aP
sP
=
=
=
=
=
Pause
Pause
Pause
Pause
Pause
(1/1)
(1/2)
(1/4)
(1/8)
(1/16)
Programmieren
in Haskell
Stefan
Janssen
Typ-Synonyme
Algebraische
Datentypen
Leftovers
Musik
Abstraktion
Abkürzungen
35
> gP , hP , vP , aP , sP :: Musik
36
37
38
39
40
41
43
>
>
>
>
>
gP
hP
vP
aP
sP
=
=
=
=
=
Pause
Pause
Pause
Pause
Pause
(1/1)
(1/2)
(1/4)
(1/8)
(1/16)
46
47
48
Stefan
Janssen
Typ-Synonyme
Algebraische
Datentypen
Leftovers
Musik
Abstraktion
> adagio , andante , allegro , presto :: GanzeZahl
44
45
Programmieren
in Haskell
>
>
>
>
adagio = 70
andante = 90
allegro = 140
presto = 180
Abkürzungen
Programmieren
in Haskell
Stefan
Janssen
50
> c’ , d’ , e’ , f ’ , g’ , a’ , h’ , c’ ’
51
52
53
54
55
56
57
58
59
>
>
>
>
>
>
>
>
c’
d’
e’
f’
g’
a’
h’
c’’
u
u
u
u
u
u
u
u
=
=
=
=
=
=
=
=
Note
Note
Note
Note
Note
Note
Note
Note
( c e +24)
( de +24)
( eh +24)
( e f +24)
( ge +24)
( ah +24)
( ha +24)
( c e +36)
u
u
u
u
u
u
u
u
: : Dauer −> Musik
Typ-Synonyme
Algebraische
Datentypen
Leftovers
Musik
Abstraktion
Zusammengesetzte Klänge
Programmieren
in Haskell
61
> c DurTon i ka : : Musik
Stefan
Janssen
62
63
> c DurTon i ka = c ’ ( 1 / 1 ) : + : e ’ ( 1 / 1 ) : + : g ’ ( 1 / 1 )
Typ-Synonyme
Algebraische
Datentypen
Leftovers
Musik
Abstraktion
Zusammengesetzte Klänge
Programmieren
in Haskell
61
> c DurTon i ka : : Musik
Stefan
Janssen
62
63
> c DurTon i ka = c ’ ( 1 / 1 ) : + : e ’ ( 1 / 1 ) : + : g ’ ( 1 / 1 )
64
65
66
67
68
> cDurSkala
>
c ’ (3/8)
>
>
= Tempo a l l e g r o (
: ∗ : d ’ (1/8) : ∗ : e ’ (3/8) : ∗ : f ’ (4/8)
: ∗ : g ’ (1/8) : ∗ : a ’ (1/4) : ∗ : h ’ (1/8)
: ∗ : c ’ ’ (1/2))
Typ-Synonyme
Algebraische
Datentypen
Leftovers
Musik
Abstraktion
Zusammengesetzte Klänge
Programmieren
in Haskell
61
> c DurTon i ka : : Musik
Stefan
Janssen
62
63
> c DurTon i ka = c ’ ( 1 / 1 ) : + : e ’ ( 1 / 1 ) : + : g ’ ( 1 / 1 )
64
65
66
67
68
70
71
> cDurSkala
>
c ’ (3/8)
>
>
= Tempo a l l e g r o (
: ∗ : d ’ (1/8) : ∗ : e ’ (3/8) : ∗ : f ’ (4/8)
: ∗ : g ’ (1/8) : ∗ : a ’ (1/4) : ∗ : h ’ (1/8)
: ∗ : c ’ ’ (1/2))
> durDreiklang t
>
= Note t ( 1 / 1 ) : + : Note ( t +4) ( 1 / 1 )
: + : Note ( t +7) ( 1 / 1 )
72
73
74
> m o l l D r e i k l a n g t = Note t ( 1 / 1 ) : + : Note ( t +3) ( 1 / 1 )
>
: + : Note ( t +7) ( 1 / 1 )
Typ-Synonyme
Algebraische
Datentypen
Leftovers
Musik
Abstraktion
Transponierung
Programmieren
in Haskell
Stefan
Janssen
Typ-Synonyme
79
> transponiere
: : Ton −> Musik −> Musik
Algebraische
Datentypen
80
81
82
83
84
85
86
>
>
>
>
>
>
t r a n s p o n i e r e i ( Pause d )
=
t r a n s p o n i e r e i ( Note t d ) =
t r a n s p o n i e r e i (m1 : ∗ : m2) =
:∗:
t r a n s p o n i e r e i (m1 : + : m2) =
:+:
Pause d
Note ( t+i ) d
( transponiere
( transponiere
( transponiere
( transponiere
Leftovers
i
i
i
i
m1)
m2)
m1)
m2)
Musik
Abstraktion
Verschiedenes
Programmieren
in Haskell
Stefan
Janssen
Typ-Synonyme
92
93
> wdh
: : Musik −> Musik
> wdh m = m : ∗ : m
Leftovers
94
95
96
> ad_infinitum
: : Musik −> Musik
> ad_infinitum m = m : ∗ : ad_infinitum m
97
98
Algebraische
Datentypen
> einsatz
d m = ( Pause d ) : ∗ : m
Musik
Abstraktion
Bruder Jakob: Text
Programmieren
in Haskell
Bruder Jakob, Bruder Jakob
Schläfst du noch? Schläfst du noch?
||: Hörst du nicht die Glocken? :||
Ding dang dong, ding dang dong.
Stefan
Janssen
Typ-Synonyme
Algebraische
Datentypen
Leftovers
Musik
Abstraktion
Quelle: http://de.wikipedia.org/w/index.php?title=Datei:
FrereJacques1pt.png&filetimestamp=20070819210216, Public Domain
Bruder Jakob: Bauelemente
100
101
102
103
104
105
Programmieren
in Haskell
Stefan
Janssen
Typ-Synonyme
>
>
>
>
>
>
phrase1 = c ’ (1/4) : ∗ :
phrase2 = e ’ (1/4) : ∗ :
phrase3 = g ’ (1/8) : ∗ :
: ∗ : e ’ (1/4)
phrase4 = c ’ (1/4) : ∗ :
s t r o p h e = wdh p h r a s e 1
d ’ ( 1 / 4 ) : ∗ : e ’ ( 1 / 4 ) : ∗ : c ’ ( 1Algebraische
/4)
Datentypen
f ’ (1/4) : ∗ : g ’ (1/2)
Leftovers
a ’ (1/8) : ∗ : g ’ (1/8) : ∗ : f ’ (1/8)
Musik
: ∗ : c ’ (1/4)
( t r a n s p o n i e r e ( −12) ( g ’ ( 1 / 4 ) ) )Abstraktion
:∗: c ’
: ∗ : wdh p h r a s e 2 : ∗ : wdh p h r a s e 3 : ∗ : wdh
Bruder Jakob: Der ganze Kanon
107
Programmieren
in Haskell
Stefan
Janssen
endlos = ad_infinitum strophe
108
−− h i e r bekommen w i r S c h w i e r i g k
−− wenn w i r d a s i n MIDI Typ-Synonyme
umwande
Algebraische
Datentypen
109
110
> endlos = strophe : ∗ : strophe
Leftovers
111
112
113
114
115
116
> b r u d e r J a k o b = Tempo a n d a n t e
>
( e i n s a t z (0/1)
:+:
>
( e i n s a t z (2/1)
>
( e i n s a t z (4/1)
:+:
>
( e i n s a t z (6/1)
( I n s t r ChoirAahs
endlos
Musik
Abstraktion
( t r a n s p o n i e r e 12 e n d l o s ) ) : + :
endlos )
endlos )))
Bruder Jakob: Variante
118
Programmieren
in Haskell
Stefan
Janssen
Typ-Synonyme
Eine Variante
Algebraische
Datentypen
119
120
121
122
123
124
> bruderJakob2
>
:+:
>
>
:+:
>
= Tempo a l l e g r o ( I n s t r A c o u s t i c G r a n d P i a n o
Leftovers
( e i n s a t z (0/1) endlos
Musik
( e i n s a t z ( 2 / 1 ) ( t r a n s p o n i e r e 12 e n d l o s ) ) Abstraktion
:+:
( e i n s a t z (4/1) endlos )
( e i n s a t z (6/1) endlos ) ) )
Abstraktion ...
130
131
Programmieren
in Haskell
> tritonus_f_1
> tritonus t d
= Note e f ( 1 / 1 ) : + : Note ha ( 1 / 1 )
= Note t d
: + : Note ( t +6) d
132
133
134
Stefan
Janssen
Typ-Synonyme
> tritonus_f_1
> tritonus
: : Musik
: : Ton −> Dauer −> Musik
Algebraische
Datentypen
Leftovers
Musik
Abstraktion – das ist hier der Übergang von einer Formel, die
einen Musikstück beschreibt, zu einer Funktion, die abhängig
von ihren Parametern ein Musikstück konstruiert.
Sie erlaubt es uns, in unserer Formelsprache für Musik auch
harmonische Gesetze zu definieren. In der klassischen
Notenschrift geht das nicht.
Abstraktion
Musik
Programmieren
in Haskell
Stefan
Janssen
Wir verwenden bisher das Haskore-System.
Der Nachfolger von Haskore ist Euterpea:
http://haskell.cs.yale.edu/?page_id=103
Paul Hudak. The Haskell School of Music. 2.0 edition,
2011.
http:
//www.cs.yale.edu/homes/hudak/Papers/HSoM.pdf
Typ-Synonyme
Algebraische
Datentypen
Leftovers
Musik
Abstraktion