WS 2011/2012. Robert Giegerich. October 30, 2013

Ähnliche Dokumente
WS 2011/2012. Georg Sauthoff 1. October 26, 2011

October 29, Universität Bielefeld AG Praktische Informatik. Programmieren in Haskell. Stefan Janssen. Typ-Synonyme. Algebraische Datentypen

Kapitel 2: Modellierung. Programmieren in Haskell 1

(einsatz (2/1) (transponiere 12 endlos)) (einsatz (4/1) endlos) :+: (einsatz (6/1) endlos )))

Programmieren in Haskell

WS 2011/2012. Georg Sauthoff 1. November 1, 2011

WS 2011/2012. Georg Sauthoff 1. November 11, 2011

Typ-Polymorphismus. November 12, 2014

Programmieren in Haskell

Kapitel 3: Eine einfache Programmiersprache. Programmieren in Haskell 1

ALP I. Funktionale Programmierung

Programmieren in Haskell Einstieg in Haskell

Programmieren in Haskell

Grundlegende Datentypen

Programmieren in Haskell

Funktionale Programmierung Grundlegende Datentypen

Einführung in die funktionale Programmierung

Grundlegende Datentypen

Programmieren in Haskell

Grundlegende Datentypen

Praktische Informatik 3: Funktionale Programmierung Vorlesung 4 vom : Typvariablen und Polymorphie

Programmierkurs II. Typsynonyme & algebraische Datentypen

Einführung in Haskell

Programmieren in Haskell Das Haskell Typsystem

Funktionale Programmierung Mehr funktionale Muster

WS 2012/2013. Robert Giegerich. 21. November 2012

Paradigmen der Programmierung

Programmieren in Haskell Programmiermethodik

WS 2011/2012. Georg Sauthoff 1. October 18, 2011

Praktische Informatik 3: Funktionale Programmierung Vorlesung 4 vom : Typvariablen und Polymorphie

WS 2013/2014. Robert Giegerich. 11. Dezember 2013

WS 2011/2012. Robert Giegerich. October 17, 2012

9 Algebraische Datentypen

Prüfung Funktionale Programmierung

Algorithmen und Programmieren 1 Funktionale Programmierung - Musterlösung zur Übungsklausur -

Typklassen. Natascha Widder

Einführung in die Funktionale Programmierung mit Haskell

WS 2013/2014. Robert Giegerich. 11. Dezember 2013

Proinformatik Marco Block Dienstag, den 21. Juli 2009

WS 2011/2012. RobertGiegerich. November 12, 2013

WS 2011/2012. RobertGiegerich. November 12, 2013

Haskell, Typen, und Typberechnung. Grundlagen der Programmierung 3 A. Einige andere Programmiersprachen. Typisierung in Haskell

Die Definition eines Typen kann rekursiv sein, d.h. Typ-Konstruktoren dürfen Elemente des zu definierenden Typ erhalten.

Workshop Einführung in die Sprache Haskell

ALP I. Funktionale Programmierung

Funktionale Programmierung und Typtheorie

Übergang von funktionaler zu OOP. Algorithmen und Datenstrukturen II 1

Grundlagen der Programmierung 2 A (Listen)

Listen und Listenfunktionen. Grundlagen der Programmierung 2 A (Listen) Listen und Listenfunktionen. Listen? Haskell: Listen

Prüfung Funktionale Programmierung

Programmieren in Haskell. Stefan Janssen. Strukturelle Rekursion. Universität Bielefeld AG Praktische Informatik. 10.

WS 2012/2013. Robert Giegerich. January 22, 2014

Grundlagen der Programmierung 3 A

Informatik A WS 2007/08. Nachklausur

Haskell for Hackers... or why functional programming matters

Funktionale Programmierung. Monoide. Prof. Dr. Oliver Braun. Fakultät für Informatik und Mathematik Hochschule München

Grundlagen der Programmierung 3 A

Verarbeitung unendlicher Datenstrukturen Jetzt können wir z.b. die unendliche Liste aller geraden Zahlen oder aller Quadratzahlen berechnen:

Was bisher geschah. deklarative Programmierung. funktionale Programmierung (Haskell):

Tag 7. Pattern Matching und eigene Datentypen

