Grundlagen der Programmierung 2 A (Listen)
|
|
|
- Nora Meissner
- vor 6 Jahren
- Abrufe
Transkript
1 Grundlagen der Programmierung 2 A (Listen) Haskell: Listen Prof. Dr. Manfred Schmidt-Schauß Sommersemester 2017
2 Listen und Listenfunktionen Listen modellieren Folgen von gleichartigen, gleichgetypten Objekten. Ausdruck im Programm Erklärung Grundlagen der Programmierung 2 (Listen-B) 2/69
3 Listen und Listenfunktionen Listen modellieren Folgen von gleichartigen, gleichgetypten Objekten. Ausdruck im Programm Erklärung [0,1,2,3,4,5,6,7,8] Typ: [Integer]; d.h. Liste von Integer. Grundlagen der Programmierung 2 (Listen-B) 2/69
4 Listen und Listenfunktionen Listen modellieren Folgen von gleichartigen, gleichgetypten Objekten. Ausdruck im Programm Erklärung [0,1,2,3,4,5,6,7,8] Typ: [Integer]; d.h. Liste von Integer. [] leere Liste, (Nil) Grundlagen der Programmierung 2 (Listen-B) 2/69
5 Listen und Listenfunktionen Listen modellieren Folgen von gleichartigen, gleichgetypten Objekten. Ausdruck im Programm Erklärung [0,1,2,3,4,5,6,7,8] Typ: [Integer]; d.h. Liste von Integer. [] leere Liste, (Nil) [ a, b, c ] Typ: [Char]; Grundlagen der Programmierung 2 (Listen-B) 2/69
6 Listen und Listenfunktionen Listen modellieren Folgen von gleichartigen, gleichgetypten Objekten. Ausdruck im Programm Erklärung [0,1,2,3,4,5,6,7,8] Typ: [Integer]; d.h. Liste von Integer. [] leere Liste, (Nil) [ a, b, c ] Typ: [Char]; [[], [0], [1,2]] Liste von Listen; Typ [[Integer]], d.h. eine Liste von Listen von Integer-Objekten. Grundlagen der Programmierung 2 (Listen-B) 2/69
7 Listen und Listenfunktionen Listen modellieren Folgen von gleichartigen, gleichgetypten Objekten. Ausdruck im Programm Erklärung [0,1,2,3,4,5,6,7,8] Typ: [Integer]; d.h. Liste von Integer. [] leere Liste, (Nil) [ a, b, c ] Typ: [Char]; [[], [0], [1,2]] Liste von Listen; Typ [[Integer]], d.h. eine Liste von Listen von Integer-Objekten. [1..] potentiell unendliche Liste der Zahlen 1,2,3,... Grundlagen der Programmierung 2 (Listen-B) 2/69
8 Listen? Vorteile der Listen im Vergleich mit z.b Arrays: Haskell-Listen sind seiteneffektfrei; Programmierung mit Array ist imperativ; also mit Seiteneffekten. Potentiell unendliche Listen sind möglich Programmlogik mit Listen ist einfacher: Es gibt mehr korrekte Programmtransformationen Grundlagen der Programmierung 2 (Listen-B) 3/69
9 Listen? Vorteile der Listen im Vergleich mit z.b Arrays: Haskell-Listen sind seiteneffektfrei; Programmierung mit Array ist imperativ; also mit Seiteneffekten. Potentiell unendliche Listen sind möglich Programmlogik mit Listen ist einfacher: Es gibt mehr korrekte Programmtransformationen Weniger ist Mehr Grundlagen der Programmierung 2 (Listen-B) 3/69
10 Listen und Listenfunktionen zwei Schreibweisen für Listen: [0,1,2] (0 : (1 : (2 : []))) schöne Darstellung interne Darstellung mit Druckbild einer Liste zweistelligem Infix-Listen-Konstruktor : und dem Konstruktor [] Grundlagen der Programmierung 2 (Listen-B) 4/69
11 Listen und Listenfunktionen zwei Schreibweisen für Listen: [0,1,2] (0 : (1 : (2 : []))) schöne Darstellung interne Darstellung mit Druckbild einer Liste zweistelligem Infix-Listen-Konstruktor : und dem Konstruktor [] Eingebaute, listenerzeugende Funktionen: Ausdruck im Programm Erklärung [n..] erzeugt die Liste der Zahlen ab n. [n..m] erzeugt die Liste von n bis m [1..10] ergibt [1,2,3,4,5,6,7,8,9,10] [n,m..k] erzeugt die Liste von n bis k mit Schritten m n Grundlagen der Programmierung 2 (Listen-B) 4/69
12 Listen Listendarstellung Listenerzeugung Listen-Druckbild Grundlagen der Programmierung 2 (Listen-B) 5/69
13 Darstellung von Listen Listen sind aufgebaut mittels zwei Konstruktoren: [] Konstante für die leere Liste : Zweistelliger Infix-Konstruktor Grundlagen der Programmierung 2 (Listen-B) 6/69
14 Darstellung von Listen Listen sind aufgebaut mittels zwei Konstruktoren: [] Konstante für die leere Liste : Zweistelliger Infix-Konstruktor a : b Linkes Argument a: erstes Element der Liste Rechtes Argument b: Restliste Beispiel für Haskells Listenerzeugung: 8:[] Liste [8] mit dem Element 8 9:(8:[]) Liste [9,8] mit zwei Elementen 9,8 10:(9:(8:[])) Liste [10,9,8] mit drei Elementen Grundlagen der Programmierung 2 (Listen-B) 6/69
15 Baum-Bild einer Liste : 10 : 9 : entspricht [10, 9, 8] 8 [] Grundlagen der Programmierung 2 (Listen-B) 7/69
16 Pattern-Matching und Listendarstellung Pattern Liste : : x xs 10 : 9 : 8 [] Grundlagen der Programmierung 2 (Listen-B) 8/69
17 Pattern-Matching und Listendarstellung Pattern Liste : : x xs 10 : 9 : 8 [] Ergebnis des Pattern-Match: x 10, xs [9, 8] Grundlagen der Programmierung 2 (Listen-B) 8/69
18 Einfache Listenfunktionen Definitionen head (x:xs) = x -- extrahiert das erste Element tail (x:xs) = xs -- extrahiert die Restliste Auswertungen Prelude> head []????? Prelude> head [1]????? Prelude> tail []????? Prelude> tail [1]????? Grundlagen der Programmierung 2 (Listen-B) 9/69
19 Beispiel-Funktion: Länge einer Liste length :: [a] -> Int length [] = 0 length (x:xs) = 1 + (length xs) Auswertung bei bereits ausgewerteter Liste length (10:(9:(8:[]))) Grundlagen der Programmierung 2 (Listen-B) 10/69
20 Beispiel-Funktion: Länge einer Liste length :: [a] -> Int length [] = 0 length (x:xs) = 1 + (length xs) Auswertung bei bereits ausgewerteter Liste length (10:(9:(8:[]))) Grundlagen der Programmierung 2 (Listen-B) 10/69
21 Beispiel-Funktion: Länge einer Liste length :: [a] -> Int length [] = 0 length (x:xs) = 1 + (length xs) Auswertung bei bereits ausgewerteter Liste length (10:(9:(8:[]))) Zweiter Fall; [10/x, (9:(8:[]))/xs] 1+ (length (9:(8:[]))) Grundlagen der Programmierung 2 (Listen-B) 10/69
22 Beispiel-Funktion: Länge einer Liste length :: [a] -> Int length [] = 0 length (x:xs) = 1 + (length xs) Auswertung bei bereits ausgewerteter Liste length (10:(9:(8:[]))) Zweiter Fall; [10/x, (9:(8:[]))/xs] 1+ (length (9:(8:[]))) Grundlagen der Programmierung 2 (Listen-B) 10/69
23 Beispiel-Funktion: Länge einer Liste length :: [a] -> Int length [] = 0 length (x:xs) = 1 + (length xs) Auswertung bei bereits ausgewerteter Liste length (10:(9:(8:[]))) Zweiter Fall; [10/x, (9:(8:[]))/xs] 1+ (length (9:(8:[]))) Zweiter Fall; [9/x, (8:[])/xs] 1+(1+ (length (8:[]))) Grundlagen der Programmierung 2 (Listen-B) 10/69
24 Beispiel-Funktion: Länge einer Liste length :: [a] -> Int length [] = 0 length (x:xs) = 1 + (length xs) Auswertung bei bereits ausgewerteter Liste length (10:(9:(8:[]))) Zweiter Fall; [10/x, (9:(8:[]))/xs] 1+ (length (9:(8:[]))) Zweiter Fall; [9/x, (8:[])/xs] 1+(1+ (length (8:[]))) Grundlagen der Programmierung 2 (Listen-B) 10/69
25 Beispiel-Funktion: Länge einer Liste length :: [a] -> Int length [] = 0 length (x:xs) = 1 + (length xs) Auswertung bei bereits ausgewerteter Liste length (10:(9:(8:[]))) Zweiter Fall; [10/x, (9:(8:[]))/xs] 1+ (length (9:(8:[]))) Zweiter Fall; [9/x, (8:[])/xs] 1+(1+ (length (8:[]))) Zweiter Fall; [8/x, ([])/xs] 1+(1+ (1+ (length []))) Grundlagen der Programmierung 2 (Listen-B) 10/69
26 Beispiel-Funktion: Länge einer Liste length :: [a] -> Int length [] = 0 length (x:xs) = 1 + (length xs) Auswertung bei bereits ausgewerteter Liste length (10:(9:(8:[]))) Zweiter Fall; [10/x, (9:(8:[]))/xs] 1+ (length (9:(8:[]))) Zweiter Fall; [9/x, (8:[])/xs] 1+(1+ (length (8:[]))) Zweiter Fall; [8/x, ([])/xs] 1+(1+ (1+ (length []))) Grundlagen der Programmierung 2 (Listen-B) 10/69
27 Beispiel-Funktion: Länge einer Liste length :: [a] -> Int length [] = 0 length (x:xs) = 1 + (length xs) Auswertung bei bereits ausgewerteter Liste length (10:(9:(8:[]))) Zweiter Fall; [10/x, (9:(8:[]))/xs] 1+ (length (9:(8:[]))) Zweiter Fall; [9/x, (8:[])/xs] 1+(1+ (length (8:[]))) Zweiter Fall; [8/x, ([])/xs] 1+(1+ (1+ (length []))) Erster Fall 1+(1+ (1+ (0))) Grundlagen der Programmierung 2 (Listen-B) 10/69
28 Beispiel-Funktion: Länge einer Liste length :: [a] -> Int length [] = 0 length (x:xs) = 1 + (length xs) Auswertung bei bereits ausgewerteter Liste length (10:(9:(8:[]))) Zweiter Fall; [10/x, (9:(8:[]))/xs] 1+ (length (9:(8:[]))) Zweiter Fall; [9/x, (8:[])/xs] 1+(1+ (length (8:[]))) Zweiter Fall; [8/x, ([])/xs] 1+(1+ (1+ (length []))) Erster Fall 1+(1+ (1+ (0))) 3 Additionen Grundlagen der Programmierung 2 (Listen-B) 10/69
29 Beispiel-Funktion: Länge einer Liste length :: [a] -> Int length [] = 0 length (x:xs) = 1 + (length xs) Auswertung bei bereits ausgewerteter Liste length (10:(9:(8:[]))) Zweiter Fall; [10/x, (9:(8:[]))/xs] 1+ (length (9:(8:[]))) Zweiter Fall; [9/x, (8:[])/xs] 1+(1+ (length (8:[]))) Zweiter Fall; [8/x, ([])/xs] 1+(1+ (1+ (length []))) Erster Fall 1+(1+ (1+ (0))) 3 Additionen 3 Grundlagen der Programmierung 2 (Listen-B) 10/69
30 Funktionen auf Listen: map map :: (a -> b) -> [a] -> [b] map f [] = [] map f (x:xs) = (f x) : (map f xs) map wendet eine Funktion f auf alle Elemente einer Liste an und konstruiert die Liste der Ergebnisse. [] und (x:xs) links von = sind Muster(Pattern) Z.B. Muster (x:xs) und Argument (s:t) Grundlagen der Programmierung 2 (Listen-B) 11/69
31 Funktionen auf Listen: map map :: (a -> b) -> [a] -> [b] map f [] = [] map f (x:xs) = (f x) : (map f xs) map wendet eine Funktion f auf alle Elemente einer Liste an und konstruiert die Liste der Ergebnisse. [] und (x:xs) links von = sind Muster(Pattern) Z.B. Muster (x:xs) und Argument (s:t) ergibt die Ersetzung: [s/x, t/xs] Grundlagen der Programmierung 2 (Listen-B) 11/69
32 Funktionen auf Listen: Beispiele map f [] = [] map f (x:xs) = (f x) : (map f xs) Auswertung von map quadrat (1:(2:[])): Bei vollständiger Auswertung der Ergebnisliste durch den Interpreter: map quadrat (1:(2:[])) Grundlagen der Programmierung 2 (Listen-B) 12/69
33 Funktionen auf Listen: Beispiele map f [] = [] map f (x:xs) = (f x) : (map f xs) Auswertung von map quadrat (1:(2:[])): Bei vollständiger Auswertung der Ergebnisliste durch den Interpreter: map quadrat (1:(2:[])) (quadrat 1) : (map quadrat(2:[])) [quadrat/f, 1/x, (2:[])/xs] Grundlagen der Programmierung 2 (Listen-B) 12/69
34 Funktionen auf Listen: Beispiele map f [] = [] map f (x:xs) = (f x) : (map f xs) Auswertung von map quadrat (1:(2:[])): Bei vollständiger Auswertung der Ergebnisliste durch den Interpreter: map quadrat (1:(2:[])) (quadrat 1) : (map quadrat(2:[])) [quadrat/f, 1/x, (2:[])/xs] Grundlagen der Programmierung 2 (Listen-B) 12/69
35 Funktionen auf Listen: Beispiele map f [] = [] map f (x:xs) = (f x) : (map f xs) Auswertung von map quadrat (1:(2:[])): Bei vollständiger Auswertung der Ergebnisliste durch den Interpreter: map quadrat (1:(2:[])) (quadrat 1) : (map quadrat(2:[])) 1*1 : map quadrat (2:[]) [quadrat/f, 1/x, (2:[])/xs] bei vollst. Auswertung: Grundlagen der Programmierung 2 (Listen-B) 12/69
36 Funktionen auf Listen: Beispiele map f [] = [] map f (x:xs) = (f x) : (map f xs) Auswertung von map quadrat (1:(2:[])): Bei vollständiger Auswertung der Ergebnisliste durch den Interpreter: map quadrat (1:(2:[])) (quadrat 1) : (map quadrat(2:[])) 1*1 : map quadrat (2:[]) [quadrat/f, 1/x, (2:[])/xs] bei vollst. Auswertung: Grundlagen der Programmierung 2 (Listen-B) 12/69
37 Funktionen auf Listen: Beispiele map f [] = [] map f (x:xs) = (f x) : (map f xs) Auswertung von map quadrat (1:(2:[])): Bei vollständiger Auswertung der Ergebnisliste durch den Interpreter: map quadrat (1:(2:[])) (quadrat 1) : (map quadrat(2:[])) 1*1 : map quadrat (2:[]) 1 : map quadrat (2:[]) [quadrat/f, 1/x, (2:[])/xs] bei vollst. Auswertung: Grundlagen der Programmierung 2 (Listen-B) 12/69
38 Funktionen auf Listen: Beispiele map f [] = [] map f (x:xs) = (f x) : (map f xs) Auswertung von map quadrat (1:(2:[])): Bei vollständiger Auswertung der Ergebnisliste durch den Interpreter: map quadrat (1:(2:[])) (quadrat 1) : (map quadrat(2:[])) 1*1 : map quadrat (2:[]) 1 : map quadrat (2:[]) [quadrat/f, 1/x, (2:[])/xs] bei vollst. Auswertung: Grundlagen der Programmierung 2 (Listen-B) 12/69
39 Funktionen auf Listen: Beispiele map f [] = [] map f (x:xs) = (f x) : (map f xs) Auswertung von map quadrat (1:(2:[])): Bei vollständiger Auswertung der Ergebnisliste durch den Interpreter: map quadrat (1:(2:[])) [quadrat/f, 1/x, (2:[])/xs] (quadrat 1) : (map quadrat(2:[])) bei vollst. Auswertung: 1*1 : map quadrat (2:[]) 1 : map quadrat (2:[]) Zweite Gleichung 1 : (quadrat 2 : map quadrat []) Grundlagen der Programmierung 2 (Listen-B) 12/69
40 Funktionen auf Listen: Beispiele map f [] = [] map f (x:xs) = (f x) : (map f xs) Auswertung von map quadrat (1:(2:[])): Bei vollständiger Auswertung der Ergebnisliste durch den Interpreter: map quadrat (1:(2:[])) [quadrat/f, 1/x, (2:[])/xs] (quadrat 1) : (map quadrat(2:[])) bei vollst. Auswertung: 1*1 : map quadrat (2:[]) 1 : map quadrat (2:[]) Zweite Gleichung 1 : (quadrat 2 : map quadrat []) Grundlagen der Programmierung 2 (Listen-B) 12/69
41 Funktionen auf Listen: Beispiele map f [] = [] map f (x:xs) = (f x) : (map f xs) Auswertung von map quadrat (1:(2:[])): Bei vollständiger Auswertung der Ergebnisliste durch den Interpreter: map quadrat (1:(2:[])) [quadrat/f, 1/x, (2:[])/xs] (quadrat 1) : (map quadrat(2:[])) bei vollst. Auswertung: 1*1 : map quadrat (2:[]) 1 : map quadrat (2:[]) Zweite Gleichung 1 : (quadrat 2 : map quadrat []) 1 : (2*2 : map quadrat []) Grundlagen der Programmierung 2 (Listen-B) 12/69
42 Funktionen auf Listen: Beispiele map f [] = [] map f (x:xs) = (f x) : (map f xs) Auswertung von map quadrat (1:(2:[])): Bei vollständiger Auswertung der Ergebnisliste durch den Interpreter: map quadrat (1:(2:[])) [quadrat/f, 1/x, (2:[])/xs] (quadrat 1) : (map quadrat(2:[])) bei vollst. Auswertung: 1*1 : map quadrat (2:[]) 1 : map quadrat (2:[]) Zweite Gleichung 1 : (quadrat 2 : map quadrat []) 1 : (2*2 : map quadrat []) Grundlagen der Programmierung 2 (Listen-B) 12/69
43 Funktionen auf Listen: Beispiele map f [] = [] map f (x:xs) = (f x) : (map f xs) Auswertung von map quadrat (1:(2:[])): Bei vollständiger Auswertung der Ergebnisliste durch den Interpreter: map quadrat (1:(2:[])) [quadrat/f, 1/x, (2:[])/xs] (quadrat 1) : (map quadrat(2:[])) bei vollst. Auswertung: 1*1 : map quadrat (2:[]) 1 : map quadrat (2:[]) Zweite Gleichung 1 : (quadrat 2 : map quadrat []) 1 : (2*2 : map quadrat []) 1 : (4 : map quadrat []) Grundlagen der Programmierung 2 (Listen-B) 12/69
44 Funktionen auf Listen: Beispiele map f [] = [] map f (x:xs) = (f x) : (map f xs) Auswertung von map quadrat (1:(2:[])): Bei vollständiger Auswertung der Ergebnisliste durch den Interpreter: map quadrat (1:(2:[])) [quadrat/f, 1/x, (2:[])/xs] (quadrat 1) : (map quadrat(2:[])) bei vollst. Auswertung: 1*1 : map quadrat (2:[]) 1 : map quadrat (2:[]) Zweite Gleichung 1 : (quadrat 2 : map quadrat []) 1 : (2*2 : map quadrat []) 1 : (4 : map quadrat []) Erste Gleichung 1 : (4 : []) = [1,4] Grundlagen der Programmierung 2 (Listen-B) 12/69
45 Auswertung: Wieviel ist nötig? istleer [] = True istleer (x:xs) = False zahlenab n = n: zahlenab (n+1) Auswertung (mit Listenerzeuger als Argument) Grundlagen der Programmierung 2 (Listen-B) 13/69
46 Auswertung: Wieviel ist nötig? istleer [] = True istleer (x:xs) = False zahlenab n = n: zahlenab (n+1) Auswertung (mit Listenerzeuger als Argument) istleer [1..] Grundlagen der Programmierung 2 (Listen-B) 13/69
47 Auswertung: Wieviel ist nötig? istleer [] = True istleer (x:xs) = False zahlenab n = n: zahlenab (n+1) Auswertung (mit Listenerzeuger als Argument) istleer [1..] verwende zahlenab Grundlagen der Programmierung 2 (Listen-B) 13/69
48 Auswertung: Wieviel ist nötig? istleer [] = True istleer (x:xs) = False zahlenab n = n: zahlenab (n+1) Auswertung (mit Listenerzeuger als Argument) istleer [1..] verwende zahlenab istleer (zahlenab 1) Grundlagen der Programmierung 2 (Listen-B) 13/69
49 Auswertung: Wieviel ist nötig? istleer [] = True istleer (x:xs) = False zahlenab n = n: zahlenab (n+1) Auswertung (mit Listenerzeuger als Argument) istleer [1..] verwende zahlenab istleer (zahlenab 1) istleer (1: zahlenab (1+1)) Grundlagen der Programmierung 2 (Listen-B) 13/69
50 Auswertung: Wieviel ist nötig? istleer [] = True istleer (x:xs) = False zahlenab n = n: zahlenab (n+1) Auswertung (mit Listenerzeuger als Argument) istleer [1..] verwende zahlenab istleer (zahlenab 1) istleer (1: zahlenab (1+1)) Zweite Gleichung von istleer Grundlagen der Programmierung 2 (Listen-B) 13/69
51 Auswertung: Wieviel ist nötig? istleer [] = True istleer (x:xs) = False zahlenab n = n: zahlenab (n+1) Auswertung (mit Listenerzeuger als Argument) istleer [1..] verwende zahlenab istleer (zahlenab 1) istleer (1: zahlenab (1+1)) Zweite Gleichung von istleer False Grundlagen der Programmierung 2 (Listen-B) 13/69
52 Listenfunktionen und Listenerzeuger *Main> map quadrat [1..10] [1,4,9,16,25,36,49,64,81,100] *Main> map quadrat [1..] [1,4,9,16,25,36,49,64,81,100,121,... Der Listenerzeuger [1..] erzeugt soviel von der potentiell unendlichen Liste [1,2,3,4,5,... wie für das Ergebnis benötigt wird. Grundlagen der Programmierung 2 (Listen-B) 14/69
53 Typen von Listenausdrücken mapquadrat xs = map quadrat xs *Main> :t mapquadrat mapquadrat :: forall a. (Num a) => [a] -> [a] maplength xs = map length xs *Main> :t maplength maplength :: forall a. [[a]] -> [Int] Grundlagen der Programmierung 2 (Listen-B) 15/69
54 Listenfunktion append Die folgende Funktion hängt zwei Listen zusammen (genauer: sie konstruiert die Resultat-Liste) append :: [a] -> [a] -> [a] append [] ys = ys append (x:xs) ys = x : (append xs ys) Haskell-Operator für append: ++ (Infix-Operator) Haskell-Schreibweise: [1,2,3] ++ [4,5,6,7] ergibt [1,2,3,4,5,6,7] Grundlagen der Programmierung 2 (Listen-B) 16/69
55 Beispiele *Main> [] ++ [3,4,5] [3,4,5] *Main> [0,1,2] ++ [] [0,1,2] *Main> [0,1,2] ++ [3,4,5] [0,1,2,3,4,5] *Main> [ ] ++ [ ] == [ ] True Grundlagen der Programmierung 2 (Listen-B) 17/69
56 Funktionen auf Listen (2) Filtern von Elementen aus einer Liste: filter :: (a -> Bool) -> [a] -> [a] filter f [] = [] filter f (x:xs) = if (f x) then x : filter f xs else filter f xs Beispiele: *Main> filter (< 5) [1..10] [1,2,3,4] *Main> filter primzahlq [2..] [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61, 67,71,73,79,83,89,97,101,103,107,109,113,127,131,137, 139,149,151,157,163,167,173,179,181,191,193,197,199,211, Grundlagen der Programmierung 2 (Listen-B) 18/69
57 Funktionen auf Listen Die ersten n Elemente der Liste xs: take :: Int -> [a] -> [a] take 0 _ = [] take n [] = [] take n (x:xs) = x : (take (n-1) xs) *Main> take 10 [20..40] [20,21,22,23,24,25,26,27,28,29] *Main> take 10 [20,23..] [20,23,26,29,32,35,38,41,44,47] Grundlagen der Programmierung 2 (Listen-B) 19/69
58 Auswertungsreihenfolge, Definitionseinsetzung Auswertung von f s 1... s n wenn f mittels Pattern (Muster) definiert ist, innerhalb einer Fallunterscheidung: Erster Schritt: die Argumente soweit auswerten, bis die Fallunterscheidung möglich ist. (von links nach rechts) Zweiter Schritt: Definitionseinsetzung Grundlagen der Programmierung 2 (Listen-B) 20/69
59 Geschachtelte Pattern elimdub eliminiert doppelte benachbarte Vorkommen von Elementen aus Listen: elimdub [] = [] elimdub [x] = [x] elimdub (x:(y:r)) = if x == y then elimdub (y:r) else x : elimdub (y:r) Beachte das Pattern (x:(y:r)) nub im Modul Data.List eliminiert alle Doppelten: elimdub [1,2,3,3,2,1] [1,2,3,2,1] nub [1,2,3,3,2,1] [1,2,3] Grundlagen der Programmierung 2 (Listen-B) 21/69
60 Paare und Tupel (Einschub) Beispiel: Tupel: mehrere Ausdrücke werden zusammengefasst. (1, 2, [ a, b ]) oder (1 + 2, 3 4) Es gibt Tupel mit 2,3,.. Komponenten. Grundlagen der Programmierung 2 (Listen-B) 22/69
61 Paare und Tupel (Einschub) Beispiel: Tupel: mehrere Ausdrücke werden zusammengefasst. (1, 2, [ a, b ]) oder (1 + 2, 3 4) Es gibt Tupel mit 2,3,.. Komponenten. Verwendung in Funktionen: drittekomponente (x,y,z) = z addierepaar (x1,x2) (y1,y2) = (x1+y1,x2+y2) Grundlagen der Programmierung 2 (Listen-B) 22/69
62 Paare und Tupel (Einschub) Beispiel: Tupel: mehrere Ausdrücke werden zusammengefasst. (1, 2, [ a, b ]) oder (1 + 2, 3 4) Es gibt Tupel mit 2,3,.. Komponenten. Verwendung in Funktionen: drittekomponente (x,y,z) = z addierepaar (x1,x2) (y1,y2) = (x1+y1,x2+y2) Typen: drittekomponente:: (a, b, c) c addierepaar :: Num a, Num b = (a, b) (a, b) (a, b) Grundlagen der Programmierung 2 (Listen-B) 22/69
63 Listen: Auswertung Listen (bzw. Listenargumente) nennt man: einfach ausgewertet: wenn Listen-Fallunterscheidung möglich ist, d.h. [] oder von der Form s : t vollständig ausgewertet: wenn Liste endlich ist und der Tail, Tail-von Tail,... alle usgewertet sind und alle Elemente ebenfalls vollständig ausgewertet sind, Grundlagen der Programmierung 2 (Listen-B) 23/69
64 Iterative Prozesse mit Listenargumenten Bei Verwendung von Listenargumenten: Die folgenden Begriffe sind unverändert: linear rekursiv, end-rekursiv (= tail-recursive) Baum-rekursiv geschachtelt Baum-rekursiv (Bei applikativer Reihenfolge der Auswertung) iterativ muss genauer erklärt werden. Grundlagen der Programmierung 2 (Listen-B) 24/69
65 Iterativer Auswertungsprozess zu f Ein iterativer Auswertungsprozess liegt, bei einer rekursiven Funktion f, vor wenn: (f a 1... a n ) (f a 1... a n) (f a (2) 1... a (2) n ) (f a (3) 1... a (3) n ) (f a (m) 1... a (m) n )... und alle a (j) i sind Basiswerte oder komplett ausgewertete, endliche Listen (bei applikativer Reihenfolge der Auswertung.) Grundlagen der Programmierung 2 (Listen-B) 25/69
66 iterative Version f iter von f f iter ist iterative Version von f Wenn: f und f iter das gleiche berechnen und f iter einen iterativen Prozess erzeugt (unter applikativer R.) für alle Basiswerte und alle komplett ausgewerteten endlichen Listen als Eingaben Grundlagen der Programmierung 2 (Listen-B) 26/69
67 Beispiel: iterative Version von length: length_lin xs = length_linr 0 xs length_linr s [] = s length_linr s (x:xs) = length_linr (s+1) xs nicht-iterative Version: (auch nicht endrekursiv) length [] = 0 length (x:xs) = 1 + length xs Grundlagen der Programmierung 2 (Listen-B) 27/69
68 Linearer (Nicht-iterativer) Prozess zu length length (9:(8:(7:(6:...(1:[]))))) Grundlagen der Programmierung 2 (Listen-B) 28/69
69 Linearer (Nicht-iterativer) Prozess zu length length (9:(8:(7:(6:...(1:[]))))) 1+(length (8:(7:(6:...(1:[])))) Grundlagen der Programmierung 2 (Listen-B) 28/69
70 Linearer (Nicht-iterativer) Prozess zu length length (9:(8:(7:(6:...(1:[]))))) 1+(length (8:(7:(6:...(1:[])))) 1+(1+(length (7:(6:...(1:[]))) Grundlagen der Programmierung 2 (Listen-B) 28/69
71 Linearer (Nicht-iterativer) Prozess zu length length (9:(8:(7:(6:...(1:[]))))) 1+(length (8:(7:(6:...(1:[])))) 1+(1+(length (7:(6:...(1:[]))) 1+(1+(1+(length (6:...(1:[])) Grundlagen der Programmierung 2 (Listen-B) 28/69
72 Linearer (Nicht-iterativer) Prozess zu length length (9:(8:(7:(6:...(1:[]))))) 1+(length (8:(7:(6:...(1:[])))) 1+(1+(length (7:(6:...(1:[]))) 1+(1+(1+(length (6:...(1:[]))... Grundlagen der Programmierung 2 (Listen-B) 28/69
73 Linearer (Nicht-iterativer) Prozess zu length length (9:(8:(7:(6:...(1:[]))))) 1+(length (8:(7:(6:...(1:[])))) 1+(1+(length (7:(6:...(1:[]))) 1+(1+(1+(length (6:...(1:[]))... (1+(1+(1+(1+(1+(1+(1+(1+(1+0)))))))))) Grundlagen der Programmierung 2 (Listen-B) 28/69
74 Linearer (Nicht-iterativer) Prozess zu length length (9:(8:(7:(6:...(1:[]))))) 1+(length (8:(7:(6:...(1:[])))) 1+(1+(length (7:(6:...(1:[]))) 1+(1+(1+(length (6:...(1:[]))... (1+(1+(1+(1+(1+(1+(1+(1+(1+0))))))))))... Grundlagen der Programmierung 2 (Listen-B) 28/69
75 Linearer (Nicht-iterativer) Prozess zu length length (9:(8:(7:(6:...(1:[]))))) 1+(length (8:(7:(6:...(1:[])))) 1+(1+(length (7:(6:...(1:[]))) 1+(1+(1+(length (6:...(1:[]))... (1+(1+(1+(1+(1+(1+(1+(1+(1+0))))))))))... 9 Grundlagen der Programmierung 2 (Listen-B) 28/69
76 Beispiel: iterativer Prozess Beachte: wir benutzen hier die applikative Reihenfolge der Auswertung Grundlagen der Programmierung 2 (Listen-B) 29/69
77 Beispiel: iterativer Prozess Beachte: wir benutzen hier die applikative Reihenfolge der Auswertung length lin (9:(8:(7:(6:...(1:[]))))) Grundlagen der Programmierung 2 (Listen-B) 29/69
78 Beispiel: iterativer Prozess Beachte: wir benutzen hier die applikative Reihenfolge der Auswertung length lin (9:(8:(7:(6:...(1:[]))))) length linr 0 (9:(8:(7:(6:...(1:[]))))) Grundlagen der Programmierung 2 (Listen-B) 29/69
79 Beispiel: iterativer Prozess Beachte: wir benutzen hier die applikative Reihenfolge der Auswertung length lin (9:(8:(7:(6:...(1:[]))))) length linr 0 (9:(8:(7:(6:...(1:[]))))) length linr 1 (8:(7:(6:...(1:[])))) Grundlagen der Programmierung 2 (Listen-B) 29/69
80 Beispiel: iterativer Prozess Beachte: wir benutzen hier die applikative Reihenfolge der Auswertung length lin (9:(8:(7:(6:...(1:[]))))) length linr 0 (9:(8:(7:(6:...(1:[]))))) length linr 1 (8:(7:(6:...(1:[])))) length linr 2 (7:(6:...(1:[]))) Grundlagen der Programmierung 2 (Listen-B) 29/69
81 Beispiel: iterativer Prozess Beachte: wir benutzen hier die applikative Reihenfolge der Auswertung length lin (9:(8:(7:(6:...(1:[]))))) length linr 0 (9:(8:(7:(6:...(1:[]))))) length linr 1 (8:(7:(6:...(1:[])))) length linr 2 (7:(6:...(1:[]))) length linr 3 (6:...(1:[])) Grundlagen der Programmierung 2 (Listen-B) 29/69
82 Beispiel: iterativer Prozess Beachte: wir benutzen hier die applikative Reihenfolge der Auswertung length lin (9:(8:(7:(6:...(1:[]))))) length linr 0 (9:(8:(7:(6:...(1:[]))))) length linr 1 (8:(7:(6:...(1:[])))) length linr 2 (7:(6:...(1:[]))) length linr 3 (6:...(1:[]))... Grundlagen der Programmierung 2 (Listen-B) 29/69
83 Beispiel: iterativer Prozess Beachte: wir benutzen hier die applikative Reihenfolge der Auswertung length lin (9:(8:(7:(6:...(1:[]))))) length linr 0 (9:(8:(7:(6:...(1:[]))))) length linr 1 (8:(7:(6:...(1:[])))) length linr 2 (7:(6:...(1:[]))) length linr 3 (6:...(1:[]))... length linr 9 [] Grundlagen der Programmierung 2 (Listen-B) 29/69
84 Beispiel: iterativer Prozess Beachte: wir benutzen hier die applikative Reihenfolge der Auswertung length lin (9:(8:(7:(6:...(1:[]))))) length linr 0 (9:(8:(7:(6:...(1:[]))))) length linr 1 (8:(7:(6:...(1:[])))) length linr 2 (7:(6:...(1:[]))) length linr 3 (6:...(1:[]))... length linr 9 [] 9 Grundlagen der Programmierung 2 (Listen-B) 29/69
85 Allgemeine Funktionen auf Listen Allgemeine Funktionen (Methoden): foldl und foldr Links-Faltung und Rechts-Faltung Die 3 Argumente sind: eine zweistellige Operation, ein Anfangselement (Einheitselement) und die Liste. foldl e [a 1,..., a n ] entspricht ((... ((e a 1 ) a 2 )... ) a n ). foldr e [a 1,..., a n ] entspricht a 1 (a 2 (... (a n e))) Grundlagen der Programmierung 2 (Listen-B) 30/69
86 Definitionen der fold-funktionen foldl (Linksfaltung) foldr (Rechtsfaltung) foldl foldl f z [] foldl f z (x:xs) :: (a -> b -> a) -> a -> [b] -> a = z = foldl f (f z x) xs foldr foldr f z [] foldr f z (x:xs) :: (a -> b -> b) -> b -> [a] -> b = z = f x (foldr f z xs) Grundlagen der Programmierung 2 (Listen-B) 31/69
87 Fold-Verwendungen Summe bzw. Produkt einer Liste von Zahlen: sum xs = foldl (+) 0 xs produkt xs = foldl (*) 1 xs concat xs = foldr (++) [] xs foldl (+) 0 [1,2,3,4] ((((0+1)+2)+3)+4) foldr (++) [] [[0],[2,3],[5]] [0] ++ ([2,3] ++ ([5] ++ [])) Je nach Operator ergibt foldl, oder foldr eine schnellere Verarbeitung. Grundlagen der Programmierung 2 (Listen-B) 32/69
88 Lambda-Ausdrücke Lokale Funktionsdefinitionen, anonyme Funktionen Lambda-Ausdruck \x 1... x n -> Ausdruck x 1, x 2,... sind die formalen Parameter Beispiel quadrat = \x -> x*x Der Lambdaausdruck kann wie eine Funktion verwendet werden Grundlagen der Programmierung 2 (Listen-B) 33/69
89 let und lokale Bindungen let {x 1 = s 1 ;... ; x n = s n } in t {x 1 = s 1 ;... ; x n = s n } ist eine lokale Umgebung die Variablen x i können in t vorkommen mit der Bedeutung: Wert von s i t der eigentliche Ausdruck let x1 = 5 x2 = "abc" x3 = 7*x1 in (x1,x2,x3) Grundlagen der Programmierung 2 (Listen-B) 34/69
90 let und lokale Bindungen In Haskell: rekursives let. D.h. x i kann in jedem s j vorkommen in {x 1 = s 1 ;... ; x n = s n } Beachte im ghci-interpreter: Spezielle Verwendung des let Grundlagen der Programmierung 2 (Listen-B) 35/69
91 Erweiterungen des let Funktionen sind definierbar direkt in einem rekursiven let: Zum Beispiel: let {f x 1... x n = s;...} in t let {hochdrei x = x*x*x; a = 3} in hochdrei a Grundlagen der Programmierung 2 (Listen-B) 36/69
92 Freie und Gebundene Variablen Neue Sichtweise: Jetzt betrachten wir Programme als statischen, strukturierten Text Grundlagen der Programmierung 2 (Listen-B) 37/69
93 Freie und Gebundene Variablen Statische Analysen: Untersuche den Programmtext bzw. den Syntaxbaum. Um Definitionen von lokalen Variablen (Namen) korrekt zu handhaben, braucht man neue Begriffe: Gültigkeitsbereich einer Variablen x freie Variablen eines Ausdrucks gebundene Variablen eines Ausdrucks Text-Fragment(e) des Programms in dem dieses x gemeint ist. Variablen, deren Bedeutung außerhalb des Ausdrucks festgelegt wird. Variablen, deren Bedeutung innerhalb des Ausdrucks festgelegt wird. Grundlagen der Programmierung 2 (Listen-B) 38/69
94 Freie und Gebundene Variablen (2) Problem: Variablen können mit gleichem Namen, aber verschiedener Bedeutung (bzw. Verwendung / Intention) in einem Ausdruck vorkommen: Grundlagen der Programmierung 2 (Listen-B) 39/69
95 Freie und Gebundene Variablen (2) Problem: Variablen können mit gleichem Namen, aber verschiedener Bedeutung (bzw. Verwendung / Intention) in einem Ausdruck vorkommen: Lösung: Exakte Festlegung der Gültigkeitsbereiche für jedes syntaktische Konstrukt Umbenennen von gebundenen Variablennamen, falls nötig Grundlagen der Programmierung 2 (Listen-B) 39/69
96 Beispiel \x-> x*x Gültigkeitsbereich von x: der Ausdruck x*x die Variable x ist gebunden von \x Grundlagen der Programmierung 2 (Listen-B) 40/69
97 Beispiel \x-> x*x x*x Gültigkeitsbereich von x: der Ausdruck x*x die Variable x ist gebunden von \x in diesem Ausdruck ist x frei Grundlagen der Programmierung 2 (Listen-B) 40/69
98 Beispiel \x-> x*x x*x (let x = 1; y = 2 in x*y*z) Gültigkeitsbereich von x: der Ausdruck x*x die Variable x ist gebunden von \x in diesem Ausdruck ist x frei x und y sind gebunden, z ist frei Grundlagen der Programmierung 2 (Listen-B) 40/69
99 Definition von FV FV: ergibt Menge von Variablen-Namen. F V (x) := {x}, wenn x ein Variablenname ist F V ((s t)) := F V (s) F V (t) F V (if t 1 then t 2 else t 3 ) := F V (t 1 ) F V (t 2 ) F V (t 3 ) F V (\x 1... x n -> t) := F V (t) \ {x 1,..., x n } F V (let x 1 = s 1,..., x n = s n in t) := (F V (t) F V (s 1 )... F V (s n )) \ {x 1,..., x n } F V (let f x 1... x n = s in t) := F V (let f = \x 1... x n -> s in t) Beachte: FV ist eine Funktion auf dem Syntaxbaum; Grundlagen der Programmierung 2 (Listen-B) 41/69
100 Beispiel: freie Variablen F V (\x -> (f x y)) = F V (f x y) \ {x} =... = {x, f, y} \ {x} = {f, y} Grundlagen der Programmierung 2 (Listen-B) 42/69
101 Gebundene Variablen GV (t) Entsprechend der F V -Definition: GV (x) := GV ((s t)) := GV (s) GV (t) GV (if t 1 then t 2 else t 3 ) := GV (t 1 ) GV (t 2 ) GV (t 3 ) GV (\x 1... x n -> t) := GV (t) {x 1,..., x n } GV (let x 1 = s 1,..., x n = s n in t) := (GV (t) GV (s 1 )... GV (s n ) {x 1,..., x n }}) GV (let f x 1... x n = s in t) := GV (let f = \x 1... x n -> s in t) = {f, x 1,..., x n } GV (s) GV (t) Auch hier GV ist eine Funktion auf dem Syntaxbaum; Grundlagen der Programmierung 2 (Listen-B) 43/69
102 Beispiel : Berechnung von gebundenen Variablen GV(\x -> (f x y)) = GV (f x y) {x} =... = {x} = {x} Grundlagen der Programmierung 2 (Listen-B) 44/69
103 Lexikalischer Gültigkeitsbereich einer Variablen let x = s in t die Vorkommen der freien Variablen x in s, t werden gebunden. s, t ist der lexikalische Gültigkeitsbereich der Variablen x f x y z = t die freien Variablen x, y, z in t werden gebunden. t ist der lexikalische Gültigkeitsbereich von x, y, z; auch tlw. von f. \x y z -> t t ist der lexikalische Gültigkeitsbereich von x, y, z. Grundlagen der Programmierung 2 (Listen-B) 45/69
104 Beispiel Ausdruck t = \x -> (x (\x -> x*x)) x ist in t gebunden, aber in zwei Bindungsbereichen: \x -> (x (\x -> x*x)) In (x (\x -> x*x)) kommt x frei und gebunden vor. Umbenennen des gebundenen x in y ergibt: (x (\y -> y*y)) Grundlagen der Programmierung 2 (Listen-B) 46/69
105 Beispiele Zwei Bindungsbereiche für x in einem let-ausdruck: let x = 10 in (let x = 100 in (x+x)) + x Umbenennung ergibt: let x1 = 10 in (let x2 = 100 in (x2+x2)) + x1 Dieser Term wertet zu 210 aus. Beispiel: let x = (x*x) in (x+x) führt zu Nichtterminierung des Haskell-Interpreters ohne Reduktionen auszuführen. Grundlagen der Programmierung 2 (Listen-B) 47/69
106 Beispiel: Reihenfolgenunabhängigkeit let y = 20*z x = 10+y z = 15 in x Wertet aus zu : 310. Grundlagen der Programmierung 2 (Listen-B) 48/69
107 Beispiel geschachtelte Bindungsbereiche let {x = 1;y = 7} in (let {y = 2; z = 4} in (let z = 5 in (x+y+z))) x = 1;y = 7 y = 2; z = 4 z = 5 x+y+z Grundlagen der Programmierung 2 (Listen-B) 49/69
108 Optimierung mittels let Vermeidung redundanter Auswertungen mit let f(x,y) := x(1 + xy) 2 + y(1-y) + (1+xy)(1-y) optimierbar durch Vermeidung von Doppelauswertungen: Der zugehörige Ausdruck ist: let a b in = 1 + x*y = 1 - y x*a*a + y*b + a*b Grundlagen der Programmierung 2 (Listen-B) 50/69
109 Daten-Objekte Zusammengesetzte Daten Datenobjekte Tupel Verallgemeinerungen von Listen Grundlagen der Programmierung 2 (Listen-B) 51/69
110 Zusammengesetzte Objekte: Datentypen Für Datentypen benötigt man: Datenkonstruktor(en) Datenselektor(en) Beispiel Paarkonstruktor s, t (s, t) Paarselektoren fst, snd Eigenschaften: fst(s, t) = s snd(s, t) = t. und Grundlagen der Programmierung 2 (Listen-B) 52/69
111 Beispiel n-tupel n-tupelkonstruktor t 1,..., t n (t 1,..., t n ) Tupelselektoren n Selektoren: pro Stelle des Konstruktors ein Selektor n-tupel haben einen impliziten Konstruktor: (.,...,.) }{{} n Grundlagen der Programmierung 2 (Listen-B) 53/69
112 Definition der Selektoren Muster (pattern) statt Selektoren. Muster sind syntaktisch dort erlaubt, wo formale Parameter (Variablen) neu eingeführt werden: in Funktionsdefinitionen, in Lambda-Ausdrücken und in let-ausdrücken. Beispiel-Definitionen von Selektoren mittels Muster fst (x,y) = x snd (x,y) = y selektiere_erstes_von_3 (x1,x2,x3) = x1 selektiere_zweites_von_3 (x1,x2,x3) = x2 selektiere_drittes_von_3 (x1,x2,x3) = x3 Grundlagen der Programmierung 2 (Listen-B) 54/69
113 Beispiel: Typen von Selektoren, Konstruktoren, Tupeln (1, 1) :: (Integer, Integer) (1, (2, True)) :: (Integer, (Integer, Bool)) (.,...,.) }{{} :: a1 a2... an (a1, a2,..., an) n selektiere_drittes_von_3 :: (a1, a2, a3) a3 Grundlagen der Programmierung 2 (Listen-B) 55/69
114 Benutzerdefinierte Konstruktoren Benutzerdefinierte Konstruktoren sind definierbar in Haskell mittels data-anweisung Beispiel data Punkt = Punktkonstruktor Double Double data Strecke = Streckenkonstruktor Punkt Punkt Punkt, Strecke: Punktkonstruktor Streckenkonstruktor Double, Punkt (rechts) Typen Konstruktoren Typen der Argumente Grundlagen der Programmierung 2 (Listen-B) 56/69
115 Benutzerdefinierte Konstruktoren Beispiel data Punkt = Punktkonstruktor Double Double deriving (Show,Eq) data Strecke = Streckenkonstruktor Punkt Punkt deriving (Show,Eq) Grund für die Ergänzung deriving (Show,Eq): man kann dann Objekte drucken und mit == vergleichen. Grundlagen der Programmierung 2 (Listen-B) 57/69
116 Muster (pattern) streckenanfang (Streckenkonstruktor x y) = x Nutzen der Muster: tiefes Selektieren Ersatz für Selektoren Man braucht keine Funktionsnamen Syntax der Muster: Muster ::= Variable ( Muster ) Konstruktor (n) Muster... Muster }{{} n ( Muster,..., Muster ) Bedingung: in einem Muster darf keine Variable doppelt vorkommen Grundlagen der Programmierung 2 (Listen-B) 58/69
117 Muster; Mustervergleich: Anpassen des Objekts an das Muster gleichzeitige Selektion mittels impliziter let-bindungen Tlw. vorher Auswertung des Objekts erforderlich Beispiele Grundlagen der Programmierung 2 (Listen-B) 59/69
118 Muster; Mustervergleich: Anpassen des Objekts an das Muster gleichzeitige Selektion mittels impliziter let-bindungen Tlw. vorher Auswertung des Objekts erforderlich Beispiele (x,y,(u,v)) anpassen an: (1,2,(3,4)) ergibt: let x = 1;y = 2;u = 3;v = 4 in... Grundlagen der Programmierung 2 (Listen-B) 59/69
119 Muster; Mustervergleich: Anpassen des Objekts an das Muster gleichzeitige Selektion mittels impliziter let-bindungen Tlw. vorher Auswertung des Objekts erforderlich Beispiele (x,y,(u,v)) anpassen an: (1,2,(3,4)) ergibt: let x = 1;y = 2;u = 3;v = 4 in... (x,y,(u,v)) anpassen an: (1,2,True) ergibt: Fehler. Kann nicht vorkommen wegen Typcheck. Grundlagen der Programmierung 2 (Listen-B) 59/69
120 Muster; Mustervergleich: Anpassen des Objekts an das Muster gleichzeitige Selektion mittels impliziter let-bindungen Tlw. vorher Auswertung des Objekts erforderlich Beispiele (x,y,(u,v)) anpassen an: (1,2,(3,4)) ergibt: let x = 1;y = 2;u = 3;v = 4 in... (x,y,(u,v)) anpassen an: (1,2,True) ergibt: Fehler. Kann nicht vorkommen wegen Typcheck. (x,y,u) anpassen an: (1,2,(4,5)) ergibt: let x = 1; y = 2;u = (4,5) in... Grundlagen der Programmierung 2 (Listen-B) 59/69
121 Muster; Mustervergleich: Anpassen des Objekts an das Muster gleichzeitige Selektion mittels impliziter let-bindungen Tlw. vorher Auswertung des Objekts erforderlich Beispiele (x,y,(u,v)) anpassen an: (1,2,(3,4)) ergibt: let x = 1;y = 2;u = 3;v = 4 in... (x,y,(u,v)) anpassen an: (1,2,True) ergibt: Fehler. Kann nicht vorkommen wegen Typcheck. (x,y,u) anpassen an: (1,2,(4,5)) ergibt: let x = 1; y = 2;u = (4,5) in... (x,y,u) anpassen an: (1,2,4+5) ergibt: let x = 1; y = 2;u = 4+5 in... Grundlagen der Programmierung 2 (Listen-B) 59/69
122 Benutzerdefinierte Typnamen mit Parametern Beispiel Punkt, Strecke, Polygonzug data Punkt a = Punkt a a data Strecke a = Strecke (Punkt a) (Punkt a) data Vektor a = Vektor a a data Polygon a = Polygon [Punkt a] Typ und Konstruktor können gleiche Namen haben. Der Parameter a kann jeder Typ sein: z.b.: Float, Int, aber auch [[(Int, Char)]] Grundlagen der Programmierung 2 (Listen-B) 60/69
123 Funktionen auf Punkt, Strecke, Polygonzug addierevektoren::num a => Vektor a -> Vektor a ->Vektor a addierevektoren (Vektor a1 a2) (Vektor b1 b2) = Vektor (a1 + b1) (a2 + b2) skalarprodukt (Vektor a1 a2) (Vektor b1 b2) = a1*b1 + a2*b2 streckenlaenge (Strecke (Punkt a1 a2) (Punkt b1 b2)) = sqrt (frominteger ( (quadrat (a1-b1)) + (quadrat (a2-b2)))) Grundlagen der Programmierung 2 (Listen-B) 61/69
124 Summentypen und Fallunterscheidung Summentypen: diese haben mehr als einen Konstruktor Beispiele: Bool mit True False data Bool = True False Aufzählungstyp: data Farben = Rot Gruen Blau Weiss Schwarz data Kontostand = Euro Integer Dollar Integer Renminbi Integer SFranken Integer Grundlagen der Programmierung 2 (Listen-B) 62/69
125 Datentyp Maybe data Maybe a = Just a Nothing Just 1 : Nothing : [] [Just 1,Nothing] Grundlagen der Programmierung 2 (Listen-B) 63/69
126 Liste als Summentyp selbstdefinierte Listen: (sogar rekursiv definierter Typ) Typvariable data Liste a = Nil Cons a (Liste a) Typkonstruktor Typ erstes Arg Konstruktor1 Typ zweites Arg Listen-Definition in Haskell: data [a] = [] a : [a] Konstruktor2 Grundlagen der Programmierung 2 (Listen-B) 64/69
127 Fallunterscheidung mit case Syntax: case Ausdruck of { Muster -> Ausdruck ;... ; Muster -> Ausdruck } Einschränkung: nur einfache Muster: K x 1... x n Kontextbedingung: die Muster müssen vom Typ her passen. Beispiel: und x y = case x of True -> y; False -> False Grundlagen der Programmierung 2 (Listen-B) 65/69
128 case: Gültigkeitsbereich und Beispiel F V (case x of True -> y; False -> False) = {x,y} F V (case x of (Punkt u v) -> u) = {x} GV (case x of (Punkt u v) -> u) = {u,v} Grundlagen der Programmierung 2 (Listen-B) 66/69
129 Auswertungsregel zum case (zusätzliche Auswertungsregel) case-reduktion (case (c t 1... t n ) of... (c x 1... x n s)...) s[t 1 /x 1,..., t n /x n ] Grundlagen der Programmierung 2 (Listen-B) 67/69
130 Beispiel-Verwendung (Entzuckerung) map f [] = [] map f (x:xs) = f x : map f xs kann man auch so programmieren: map f lst = (case lst of [] -> []; (x:xs) -> f x : map f xs) Grundlagen der Programmierung 2 (Listen-B) 68/69
131 Bemerkungen zur Auswertung Normale und verzögerte Reihenfolge der Auswertung werten nicht die Argumentausdrücke von Konstruktoren aus; erst wenn explizit angefordert (durch Pattern z.b. Dadurch kann man (potentiell) unendliche Listen verarbeiten Beispiele: (1+2):[] wird nicht ausgewertet: ist ein Wert 1:repeat 1 wird nicht ausgewertet: ist ein Wert Tests: seq (1:repeat 1) 7 seq (bot:repeat 1) 8 Grundlagen der Programmierung 2 (Listen-B) 69/69
Grundlagen der Programmierung 2 (1.C)
Grundlagen der Programmierung 2 (1.C) Prof. Dr. Manfred Schmidt-Schauÿ Künstliche Intelligenz und Softwaretechnologie 3. Mai 2006 Funktionen auf Listen: map map :: (a -> b) -> [a] -> [b] map f [] = []
Haskell, Typen, und Typberechnung. Grundlagen der Programmierung 3 A. Einige andere Programmiersprachen. Typisierung in Haskell
Haskell, Typen, und Typberechnung Grundlagen der Programmierung 3 A Typen, Typberechnung und Typcheck Prof. Dr. Manfred Schmidt-Schauß Ziele: Haskells Typisierung Typisierungs-Regeln Typ-Berechnung Milners
Was bisher geschah. deklarative Programmierung. funktionale Programmierung (Haskell):
Was bisher geschah deklarative Programmierung funktional: Programm: Menge von Termgleichungen, Term Auswertung: Pattern matsching, Termumformungen logisch: Programm: Menge von Regeln (Horn-Formeln), Formel
Funktionale Programmierung
Funktionale Programmierung Jörg Kreiker Uni Kassel und SMA Solar Technology AG Wintersemester 2011/2012 2 Teil II Typen mit Werten und Ausdruck, sogar listenweise 3 Haskell Programme Programm Module ein
Funktionale Programmierung mit Haskell
Funktionale Programmierung mit Haskell Dr. Michael Savorić Hohenstaufen-Gymnasium (HSG) Kaiserslautern Version 20120622 Überblick Wichtige Eigenschaften Einführungsbeispiele Listenerzeugung und Beispiel
Beispiele: (Funktionen auf Listen) (3) Bemerkungen: Die Datenstrukturen der Paare (2) Die Datenstrukturen der Paare
Beispiele: (Funktionen auf Listen) (3) Bemerkungen: 5. Zusammenhängen der Elemente einer Liste von Listen: concat :: [[a]] -> [a] concat xl = if null xl then [] else append (head xl) ( concat (tail xl))
2.5 Listen. Kurzschreibweise: [42; 0; 16] Listen werden mithilfe von [] und :: konstruiert.
![2.5 Listen. Kurzschreibweise: [42; 0; 16] Listen werden mithilfe von [] und :: konstruiert.](/thumbs/55/37072779.jpg "2.5 Listen. Kurzschreibweise: [42; 0; 16] Listen werden mithilfe von [] und :: konstruiert.")
2.5 Listen Listen werden mithilfe von [] und :: konstruiert. Kurzschreibweise: [42; 0; 16] # let mt = [];; val mt : a list = [] # let l1 = 1::mt;; val l1 : int list = [1] # let l = [1;2;3];; val l : int
Programmieren in Haskell
Programmieren in Haskell Syntax und Semantik von Haskell Programmieren in Haskell 1 Was wir heute (und nächstes mal) machen Datentypdefinitionen Wertdefinitionen, Variablenbindungen Musterbindungen Funktionsbindungen
Tag 7. Pattern Matching und eigene Datentypen
Tag 7 Pattern Matching und eigene Datentypen Heute werden wir eine Technik kennenlernen, die dafür sorgt, daß wir sehr viel übersichtlichere und kürzere Programme schreiben können. Als Überleitung auf
Funktionale Programmierung ALP I. Funktionen höherer Ordnung. Teil 2 SS 2013. Prof. Dr. Margarita Esponda. Prof. Dr.
ALP I Funktionen höherer Ordnung Teil 2 SS 2013 Funktionen höherer Ordnung Nehmen wir an, wir möchten alle Zahlen innerhalb einer Liste miteinander addieren addall:: (Num a) => [a -> a addall [ = 0 addall
Vorsicht bei redundanten und unvollständigen Matches!
Vorsicht bei redundanten und unvollständigen Matches! # let n = 7;; val n : int = 7 # match n with 0 -> "null";; Warning: this pattern-matching is not exhaustive. Here is an example of a value that is
Funktionale Programmierung mit Haskell. Jan Hermanns
Funktionale Programmierung mit Haskell Jan Hermanns 1 Programmiersprachen imperativ deklarativ konventionell OO logisch funktional Fortran Smalltalk Prolog Lisp C Eiffel ML Pascal Java Haskell 2 von Neumann
Grundprinzipien der funktionalen Programmierung
Grundprinzipien der funktionalen Programmierung Funktionen haben keine Seiteneffekte Eine Funktion berechnet einen Ausgabewert der nur von den Eingabewerten abhängt: 12 inputs + output 46 34 2 Nicht nur
Crashkurs Haskell Mentoring WiSe 2016/17. Anja Wolffgramm Freie Universität Berlin
Crashkurs Haskell Mentoring WiSe 2016/17 Anja Wolffgramm Freie Universität Berlin 02/11/2016 , Inhalt Kommandozeile Haskell installieren & starten Ein 1. Haskell-Programm Funktionsdefinition Primitive
Vorsemesterkurs Informatik
Stand der Folien: 31. März 2011 Vorsemesterkurs Informatik Sommersemester 2011 Grundlagen der Programmierung in Haskell SoSe 2011 Übersicht 1 Ausdrücke und Typen 2 Funktionen 3 Rekursion 4 Listen 5 Paare
Tutorium - Haskell in der Schule. Ralf Dorn - Dennis Buchmann - Felix Last - Carl Ambroselli
Tutorium - Haskell in der Schule Wer sind wir? Otto-Nagel-Gymnasium in Berlin-Biesdorf Hochbegabtenförderung und MacBook-Schule Leistungskurse seit 2005 Einführung Was ist funktionale Programmierung? Einführung
Programmieren in Haskell Programmiermethodik
Programmieren in Haskell Programmiermethodik Peter Steffen Universität Bielefeld Technische Fakultät 12.01.2011 1 Programmieren in Haskell Bisherige Themen Was soll wiederholt werden? Bedienung von hugs
WS 2011/2012. Georg Sauthoff 1. October 18, 2011
in in WS 2011/2012 Georg 1 AG Praktische Informatik October 18, 2011 1 gsauthof@techfak.uni-bielefeld.de Neue Übungsgruppen in neue Übungsgruppen neue Tutoren Sprechstunden in GZI-Arbeitsraum (V2-240)
Frage, Fragen und nochmals Fragen
Frage, Fragen und nochmals Fragen Berthold Hoffmann Universität Bremen and DFKI Bremen hof@informatik.uni-bremen.de In diesem Text stehen einige Fragen, die man sich zu den Folien der Veranstaltung Funktionales
ALP I Einführung in Haskell
ALP I Einführung in Haskell WS 2012/2013 Was ist Haskell? Haskell ist eine rein Funktionale Programmiersprache mit einer nach Bedarf Auswertung-Strategie oder "Lazy Evaluation". Was bedeutet rein funktional?
Programmieren in Haskell
Programmieren in Haskell Programmieren mit Listen Programmieren in Haskell 1 Was wir heute machen Eigener Listen-Datentyp Eine Sortierfunktion Nützliche Listenfunktionen Programmieren in Haskell 2 Ein
C.3 Funktionen und Prozeduren
C3 - Funktionen und Prozeduren Funktionsdeklarationen in Pascal auch in Pascal kann man selbstdefinierte Funktionen einführen: Funktionen und Prozeduren THEN sign:= 0 Funktion zur Bestimmung des Vorzeichens
Agenda. 1 Einleitung. 2 Binäre Bäume. 3 Binäre Suchbäume. 4 Rose Trees. 5 Zusammenfassung & Ausblick. Haskell Bäume. Einleitung.
Vortrag: Bäume in Haskell Bäume in Haskell Vortrag Christoph Forster Thomas Kresalek Fachhochschule Wedel University of Applied Sciences 27. November 2009 Christoph Forster, Thomas Kresalek 1/53 Vortrag
Definieren Sie eine Funktion circlearea zur Berechnung der Fläche eines Kreises mit gegebenen Radius (Float).
Haskell Funktionen Definieren Sie eine Funktion circlearea zur Berechnung der Fläche eines Kreises mit gegebenen Radius (Float). circlearea :: Float -> Float circlearea radius = 2 * pi * radius^2 Definieren
1. Erläutern Sie die Aufgaben von Datentypen in der imperativen Programmierung.
1. Erläutern Sie die Aufgaben von Datentypen in der imperativen Programmierung. Beschreiben Sie ferner je einen frei gewählten Datentyp aus der Gruppe der skalaren und einen aus der Gruppe der strukturierten
Tag 6. Module, benannte Funktionen und Rekursion
Tag 6 Module, benannte Funktionen und Rekursion Wir verlassen nun die abgeschlossene kleine Welt des interaktiven Interpreters und lernen, wie man richtige Haskell-Programme schreibt. Im Interpreter haben
26 Hierarchisch strukturierte Daten
Algorithmik II Peter Wilke Sommersemester 2005 Teil III Funktionale Programmierung 26 Hierarchisch strukturierte Daten Peter Wilke Algorithmik II Sommersemester 2005 1 Peter Wilke Algorithmik II Sommersemester
Formale Methoden in der Informatik Wiederholung klassische Logik Konkrete Datentypen (algebraische Strukturen) Abstrakte Datentypen
Was bisher geschah Formale Methoden in der Informatik Wiederholung klassische Logik Konkrete Datentypen (algebraische Strukturen) Abstrakte Datentypen Syntax: Signatur Semantik: Axiome (FOL-Formeln, meist
WS 2011/2012. Georg Sauthoff 1. November 1, 2011
WS 2011/2012 Georg 1 AG Praktische Informatik November 1, 2011 1 gsauthof@techfak.uni-bielefeld.de Übungen Abgaben und Aufgabenblätter am Ende der Vorlesung Skript gibt es demnächst in den Übungen Der
Funktionale Programmierung
Schleifen 1 Funktionale Programmierung Jörg Kreiker Uni Kassel und SMA Solar Technology AG Wintersemester 2011/2012 3 Teil I Jedem Anfang wohnt ein Zauber inne 4 Über mich Diplom in Informatik in Saarbrücken
expr :: Expr expr = Mul (Add (Const 3) (Const 4)) (Div (Sub (Const 73) (Const 37)) (Const 6))
1 - Korrektur 2 - Abstrakte Datentypen für arithmetische Ausdrücke Der Datentyp Wir beginnen zunächst mit dem algebraischen Datentyp für Ausdrücke. Hierfür definieren wir einen Konstruktor Number für Zahlen,
Einfache Ausdrücke Datentypen Rekursive funktionale Sprache Franz Wotawa Institut für Softwaretechnologie wotawa@ist.tugraz.at
Inhalt SWP Funktionale Programme (2. Teil) Einfache Ausdrücke Datentypen Rekursive funktionale Sprache Franz Wotawa Institut für Softwaretechnologie wotawa@ist.tugraz.at Interpreter für funktionale Sprache
Tag 8. Beispiel: Tabellen formatieren
Tag 8 Beispiel: Tabellen formatieren Am heutigen Tag geht es nicht in erster Linie darum, neue Konzepte einzuführen, sondern wir wollen sehen, was wir mit dem bereits Erlernten schon erreichen können.
Was bisher geschah Funktionale Programmierung in Haskell: Algebraische Datentypen Pattern Matching Polymorphie Typklassen Rekursive Datentypen:
Was bisher geschah Funktionale Programmierung in Haskell: Algebraische Datentypen Pattern Matching Polymorphie Typklassen Rekursive Datentypen: Peano-Zahlen, Listen, Bäume Rekursive Funktionen strukturelle
FachPraktikum 1590 Erweiterbare Datenbanksysteme. Aufgaben Phase 1
FachPraktikum 1590 Erweiterbare Datenbanksysteme Aufgaben Phase 1 Wintersemester 2004/2005 Ralf Hartmut Güting, Dirk Ansorge, Thomas Behr, Markus Spiekermann Praktische Informatik IV, Fernuniversität Hagen
Zahlen in Haskell Kapitel 3
Einführung in die Funktionale Programmiersprache Haskell Zahlen in Haskell Kapitel 3 FH Wedel IT-Seminar: WS 2003/04 Dozent: Prof. Dr. Schmidt Autor: Timo Wlecke (wi3309) Vortrag am: 04.11.2003 - Kapitel
Programmierung in Python
Programmierung in Python imperativ, objekt-orientiert dynamische Typisierung rapid prototyping Script-Sprache Funktionales und rekursives Programmieren P raktische Informatik 1, W S 2004/05, F olien P
Programmieren I. Kapitel 5. Kontrollfluss
Programmieren I Kapitel 5. Kontrollfluss Kapitel 5: Kontrollfluss Ziel: Komplexere Berechnungen im Methodenrumpf Ausdrücke und Anweisungen Fallunterscheidungen (if, switch) Wiederholte Ausführung (for,
zu große Programme (Bildschirmseite!) zerlegen in (weitgehend) unabhängige Einheiten: Unterprogramme
Bisher Datentypen: einfach Zahlen, Wahrheitswerte, Zeichenketten zusammengesetzt Arrays (Felder) zur Verwaltung mehrerer zusammengehörender Daten desselben Datentypes eindimensional, mehrdimensional, Array-Grenzen
Funktionale Programmiersprachen
Funktionale Programmiersprachen An den Beispielen Haskell und Erlang Übersicht Programmiersprachen λ-kalkül Syntax, Definitionen Besonderheiten von funktionalen Programmiersprache, bzw. Haskell Objektorientierte
Funktionen höherer Ordnung
Eine Funktion wird als Funktion höherer Ordnung bezeichnet, wenn Funktionen als Argumente verwendet werden, oder wenn eine Funktion als Ergebnis zurück gegeben wird. Beispiel: twotimes :: ( a -> a ) ->
Grundlagen der Programmierung 2. Bäume
Grundlagen der Programmierung 2 Bäume Prof. Dr. Manfred Schmidt-Schauÿ Künstliche Intelligenz und Softwaretechnologie 24. Mai 2006 Graphen Graph: Menge von Knoten undzugehörige (gerichtete oder ungerichtete)
Programmiersprache 1 (C++) Prof. Dr. Stefan Enderle NTA Isny
Programmiersprache 1 (C++) Prof. Dr. Stefan Enderle NTA Isny 7. Funktionen Einleitung Nach dem Prinzip Divide and Conquer bietet es sich an, größere Aufgaben in kleinere Teile zu unterteilen. Anweisungsblöcke,
Werkzeuge zur Programmentwicklung
Werkzeuge zur Programmentwicklung B-15 Bibliothek Modulschnittstellen vorübersetzte Module Eingabe Editor Übersetzer (Compiler) Binder (Linker) Rechner mit Systemsoftware Quellmodul (Source) Zielmodul
Modul 122 VBA Scribt.docx
Modul 122 VBA-Scribt 1/5 1 Entwicklungsumgebung - ALT + F11 VBA-Entwicklungsumgebung öffnen 2 Prozeduren (Sub-Prozeduren) Eine Prozedur besteht aus folgenden Bestandteilen: [Private Public] Sub subname([byval
Deklarationen in C. Prof. Dr. Margarita Esponda
Deklarationen in C 1 Deklarationen Deklarationen spielen eine zentrale Rolle in der C-Programmiersprache. Deklarationen Variablen Funktionen Die Deklarationen von Variablen und Funktionen haben viele Gemeinsamkeiten.
Programmiersprachen: rekursives Programmieren in Haskell
Kapitel 1 Programmiersprachen: rekursives Programmieren in Haskell Das generelle Ziel dieses Teils der Vorlesung ist das Verständnis von Programmierparadigmen, insbesondere rekursive Programmierung, funktionaler
zu große Programme (Bildschirmseite!) zerlegen in (weitgehend) unabhängige Einheiten: Unterprogramme
Bisher Datentypen: einfach Zahlen, Wahrheitswerte, Zeichenketten zusammengesetzt Arrays (Felder) zur Verwaltung mehrerer zusammengehörender Daten desselben Datentypes eindimensional, mehrdimensional, Array-Grenzen
Programmtransformationen und Induktion in funktionalen Programmen
Programmtransformationen und Induktion in funktionalen Programmen Prof. Dr. Manfred Schmidt-Schauß Künstliche Intelligenz und Softwaretechnologie 13. Januar 2009 Einschub: Monadisches IO verzögern Implementierung
Generische Record-Kombinatoren mit statischer Typprüfung
System Generische mit statischer Typprüfung Brandenburgische Technische Universität Cottbus Lehrstuhl Programmiersprachen und Compilerbau Lehrstuhlkolloquium am 13. Januar 2010 Überblick System System
Allgemeine Hinweise: TECHNISCHE UNIVERSITÄT MÜNCHEN. Name Vorname Studiengang Matrikelnummer. Hörsaal Reihe Sitzplatz Unterschrift
TECHNISCHE UNIVERSITÄT MÜNCHEN FAKULTÄT FÜR INFORMATIK Lehrstuhl für Sprachen und Beschreibungsstrukturen WS 2008/09 Einführung in die Informatik 2 Klausur Prof. Dr. Helmut Seidl, T. M. Gawlitza, S. Pott,
Typdeklarationen. Es gibt in Haskell bereits primitive Typen:
Typdeklarationen Es gibt in bereits primitive Typen: Integer: ganze Zahlen, z.b. 1289736781236 Int: ganze Zahlen mit Computerarithmetik, z.b. 123 Double: Fließkommazahlen, z.b. 3.14159 String: Zeichenketten,
Programmierung und Modellierung
Programmierung und Modellierung Terme, Suchbäume und Pattern Matching Martin Wirsing in Zusammenarbeit mit Moritz Hammer SS 2009 2 Inhalt Kap. 7 Benutzerdefinierte Datentypen 7. Binärer Suchbaum 8. Anwendung:
Praktikum Funktionale Programmierung Teil 1: Lexen und Parsen
Praktikum Funktionale Programmierung Teil 1: Lexen und Parsen Professur für Künstliche Intelligenz und Softwaretechnologie Sommersemester 2009 Überblick Teil 1: Lexen und Parsen Die Sprache LFP +C Professur
Adressen. Praktikum Funktionale Programmierung Organisation und Überblick. Termine. Studienleistung
Adressen Adressen, Termine Studienleistung Praktikum Funktionale Programmierung Organisation und Überblick Dr. David Sabel Büro und Email Raum 216, Robert-Mayer-Str. 11-15 sabel@ki.informatik.uni-frankfurt.de
Softwaretechnik. Funktionale Programmierung. Christian Lindig. 23. Januar 2006. Lehrstuhl für Softwaretechnik Universität des Saarlandes
Softwaretechnik Funktionale Programmierung Christian Lindig Lehrstuhl für Softwaretechnik Universität des Saarlandes 23. Januar 2006 Quicksort in Java static void sort(int a[], int lo0, int hi0) { int
Funktionales Programmieren in Python
Wintersemester 2008/2009 1 Funktionen sind Objekte 2 lambda Funktionen 3 apply 4 map 5 zip 6 filter 7 reduce 8 List Comprehension Funktionales Programmieren Wer nicht funktional programmiert, programmiert
Algorithmen und Programmieren 1 Funktionale Programmierung - Musterlösung zu Übung 1 -
Algorithmen und Programmieren 1 Funktionale Programmierung - Musterlösung zu Übung 1 - Dozent: Prof. Dr. G. Rote Tutoren: J. Fleischer, T. Haimberger, N. Lehmann, C. Pockrandt, A. Steen 18.10.2011 Ziele
Listenverarbeitung in Python
Listenverarbeitung in Python Datentypen für Sequenzen von Objekten: Tupel, Listen und Strings Tupel und Listen sind analog zu Haskells Tupel und Listen: (1, 2, 3) 3-Tupel aus den Zahlen 1,2,3, [1, 2, 3]
Der λ-kalkül. Frank Huch. Sommersemester 2015
Der λ-kalkül Frank Huch Sommersemester 2015 In diesem Skript werden die Grundlagen der Funktionalen Programmierung, insbesondere der λ-kalkül eingeführt. Der hier präsentierte Stoff stellt einen teil der
Interpreter - Gliederung
Institut für Informatik Ludwig-Maximilian Universität Interpreter - Gliederung Programmiersprache Syntax Konkrete Syntax Abstrakter Syntax Baum (Abstrakte Syntax) Parser Syntaktische Struktur einer Sprache
Algorithmen & Programmierung. Steuerstrukturen im Detail Selektion und Iteration
Algorithmen & Programmierung Steuerstrukturen im Detail Selektion und Iteration Selektion Selektion Vollständige einfache Selektion Wir kennen schon eine Möglichkeit, Selektionen in C zu formulieren: if
4.Grundsätzliche Programmentwicklungsmethoden
4.Grundsätzliche Programmentwicklungsmethoden 1.1 Grundlage strukturierter und objektorientierter Programmierung Begriff Software Engineering - umfaßt den gezielten Einsatz von Beschreibungsmitteln, Methoden
Frage: Gibt es Dinge die wir nur in anderen Sprachen berechnen können? Was kann man wirklich mit dem λ-kalkül ausdrücken?
3 Der λ-kalkül Ausdruckskraft des λ-kalküls 3.7 3.7 Ausdruckskraft des λ-kalküls Frage: Gibt es Dinge die wir nur in anderen Sprachen berechnen können? Was kann man wirklich mit dem λ-kalkül ausdrücken?
Typ-basiertes Programmieren und Schließen in Funktionalen Sprachen
Typ-basiertes Programmieren und Schließen in Funktionalen Sprachen Jun.-Prof. Janis Voigtländer Institut für Informatik III Universität Bonn WS 2009/10 Organisation Wahlpflichtvorlesung im Diplomstudiengang,
Grundlagen der Programmierung
Grundlagen der Programmierung 7. Vorlesung 18.05.2016 1 Konstanten Ganzzahlkonstante Dezimal: 42, 23, -2 Oktal (0 vorangestellt): 052 Hexadezimal (0x vorangestellt): 0x2A Gleitkommazahlen: 3.1415, 2.71,
JavaScript. Dies ist normales HTML. Hallo Welt! Dies ist JavaScript. Wieder normales HTML.
JavaScript JavaScript wird direkt in HTML-Dokumente eingebunden. Gib folgende Zeilen mit einem Texteditor (Notepad) ein: (Falls der Editor nicht gefunden wird, öffne im Browser eine Datei mit der Endung
Programmierung mit C Zeiger
Programmierung mit C Zeiger Zeiger (Pointer)... ist eine Variable, die die Adresse eines Speicherbereichs enthält. Der Speicherbereich kann... kann den Wert einer Variablen enthalten oder... dynamisch
Funktionale Programmierung. Frank Adler
F# Funktionale Programmierung Frank Adler Was ist funktionale Programmierung Funktionale Programmierung ist die Komposition von Funktionen. Funktionale Konzepte First-Class Functions Higher-Order Functions
Weitere Operationen auf neu deklarierten Typen: Begriffsklärung: Weitere Anwendungen der datatype-deklaration: Beispiel: (Aufzählungstypen)
Begriffsklärung: Weitere Operationen auf neu deklarierten Typen: Konstruktorfunktionen oder Konstruktoren liefern Werte des neu definierten Datentyps. Sie können in Mustern verwendet werden (z.b.: Student,
Repetitorium Informatik (Java)
Repetitorium Informatik (Java) Tag 6 Lehrstuhl für Informatik 2 (Programmiersysteme) Übersicht 1 Klassen und Objekte Objektorientierung Begrifflichkeiten Deklaration von Klassen Instanzmethoden/-variablen
11 Fallstudie: Reguläre Ausdrücke
11 Fallstudie: Reguläre Ausdrücke Mit den bisher eingeführten Sprachelementen von Haskell lassen sich bereits substantielle Projekte realisieren. Dieses Kapitel 1 beschreibt einen algebraischen Datentyp
Abstrakte Klassen und Induktive Datenbereiche
Abstrakte Klassen und Induktive Datenbereiche Abstrakte Klassen, Induktive Datenbereiche, Bäume, Binärbäume, Bäume mit Blättern, Listen, Konstruktoren, Prädikate, Selektoren, Mutatoren, Operationen. Abstrakte
Algorithmen & Programmierung. Ausdrücke & Operatoren (1)
Algorithmen & Programmierung Ausdrücke & Operatoren (1) Ausdrücke Was ist ein Ausdruck? Literal Variable Funktionsaufruf Ausdruck, der durch Anwendung eines einstelligen (unären) Operators auf einen Ausdruck
Tutoraufgabe 1 (Datenstrukturen in Haskell):
Prof. aa Dr. J. Giesl Programmierung WS12/13 M. Brockschmidt, F. Emmes, C. Otto, T. Ströder Allgemeine Die Hausaufgaben sollen in Gruppen von je 2 Studierenden aus der gleichen Kleingruppenübung (Tutorium)
Der Datentyp String. Stringvariable und -vergleiche
Informatik 12 mit Java: Gierhardt Zeichenketten bzw. Strings Der Datentyp String Zeichenketten bzw. Strings sind eine häufig benutzte Datenstruktur. Man könnte auch mit Arrays aus Zeichen arbeiten. Da
Felder. November 5, 2014
Felder Universität Bielefeld AG Praktische Informatik November 5, 2014 Felder: Datenstrukturen mit konstantem Zugriff Felder nennt man auch, Vektoren, Matrizen,... Konstanter Zugriff heisst: Zugriff auf
Praktische Informatik 3: Einführung in die Funktionale Programmierung Vorlesung vom 10.11.2010: Rekursive Datentypen
Rev. 1152 1 [23] Praktische Informatik 3: Einführung in die Funktionale Programmierung Vorlesung vom 10.11.2010: Rekursive Datentypen Christoph Lüth & Dennis Walter Universität Bremen Wintersemester 2010/11
VBA-Programmierung: Zusammenfassung
VBA-Programmierung: Zusammenfassung Programmiersprachen (Definition, Einordnung VBA) Softwareentwicklung-Phasen: 1. Spezifikation 2. Entwurf 3. Implementierung Datentypen (einfach, zusammengesetzt) Programmablaufsteuerung
Programmieren in Haskell. Abstrakte Datentypen
Programmieren in Haskell Abstrakte Datentypen Einführung Man unterscheidet zwei Arten von Datentypen: konkrete Datentypen: beziehen sich auf eine konkrete Repräsentation in der Sprache. Beispiele: Listen,
-ein Mustervergleicher ist ein Programm, das überprüft, ob ein Datum zu einem gegebenen Muster passt.
Thema: Wie ein beispielhaftes Query-System funktioniert Vortragender: Petar Tonev 1. Vorworte - - Ziele und Aufgaben des Vortrags klären wie das für Beispiel verwendete Anfragesystem die Herleitung musterbasierter
Java 8. Elmar Fuchs Grundlagen Programmierung. 1. Ausgabe, Oktober 2014 JAV8
Java 8 Elmar Fuchs Grundlagen Programmierung 1. Ausgabe, Oktober 2014 JAV8 5 Java 8 - Grundlagen Programmierung 5 Kontrollstrukturen In diesem Kapitel erfahren Sie wie Sie die Ausführung von von Bedingungen
Kapitel 3: Programmierung mit Kombinatoren
Funktionale Programmierung (WS2005/2006) 3/1 Kapitel 3: Programmierung mit Kombinatoren Lernziele dieses Kapitels 1. Denken in unktionalen Komponenten, Vermeidung von Kontrolllussdenken (Rekursion) Details
Kontrollstrukturen, Pseudocode und Modulo-Rechnung
Kontrollstrukturen, Pseudocode und Modulo-Rechnung CoMa-Übung III TU Berlin 29.10.2012 CoMa-Übung III (TU Berlin) Kontrollstrukturen, Pseudocode und Modulo-Rechnung 29.10.2012 1 / 1 Themen der Übung 1
Einführung in das Programmieren Prolog Sommersemester 2006. Teil 2: Arithmetik. Version 1.0
Einführung in das Programmieren Prolog Sommersemester 2006 Teil 2: Arithmetik Version 1.0 Gliederung der LV Teil 1: Ein motivierendes Beispiel Teil 2: Einführung und Grundkonzepte Syntax, Regeln, Unifikation,
Es ist für die Lösung der Programmieraufgabe nicht nötig, den mathematischen Hintergrund zu verstehen, es kann aber beim Verständnis helfen.
Ziele sind das Arbeiten mit Funktionen und dem Aufzählungstyp (enum), sowie - einfache Verzweigung (if else) - Alternativen switch case - einfache Schleifen (while oder do while) Aufgabe 3: Diese Aufgabe
Imperative vs. Funktionale Programmierung
Beispiel: Entwerfe eine Funktion, die testet, ob eine Zahl n eine Primzahl ist oder nicht. Beobachtung: (1) Wenn n Primzahl ist, ist die Menge der Teiler von n leer. (2) Die Menge der Teiler von n sind
Tutoraufgabe 1 (Zweierkomplement): Lösung: Programmierung WS16/17 Lösung - Übung 2
Prof. aa Dr. J. Giesl Programmierung WS16/17 F. Frohn, J. Hensel, D. Korzeniewski Tutoraufgabe 1 (Zweierkomplement): a) Sei x eine ganze Zahl. Wie unterscheiden sich die Zweierkomplement-Darstellungen
String s1, s2; Eine Zuweisung geschieht am einfachsten direkt durch Angabe des Strings eingeschlossen in doppelte Hochkommata:
Informatik mit Java: Gierhardt Zeichenketten bzw. Strings Der Datentyp String Zeichenketten bzw. Strings sind eine häufig benutzte Datenstruktur. Man könnte auch mit Arrays aus Zeichen arbeiten. Da aber
Die Programmiersprache C Eine Einführung
Die Programmiersprache C Eine Einführung Christian Gentsch Fakutltät IV Technische Universität Berlin Projektlabor 2. Mai 2014 Inhaltsverzeichnis 1 Einführung Entstehungsgeschichte Verwendung 2 Objektorientiert
3. Anweisungen und Kontrollstrukturen
3. Kontrollstrukturen Anweisungen und Blöcke 3. Anweisungen und Kontrollstrukturen Mit Kontrollstrukturen können wir den Ablauf eines Programmes beeinflussen, z.b. ob oder in welcher Reihenfolge Anweisungen
Funktionale Programmierung
FP-1.0 Funktionale Programmierung Prof. Dr. Uwe Kastens SS 2013 Vorlesung Funktionale Programmierung SS 2013 / Folie 100 Begrüßung Functional Programming is Fun FP-1.1 Fun ctional Programming is Fun ctional
Funktionale Programmierung. ALP I Lambda-Kalkül. Teil IVb WS 2012/2013. Prof. Dr. Margarita Esponda. Prof. Dr. Margarita Esponda
ALP I Lambda-Kalkül Teil IVb WS 2012/2013 λ-kalkül-parser Hilfsfunktionen: Die break-funktion ist eine Funktion höherer Ordnung, die eine Liste beim ersten Vorkommen einer Bedingung in zwei Listen spaltet.
Praktische Informatik 3: Funktionale Programmierung Vorlesung 3 vom : Algebraische Datentypen
16:01:59 2017-01-17 1 [35] Praktische Informatik 3: Funktionale Programmierung Vorlesung 3 vom 01.11.2016: Algebraische Datentypen Christoph Lüth Universität Bremen Wintersemester 2016/17 PI3 WS 16/17
Funktionale Programmierung. der direkte Weg vom Modell zum Programm
1 Funktionale Programmierung der direkte Weg vom Modell zum Programm Peter Padawitz, TU Dortmund 19. Juni 2010 2 Inhalt Modelle Bestandteile eines Modells Konstruktor- versus destruktorbasierte Modelle
Syntaktische Analyse (Parsen)
Syntaktische Analyse (Parsen) Gegeben: eine kontextfreie Grammatik G und ein String w. Fragen: Vorgehen: gehört w zu L(G)? Welche Bedeutung hat w? Konstruiere Herleitungsbaum zu w P raktische Informatik
Eine Einführung in die funktionale Programmierung mit Haskell
TECHNISCHE UNIVERSITÄT CAROLO-WILHELMINA ZU BRAUNSCHWEIG Übungsskript Eine Einführung in die funktionale Programmierung mit Haskell Jan Oliver Ringert, überarbeitet von Henning Basold und Christoph Szeppek
Klausur C-Programmierung / 15.02.2014 / Klingebiel / 60 Minuten / 60 Punkte
Klausur C-Programmierung / 15.02.2014 / Klingebiel / 60 Minuten / 60 Punkte Musterlösung 1. Aufgabe (5 Punkte) Im folgenden Programmcode sind einige Fehler enthalten. Finden und markieren Sie mindestens
[10] Software Transactional Memory in Haskell, Tortenwurf und Aufgabenblatt 7
![[10] Software Transactional Memory in Haskell, Tortenwurf und Aufgabenblatt 7](/thumbs/27/11687557.jpg "[10] Software Transactional Memory in Haskell, Tortenwurf und Aufgabenblatt 7")
Haskell Live [10 Software Transactional Memory in Haskell, Tortenwurf und Aufgabenblatt 7 Bong Min Kim e0327177@student.tuwien.ac.at Christoph Spörk christoph.spoerk@inode.at Bernhard Urban lewurm@gmail.com
Haskell. A Wild Ride. Sven M. Hallberg. sm@khjk.org. 21C3 Berlin / Bildungswerk Hamburg 20.6.2007 p. 1/36
21C3 Berlin / Bildungswerk Hamburg 20.6.2007 p. 1/36 Haskell A Wild Ride Sven M. Hallberg sm@khjk.org 21C3 Berlin / Bildungswerk Hamburg 20.6.2007 p. 2/36 Überblick Vorsichtsmaßnahmen Einführung und Sprachgrundlagen