WS 2011/2012. Robert Giegerich Dezember 2013

Beispiele: Funktionsabstraktion (3) Funktionsdeklaration. Funktionsdeklaration (2) Funktionsdeklaration (3) 3. Abstraktion über Funktionsbezeichner:

Funktionale Programmierung

Monoide. Funktionale Programmierung. Prof. Dr. Oliver Braun Letzte Änderung: :54. Monoide 1/16

PROGRAMMIERUNG UND MODELLIERUNG

Motivation Von Funktoren, Komposition, Applikation Zu Monoiden Die Monade Zusammenfassung. Monaden für alle. Franz Pletz

Programmieren in Haskell Programmieren mit Listen

Einführung in die Informatik 2

Programmieren in Haskell

Monaden. 14. Januar 2015

Programmieren in Haskell

Grundlagen der Programmierung 2 (2.A)

Haskell, Typen, und Typberechnung. Grundlagen der Programmierung 3 A. Überladung und Konversion in Haskell. Typisierung in Haskell

Funktionale Programmierung ALP I. Funktionen höherer Ordnung SS Prof. Dr. Margarita Esponda. Prof. Dr. Margarita Esponda

Praktische Informatik 3: Funktionale Programmierung Vorlesung 6 vom : Funktionen Höherer Ordnung II und Effizienzaspekte

Abstrakte Datentypen I

Programmieren in Haskell

Vorsemesterkurs Informatik

Funktionen höherer Ordnung. 3. Dezember 2014

Programmieren in Haskell

Typklassen und Überladung in Haskell

Zahlen in Haskell Kapitel 3

Abstrakte Datentypen II

Programmieren in Haskell Abstrakte Datentypen

Funktionale Programmierung

Basiskonstrukte von Haskell

Kapitel 6: Abstraktion. Programmieren in Haskell 1

Haskell für Mathematiker

ProInformatik: Funktionale Programmierung. Punkte

Einführung in die Funktionale Programmierung mit Haskell

HASKELL KAPITEL 2.1. Notationen: Currying und das Lambda-Kalkül

Frank eine Programmiersprache mit Effekten

Frage, Fragen und nochmals Fragen

Einführung in die Informatik 2

Crashkurs: Haskell. Mentoring FU Berlin Felix Droop

expr :: Expr expr = Mul (Add (Const 3) (Const 4)) (Div (Sub (Const 73) (Const 37)) (Const 6))

Programmieren in Haskell

Praktische Informatik 3: Funktionale Programmierung Vorlesung 11 vom : Monaden als Berechnungsmuster

Transkript:

WS 2011/2012 Robert AG Praktische Informatik October 30, 2013

Algebraische Datentypen Neue Datentypen werden als algebraische Datentypen eingeführt. 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.

Beispiel 1 data Bool = True 2 False keine Typ-Parameter, nicht rekursiv, nur zwei Werte Konstruktoren sind True und False beide null-stellig (nullary (data) constructor) Funktionen nutzen pattern matching auf den Konstruktoren, z.b. der Operator &&: 1 False && y = False 2 True && y = y

Apropos Konstruktor Konstruktor meint immer (Daten-)Konstruktor. Einen Typnamen mit Parametern nennt man gelegentlich Typ-Konstruktor 1 data T a b =... Typ-Konstruktor T konstruiert aus Typen a und b den Typ T a b

Beispiel 1 data Einheit = Celsius 2 Fahrenheit 3 Kelvin Neuer Typ mit genau drei Werten. 1 data Temperatur = Temp Float Einheit (Einziger) Konstruktor Temp hat zwei Argumente, deren Typen deklariert werden. 1 data Temp = Temp Float Einheit -- erlaubt und 2 -- ueblich! Typkonstruktoren und (Daten-)Konstruktoren haben getrennte Namensräume

Beispiel 1 Temp 506 Kelvin :: Temperatur 1 celsius2kelvin :: Float - > Temperatur 2 celsius2kelvin t = Temp ( t + 273.15) Kelvin 3 4 kel vin2fa hrenhe it :: Float - > Temperatur 5 kel vin2fa hrenhe it t = 6 Temp (t *9/5-459.67) Fahrenheit Das Beispiel ist inkonsequent, weil das Argument selbst nicht vom Typ Temperatur ist.

Beispiel Temperatur-Umrechnung: 1 conv :: Temperatur - > Einheit - > Temperatur 2 conv ( Temp t Celsius ) Celsius = 3 Temp t Celsius 4 conv ( Temp t Celsius ) Kelvin = 5 Temp ( t + 273. 15) Kelvin 6 conv ( Temp t Kelvin ) Fahrenheit = 7 Temp (t *9/5-459.67) Fahrenheit 8...

Algebraische Datentypen Allgemeine Form der Deklaration: data T a 1... a m = C 1 t 11... t 1n1... C r t r1... t rnr T Typkonstruktor C i a i t ij (Daten-)Konstruktoren Typvariablen Typen oder Typvariablen

Beispiel: Listen Wenn man Listen noch einführen müßte... 1 data List a = Cons a ( List a) 2 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

Beispiel: Listen Example [1..5] = [1,2,3,4,5] = 1:2:3:4:5:[] Cons : 1 Cons 1 : 2 Cons 2 : 3 Cons 3 : 4 Cons 4 : 5 Nil 5 []

Elementare Funktionen auf Listen Die meisten kennen wir bereits: head, tail length sum, product enumfromto append reverse take, drop map filter concat, concatmap siehe Tafel

Beispiel: Maybe 1 data Maybe a = Just a 2 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 > divide a b = 2 > if b == 0 then error " divide by zero " 3 > else div a b Mit Maybe: 1 > divide a b 2 > b == 0 = Nothing 3 > otherwise = Just ( div a b)

Beispiel: Maybe Typ von divide: 1 divide :: ( Num a) => a -> a -> Maybe a Pattern matching: 1 f a b = extract ( divide a b) +... 2 where 3 extract ( Just x) = x 4 extract Nothing = 0 Was ist der Typ von extract?

Typsynonyme (Nachtrag zum Haskell Typsystem) Neue Typnamen durch Typsynonyme: 1 type Pair a b = (a,b) 2 type Triple a b c = (a,b,c) 3 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. 1 newtype MyList a = [ a] führt ebenfalls einen NEUEN Typen analog zu [a] ein, der aber nicht als typgleich betrachtet wird. Verhindert gegenseitige Verwechslung von [a] und MyList a.

Derived instance declarations Optionale deriving Form: data T a 1... a m = C 1 t 11... t 1n1... C r t r1... t rnr deriving (k 1,..., k u ) k x 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... Example 1 data Maybe a = Nothing 2 Just a 3 deriving ( Eq, Ord, Read, Show ) Damit sind Operationen wie == oder < auf dem Typ Maybe implementiert.

Modellierung von cis des dis es fis gis ais ges as b cis des dis es fis gis ais ges as b c d e f g a h c d e f g a h Quelle: http://commons.wikimedia.org/wiki/file:klaviatur.svg, Public Domain

Modellierung von 1 > module where 2 > import Ratio 3 4 > i n f i x r 7 : : 5 > i n f i x r 6 :+: 6 7 > type GanzeZahl = I n t 8 > type Bruch = Ratio I n t 9 10 > type Ton = GanzeZahl 11 > type Dauer = Bruch 12 13 > data = 14 > Note Ton Dauer 15 > Pause Dauer 16 > : : h i n t e r e i n a n d e r 17 > :+: g l e i c h z e i t i g 18 > I n s t r I n s t r u m e n t 19 > Tempo GanzeZahl S c h l a e g e pro Minute 20 > d e r i v i n g Show

Modellierung von 22 > data Instrument = 23 > AcousticGrandPiano 24 > BrightAcousticPiano... 47 > TelephoneRing 48 > Helicopter 49 > Applause 50 > Gunshot 51 > deriving ( Show, Enum )

Modellierung von Sieben Ganztöne: c d e f g a h Halbtöne über den Tönen: cis dis eis (= f) fis gis ais his (=c) Halbtöne unter den Tönen: ces (=h) des es fes (=e) ges as b cis des dis es fis gis ais ges as b cis des dis es fis gis ais ges as b c d e f g a h c d e f g a h

Modellierung von 19 > module Helper where 20 21 > import 22 23 24 > ce, c i s, des, de, d i s, es, eh, e i s, f e s : : Ton 25 > ef, f i s, ges, ge, g i s, as, ah, a i s, be, ha, h i s : : Ton 26 27 > ce = 0 ; c i s = 1 ; des = 1 28 > de = 2 ; d i s = 3 ; e s = 3 29 > eh = 4 ; e i s = 5 ; f e s = 4 30 > e f = 5 ; f i s = 6 ; ges = 6 31 > ge = 7 ; g i s = 8 ; as = 8 32 > ah = 9 ; a i s = 10 ; be = 10 33 > ha = 11 ; h i s = 12

Formeln, die bedeuten 1 Note 0 ( 1/ 4) -- Viertelnote tiefes C 2 Note 24 (1/1) -- ganze Note c 3 Pause ( 1/ 16) -- Sechzehntelpause 4 5 Note 24 (1/4) :*: Note 26 (1/4) :*: Note 28 (1/4) 6 -- Anfang der C- Dur Tonleiter ( c 7 8 Note 24 ( 1/ 4) :+: Note 28 ( 1/ 4) :+: Note 31 ( 1/ 4) 9 -- C-Dur Akkord (c,e,g) 10 11 Tempo 70 m -- m als Adagio 12 Tempo 180 m -- m als Presto 13 Instr Oboe m -- m von Oboe gespielt 14 Instr VoiceAahs m -- m gesummt

Abkürzungen 35 > gp, hp, vp, ap, sp :: 36 37 > gp = Pause ( 1/ 1) 38 > hp = Pause ( 1/ 2) 39 > vp = Pause ( 1/ 4) 40 > ap = Pause ( 1/ 8) 41 > sp = Pause ( 1/ 16) 43 > adagio, andante, allegro, presto :: GanzeZahl 44 45 > adagio = 70 46 > andante = 90 47 > allegro = 140 48 > presto = 180

Abkürzungen 50 > c, d, e, f, g, a, h, c : : Dauer > 51 52 > c u = Note ( ce +24) u 53 > d u = Note ( de +24) u 54 > e u = Note ( eh +24) u 55 > f u = Note ( e f +24) u 56 > g u = Note ( ge +24) u 57 > a u = Note ( ah +24) u 58 > h u = Note ( ha +24) u 59 > c u = Note ( ce +36) u

Zusammengesetzte Klänge 61 > cdurtonika : : 62 63 > cdurtonika = c (1/1) :+: e (1/1) :+: g (1/1) 64 65 > cdurskala = Tempo a l l e g r o ( 66 > c (3/8) : : d (1/8) : : e (3/8) : : f (4/8) 67 > : : g (1/8) : : a (1/4) : : h (1/8) 68 > : : c ( 1 / 2 ) ) 70 > d u r D r e i k l a n g t = Note t (1/1) :+: Note ( t +4) (1/1) 71 > :+: Note ( t +7) (1/1) 72 73 > m o l l D r e i k l a n g t = Note t (1/1) :+: Note ( t +3) (1/1) 74 > :+: Note ( t +7) (1/1)

Transponierung 79 > t r a n s p o n i e r e : : Ton > > 80 81 > t r a n s p o n i e r e i ( Pause d ) = Pause d 82 > t r a n s p o n i e r e i ( Note t d ) = Note ( t+i ) d 83 > 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) 84 > : : ( t r a n s p o n i e r e i m2) 85 > 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) 86 > :+: ( t r a n s p o n i e r e i m2)

Verschiedenes 92 > wdh : : > 93 > wdh m = m : : m 94 95 > a d _ i n f i n i t u m : : > 96 > a d _ i n f i n i t u m m = m : : a d _ i n f i n i t u m m 97 98 > e i n s a t z d m = ( Pause d ) : : m

Bruder Jakob: Text Bruder Jakob, Bruder Jakob Schläfst du noch? Schläfst du noch? : Hörst du nicht die Glocken? : Ding dang dong, ding dang dong. Quelle: http://de.wikipedia.org/w/index.php?title=datei: FrereJacques1pt.png&filetimestamp=20070819210216, Public Domain