Programmierkurs II. Typsynonyme & algebraische Datentypen
|
|
|
- Dagmar Lang
- vor 6 Jahren
- Abrufe
Transkript
1 Programmierkurs II Typsynonyme & algebraische Datentypen
2 Um Dinge der realen Welt abzubilden, ist es nur in den seltensten Fällen komfortabel alles als Zahlen, Strings oder Listen zu kodieren. Wir benötigen einen höheren Abstraktionsgrad. Wir wollen eigene Datentypen definieren. Motivation
3 Wir haben einen Namen (String) Wir haben eine Adresse (String) Wir benötigen eine Funktion, welche eine Adresse zu einem Namen sucht Beispiel - Adressbuch
4 Wir haben einen Namen (String) Wir haben eine Adresse (String) Wir benötigen eine Funktion, welche eine Adresse zu einem Namen sucht entry :: String -> [(String, String)] -> String entry name ((n, a):r) name == n = a otherwise = entry name r entry _ [] = error "no entry" Beispiel - Adressbuch
5 entry :: String -> [(String, String)] -> String entry name ((n, a):r) name == n = a otherwise = entry name r entry _ [] = error "no entry" Was ist hierbei das Problem? Beispiel - Adressbuch
6 entry :: String -> [(String, String)] -> String entry name ((n, a):r) name == n = a otherwise = entry name r entry _ [] = error "no entry" Was ist hierbei das Problem? Ist der erste String des Tupels der Name oder die Adresse? Man muss den Programmcode genau studieren. Beispiel - Adressbuch
7 entry :: String -> [(String, String)] -> String entry name ((n, a):r) name == n = a otherwise = entry name r entry _ [] = error "no entry" Abhilfe: Wir geben den Strings einen neuen Namen (Typsynonym) Beispiel - Adressbuch
8 Abhilfe: Wir geben den Strings einen neuen Namen (Typsynonym) type Name type Address type Addressbook = String = String = [(Name, Address)] entry2 :: Name -> Addressbook -> Address entry2 name ((n, a):r) name == n = a otherwise = entry2 name r entry2 _ [] = error "no entry" Beispiel - Adressbuch
9 Abhilfe: Wir geben den Strings einen neuen Namen (Typsynonym) type Name type Address type Addressbook = String = String = [(Name, Address)] Typsynonyme entry2 :: Name -> Addressbook -> Address entry2 name ((n, a):r) name == n = a otherwise = entry2 name r entry2 _ [] = error "no entry" Code Typsynonyme
10 Helfen beim Verständnis: type Year = Int leap :: Year -> Bool leap y = if (y `mod` 100 == 0) then (y `mod` 400 == 0) else (y `mod` 4 == 0) Code Typsynonyme - Beispiel
11 Schlüsselwort data definiert uns einen Datentyp Bool: data Bool = False True Int: data Int = Datentypen
12 Ein einfacher Datentyp, der nur einen Wert enthält data Simple = Value f :: Simple -> String f Value = "This is a value" Neue Datentypen
13 Ein einfacher Datentyp, der nur einen Wert enthält data Simple = Value Neuer Datentyp f :: Simple -> String f Value = "This is a value" Neue Datentypen
14 Ein einfacher Datentyp, der nur einen Wert enthält data Simple = Value Konstruktor (ohne Argumente) f :: Simple -> String f Value = "This is a value" Neue Datentypen
15 Ein einfacher Datentyp, der nur einen Wert enthält data Simple = Value f :: Simple -> String f Value = "This is a value" Test: *Main> f Value "This is a value" Neue Datentypen
16 Soll ein Datentyp mehrere Werte haben, werden diese von einem senkrechten Strich getrennt data Boolean = T F deriving Show not2 :: Boolean -> Boolean not2 T = F not2 F = T and2 :: Boolean -> Boolean -> Boolean and2 T x = x and2 F _ = F Neue Datentypen Alternative Konstruktoren
17 Soll ein Datentyp mehrere Werte haben, werden diese von einem senkrechten Strich getrennt data Boolean = T F deriving Show not2 :: Boolean -> Boolean not2 T = F not2 F = T and2 :: Boolean -> Boolean -> Boolean and2 T x = x and2 F _ = F Neue Datentypen besitzen keinerlei Semantik Neue Datentypen Alternative Konstruktoren
18 Soll ein Datentyp mehrere Werte haben, werden diese von einem senkrechten Strich getrennt data Boolean = T F deriving Show Reihenfolge kann eine Ordnung widerspiegeln not2 :: Boolean -> Boolean not2 T = F not2 F = T and2 :: Boolean -> Boolean -> Boolean and2 T x = x and2 F _ = F Neue Datentypen Alternative Konstruktoren
19 Schauen wir uns die Wochentage an: data Day = Monday Tuesday Wednesday Thursday Friday Saturday Sunday deriving (Show, Eq, Ord, Bounded, Enum) Neue Datentypen Alternative Konstruktoren
20 Schauen wir uns die Wochentage an: data Day = Monday Tuesday Wednesday Thursday Friday Saturday Sunday deriving (Show, Eq, Ord, Bounded, Enum) Instanz von Show: *Main> Wednesday Wednesday *Main> Friday Friday Neue Datentypen Alternative Konstruktoren
21 Schauen wir uns die Wochentage an: data Day = Monday Tuesday Wednesday Thursday Friday Saturday Sunday deriving (Show, Eq, Ord, Bounded, Enum) Instanz von Eq und Ord: *Main> Wednesday == Wednesday True *Main> Saturday > Friday True *Main> compare Monday Wednesday LT Neue Datentypen Alternative Konstruktoren
22 Schauen wir uns die Wochentage an: data Day = Monday Tuesday Wednesday Thursday Friday Saturday Sunday deriving (Show, Eq, Ord, Bounded, Enum) Instanz von Bounded: *Main> minbound :: Day Monday *Main> maxbound :: Day Sunday Neue Datentypen Alternative Konstruktoren
23 Schauen wir uns die Wochentage an: data Day = Monday Tuesday Wednesday Thursday Friday Saturday Sunday deriving (Show, Eq, Ord, Bounded, Enum) Instanz von Enum: *Main> succ Monday Tuesday *Main> pred Saturday Friday *Main> [Tuesday.. Saturday] [Tuesday,Wednesday,Thursday,Friday,Saturday] Neue Datentypen Alternative Konstruktoren
24 Definition eines Punktes: data OnePoint = Point Float Float Fragen wir nach dem Typ: *Main> :t Point Point :: Float -> Float -> OnePoint Neue Datentypen Konstruktoren mit Komponenten
25 Einen Punkt anzeigen lassen: *Main> Point <interactive>:9:1: No instance for (Show OnePoint) arising from a use of print In a stmt of an interactive GHCi command: print it Neue Datentypen Konstruktoren mit Komponenten
26 Einen Punkt anzeigen lassen: *Main> Point <interactive>:9:1: No instance for (Show OnePoint) arising from a use of print In a stmt of an interactive GHCi command: print it Definition etwas anpassen: data OnePoint = Point Float Float deriving Show Neue Datentypen Konstruktoren mit Komponenten
27 Einen Punkt anzeigen lassen: *Main> Point <interactive>:9:1: No instance for (Show OnePoint) arising from a use of print In a stmt of an interactive GHCi command: print it Definition etwas anpassen: data OnePoint = Point Float Float deriving Show Testen: *Main> Point Point Neue Datentypen Konstruktoren mit Komponenten
28 Show selber definieren: data OnePoint = Point Float Float instance Show(OnePoint) where show (Point x y) = "x: " ++ show x ++ ", y: " ++ show y Testen: *Main> Point x: 3.4, y: 4.2 Neue Datentypen Konstruktoren mit Komponenten
29 Show selber definieren: data OnePoint = Point Float Float OnePoint als Instanz der Klasse Show definieren instance Show(OnePoint) where show (Point x y) = "x: " ++ show x ++ ", y: " ++ show y Testen: *Main> Point x: 3.4, y: 4.2 Neue Datentypen Konstruktoren mit Komponenten
30 Eq selber definieren: data OnePoint = Point Float Float instance Eq(OnePoint) where (==) (Point x y) (Point x' y') = x == x' && y == y' Testen: *Main> Point 2 3 == Point 2 3 True Neue Datentypen Konstruktoren mit Komponenten
31 Da die Komponenten Mitglieder der entsprechenden Typklassen sind: data OnePoint = Point Float Float deriving (Show, Eq) Neue Datentypen Konstruktoren mit Komponenten
32 Da die Komponenten Mitglieder der entsprechenden Typklassen sind: data OnePoint = Point Float Float deriving (Show, Eq) Neue Datentypen Konstruktoren mit Komponenten
33 Definieren wir einen Kreis: data Circle = Circle OnePoint Float deriving (Show, Eq) Neue Datentypen Konstruktoren mit Komponenten
34 Definieren wir einen Kreis: data Circle = Circle OnePoint Float deriving (Show, Eq) Zugriff auf den Mittelpunkt und den Radius midpoint :: Circle -> OnePoint midpoint (Circle m _) = m radius :: Circle -> Float radius (Circle _ r) = r Neue Datentypen Konstruktoren mit Komponenten
35 Stellen wir uns mal vor, wir definieren eine Person data Person = Person String String Int Float String String deriving (Show) Neue Datentypen Konstruktoren mit Komponenten
36 Stellen wir uns mal vor, wir definieren eine Person data Person = Person String String Int Float String String deriving (Show) Zugriff auf die unterschiedlichen Elemente: firstname :: Person -> String firstname (Person firstname _) = firstname lastname :: Person -> String lastname (Person _ lastname ) = lastname age :: Person -> Int age (Person age _) = age height :: Person -> Float height (Person _ height ) = height phonenumber :: Person -> String phonenumber (Person number _) = number flavor :: Person -> String flavor (Person _ flavor) = flavor Neue Datentypen Konstruktoren mit Komponenten
37 Stellen wir uns mal vor, wir definieren eine Person data Person = Person String String Int Float String String deriving (Show) Zugriff auf die unterschiedlichen Elemente (BESSER): data Person = Person { firstname :: String, lastname :: String, age :: Int, height :: Float, phonenumber :: String, flavor :: String } deriving (Show) Neue Datentypen Konstruktoren mit Komponenten
38 Definieren wir einen Kreis: data Circle = Circle OnePoint Float deriving (Show, Eq) Komfortabel wäre es direkten Zugriff auf die Komponenten zu haben: data Circle = Circle{midPoint :: OnePoint, radius :: Float} deriving (Show, Eq) Neue Datentypen Konstruktoren mit Komponenten
39 Definieren wir einen Kreis: data Circle = Circle OnePoint Float deriving (Show, Eq) Komfortabel wäre es direkten Zugriff auf die Komponenten zu haben: data Circle = Circle{midPoint :: OnePoint, radius :: Float} deriving (Show, Eq) Testen: *Main> let circle = Circle (Point 2 3) 3 *Main> radius circle 3.0 Neue Datentypen Konstruktoren mit Komponenten
40 Flächeninhalt eines Kreises berechnen: areacircle :: Circle -> Float areacircle c = pi * (radius c)^2 Neue Datentypen Konstruktoren mit Komponenten
41 Flächeninhalt eines Kreises berechnen: areacircle :: Circle -> Float areacircle c = pi * (radius c)^2 Alternative mit Pattern Matching: areacircle' :: Circle -> Float areacircle' (Circle _ r) = pi * r^2 Neue Datentypen Konstruktoren mit Komponenten
42 Definieren wir ein Rechteck: data Rect = Rect {upperleft :: OnePoint, lowerright :: OnePoint} deriving (Show) Flächeninhalt eines Rechtecks berechnen: Neue Datentypen Konstruktoren mit Komponenten
43 Definieren wir ein Rechteck: data Rect = Rect {upperleft :: OnePoint, lowerright :: OnePoint} deriving (Show) Flächeninhalt eines Rechtecks berechnen: arearect :: Rect -> Float arearect (Rect p1 p2) = abs (a1 * a2) where a1 = (xval p1 - xval p2) a2 = (yval p1 - yval p2) Neue Datentypen Konstruktoren mit Komponenten
44 Wir führen eine abstraktere Ebene ein: data Shape = Rect{upperLeft :: OnePoint, lowerright :: OnePoint} Circle{midPoint :: OnePoint, radius :: Float} deriving (Show) Neue Datentypen - Abstraktion
45 Um welche Shape (Figur) handelt es sich? isrect (Rect ) = True isrect _ = False iscircle (Circle ) = True iscircle _ = False Dementsprechend die richtige Funktion aufrufen: area :: Shape -> Float area s = if (isrect s) then (arearect s) else (areacircle s) Neue Datentypen - Abstraktion
46 Um welche Shape (Figur) handelt es sich? isrect (Rect ) = True isrect _ = False iscircle (Circle ) = True iscircle _ = False Dementsprechend die richtige Funktion aufrufen: area :: Shape -> Float area s = if (isrect s) then (arearect s) else (areacircle s) Neue Datentypen - Abstraktion
47 Anpassen der vorherigen Funktionsdefinitionen: arearect :: Shape -> Float arearect (Rect p1 p2) = abs (a1 * a2) where a1 = (xval p1 - xval p2) a2 = (yval p1 - yval p2) areacircle :: Shape -> Float areacircle c = pi * (radius c)^2 Neue Datentypen - Abstraktion
48 Weiteres Beispiel mit Maybe: Schreiben Sie eine Funktion, die für eine Liste und ein Element das erste nachfolgende Element in der Liste zurückgibt. Wieso ist diese Definition etwas problematisch? Neue Datentypen Maybe
49 Weiteres Beispiel mit Maybe: Schreiben Sie eine Funktion, die für eine Liste und ein Element das erste nachfolgende Element in der Liste zurückgibt. Wieso ist diese Definition etwas problematisch? Das letzte Element einer Liste hat keinen Nachfolger. Es gibt kein nachfolgendes Element wenn: die Liste leer ist. Wenn das Element nicht in der Liste ist Neue Datentypen Maybe
50 Implementierung: successor :: (Eq a) => a -> [a] -> Maybe a successor x [] = Nothing successor x (y:xs) xs == [] = Nothing x == y && xs /= [] = Just (head xs) not (x `elem` xs) = Nothing otherwise = successor x xs Neue Datentypen Maybe
51 Implementierung: Parametrisierter Datentyp successor :: (Eq a) => a -> [a] -> Maybe a successor x [] = Nothing successor x (y:xs) xs == [] = Nothing x == y && xs /= [] = Just (head xs) not (x `elem` xs) = Nothing otherwise = successor x xs Neue Datentypen Maybe
52 Definieren wir Mengen: infixr 5 :<: data MySet a = Empty a :<: MySet a Ist die Menge Leer? isempty :: MySet a -> Bool isempty Empty = True isempty _ = False Neue Rekursive Datentypen - Mengen
53 Ist ein Element in einer Menge enthalten: element :: (Eq a) => a -> MySet a -> Bool element x Empty = False element x (y :<: xs) = if (x == y) then True else (element x xs) Neue Rekursive Datentypen - Mengen
54 Definieren wir eine Teilmenge: A B ( x : x A x B ) A = B A B und B A subset :: (Eq a) => MySet a -> MySet a -> Bool subset Empty ms = True Neue Rekursive Datentypen - Mengen
55 Definieren wir eine Teilmenge: A B ( x : x A x B ) A = B A B und B A subset :: (Eq a) => MySet a -> MySet a -> Bool subset Empty ms = True subset (a :<: ns) ms = if (a `element` ms) then subset ns ms else False Neue Rekursive Datentypen - Mengen
56 Aus diesen Definitionen können wir nun Eq ableiten: A B ( x : x A x B ) A = B A B und B A Neue Rekursive Datentypen - Mengen
57 Aus diesen Definitionen können wir nun Eq ableiten: A B ( x : x A x B ) A = B A B und B A instance (Eq a) => Eq (MySet a) where ns == ms = (subset ns ms) && (subset ms ns) Neue Rekursive Datentypen - Mengen
58 Aus diesen Definitionen können wir nun Eq ableiten: a muss ebenfalls Mitglied von Eq sein A B ( x : x A x B ) A = B A B und B A instance (Eq a) => Eq (MySet a) where ns == ms = (subset ns ms) && (subset ms ns) Neue Rekursive Datentypen - Mengen
59 Elemente einfügen: insert :: (Eq a) => a -> MySet a -> MySet a insert x xs x `element` xs = xs otherwise = x :<: xs Elemente löschen: delete :: (Eq a) => a -> MySet a -> MySet a delete x Empty = Empty delete x (y :<: xs) x == y = delete x xs otherwise = y :<: (delete x xs) Neue Rekursive Datentypen - Mengen
60 Spezielle Funktionen: singleton :: a -> MySet a singleton x = x :<: Empty toset :: (Eq a) => [a] -> MySet a toset xs = foldr insert Empty xs tolist :: MySet a -> [a] tolist Empty = [] tolist (x :<: ms) = x:(tolist ms) Neue Rekursive Datentypen - Mengen
61 Sich die Mengen anzeigen lassen: instance (Show a) => Show (MySet a) where show Empty = "{}" show (a :<: ms) = "{" ++ (show a) ++ (concat showrest) ++ "}" where showrest isempty ms = [""] otherwise = map (", " ++) (map show (tolist ms)) Neue Rekursive Datentypen - Mengen
62 Vereinigung zweier Mengen: infixr 5 # (#) :: (Eq a) => MySet a -> MySet a -> MySet a (#) ms ns = foldr insert ms (tolist ns) Vereinigung von Teilmengen einer Menge: bigunion :: (Eq a) => MySet (MySet a) -> MySet a bigunion nss = foldr (#) Empty (tolist nss) Neue Rekursive Datentypen - Mengen
63 Vereinigung zweier Mengen: infixr 5 # (#) :: (Eq a) => MySet a -> MySet a -> MySet a (#) ms ns = foldr insert ms (tolist ns) Vereinigung von Teilmengen einer Menge: bigunion :: (Eq a) => MySet (MySet a) -> MySet a bigunion nss = foldr (#) Empty (tolist nss) Welcher Funktion entspricht bigunion auf Listen? Neue Rekursive Datentypen - Mengen
64 Identische Elemente zweier Mengen extrahieren: infixr 5 % (%) ms ns = toset (filter (\y -> y `element` ns) (tolist ms)) Neue Rekursive Datentypen - Mengen
65 Alle Teilmengen einer Menge generieren: allsubsets :: (Eq a) => MySet a -> [MySet a] allsubsets Empty = [Empty] allsubsets (x :<: ms) x `element` ms = all' otherwise = all' ++ (map (insert x) all') where all' = allsubsets ms Neue Rekursive Datentypen - Mengen
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
Programmieren in Haskell
Programmieren in Haskell Wir steigen ein... Programmieren in Haskell 1 Was wir heute machen Umfrage: Wer hat den Hugs ausprobiert? Ausdrücke und Werte Datentypen Funktionen Aufgabe für diese Woche Programmieren
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,
Programmieren in Haskell
Programmieren in Haskell Felder (Arrays) Programmieren in Haskell 1 Was wir heute machen Motivationsbeispiel Die Typklasse Ix Felder in Haskell Funktionstabellierung Binäre Suche Pascalsches Dreieck Ein
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
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
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
Funktionale Programmierung mit Haskell
Funktionale Programmierung mit Haskell Prof. Dr. Hans J. Schneider Lehrstuhl für Programmiersprachen und Programmiermethodik Friedrich-Alexander-Universität Erlangen-Nürnberg Sommersemester 2011 I. Die
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
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
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)
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,
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. 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.
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
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
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
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
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
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
[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
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
Programmieren in Haskell Felder (Arrays)
Programmieren in Haskell Felder (Arrays) Peter Steffen Universität Bielefeld Technische Fakultät 05.12.2008 1 Programmieren in Haskell Quadratzahlen 0 1 2 3 n 0 1 4 9 n 2 squareslist :: Integral a => [a]
1 Induktiver Aufbau von Graphen
Ï˾¼½¼»½½ ÙÒ Ø ÓÒ Ð ÅÓ ÐÐ ÖÙÒ ĐÙÖ Ó Ò ÓÖÑ Ø ÓÒ Ý Ø Ñ Ö Ô Ò Ð ÓØ Ä ºÅĐÓÐÐ Ö ºÅĐÓÐÐ Ö»ËºÌ ÑÔ ß ß FuGoe Ù Ó¼ Ö Ô Ò Å ÖØ Ò ÖÛ µ Ä ÙÒ Ø ÓÒ Ð Ð ÓØ ÞÙÖ Ò ÐÙÒ Ö ÐÐ Ñ Ò Ö Î Ö Ö Ò ØÞ FuGoe ÙØÓÑ Ø Ò Ö ÑÑ ß¾ß ºÅĐÓÐÐ
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))
Wiederholung Wozu Methoden? Methoden Schreiben Methoden Benutzen Rekursion?! Methoden. Javakurs 2012, 3. Vorlesung
Wiederholung Wozu? Schreiben Benutzen Rekursion?! Javakurs 2012, 3. Vorlesung maggyrz@freitagsrunde.org 5. März 2013 Wiederholung Wozu? Schreiben Benutzen Rekursion?! 1 Wiederholung 2 Wozu? 3 Schreiben
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
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
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
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
Advanced Programming in C
Advanced Programming in C Pointer und Listen Institut für Numerische Simulation Rheinische Friedrich-Wilhelms-Universität Bonn Oktober 2013 Überblick 1 Variablen vs. Pointer - Statischer und dynamischer
19. Funktional-reaktive Programmierung
19. Funktional-reaktive Programmierung Graphische Figuren type Dimension = Int data Figure = Rect Dimension Dimension Triangle Dimension Angle Dimension Polygon [Point] Circle Dimension Translate Point
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)
Kapitel 7 des Buches, von Java-Selbstbau nach Scala-Library portiert. 2014-11-14 Christoph Knabe
Anfragen für Listen Kapitel 7 des Buches, von Java-Selbstbau nach Scala-Library portiert. 2014-11-14 Christoph Knabe 1 MapReduce-Verfahren Google u.a. verwenden Map-Reduce-Verfahren zur Verarbeitung riesiger
JAVA für Nichtinformatiker - Probeklausur -
JAVA für Nichtinformatiker - Probeklausur - Die folgenden Aufgaben sollten in 150 Minuten bearbeitet werden. Aufgabe 1: Erläutere kurz die Bedeutung der folgenden Java-Schlüsselwörter und gib Sie jeweils
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
Vorkurs C++ Programmierung
Vorkurs C++ Programmierung Klassen Letzte Stunde Speicherverwaltung automatische Speicherverwaltung auf dem Stack dynamische Speicherverwaltung auf dem Heap new/new[] und delete/delete[] Speicherklassen:
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
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 [] = []
Übung 9. Quellcode Strukturieren Rekursive Datenstrukturen Uebung 9
Informatik I 2 Übung 9 Quellcode Strukturieren Rekursive Datenstrukturen Uebung 9 Quellcode Strukturieren Wenn alle Funktionen in einer Datei zusammengefasst sind wird es schnell unübersichtlich Mehrere
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
Eine zu Grunde liegende Typdefinition beschreibt eine Struktur, die alle erlaubten Instanzen dieses Typs gemeinsam haben.
Der binäre Baum Tree Die geläufigste Datenstuktur ist der binäre Baum Tree. Dieses Beispielskript zeigt im direkten Vergleich zu anderen Sprachen den Umgang mit formalen Typparametern in CHELSEA. Wir steigen
Funktionale Programmierung mit Haskell
Funktionale Programmierung mit Haskell Prof. Dr. Hans J. Schneider Lehrstuhl für Programmiersprachen und Programmiermethodik Friedrich-Alexander-Universität Erlangen-Nürnberg Sommersemester 2011 I. Die
Funktionale Programmiersprachen
Funktionale Programmiersprachen An den Beispielen Haskell und Erlang Übersicht Programmiersprachen λ-kalkül Syntax, Definitionen Besonderheiten von funktionalen Programmiersprache, bzw. Haskell Objektorientierte
Einführung in die funktionale Programmierung
Einführung in die funktionale Programmierung Prof. Dr. Manfred Schmidt-Schauÿ Künstliche Intelligenz und Softwaretechnologie 20. November 2006 Monaden und I/O Monade ist ein Datentyp für (sequentielle)
Klausur zur Veranstaltung Programmierung (fortgeschrittene Konzepte)
Klausur zur Veranstaltung Programmierung (fortgeschrittene Konzepte) Bearbeitungszeit: 100 Minuten (14:15-15:55) Gesamtpunktzahl: 80 Punkte + 30 Zusatzpunkte Die Punktzahlen sind in etwa so bemessen, dass
1. Typen und Literale (6 Punkte) 2. Zuweisungen (6 = Punkte)
Praktische Informatik (Software) Vorlesung Softwareentwicklung 1 Prof. Dr. A. Ferscha Hauptklausur am 01. 02. 2001 Zuname Vorname Matr. Nr. Stud. Kennz. Sitzplatz HS / / / Punkte Note korr. Fügen Sie fehlende
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,
Typklassen, Eingabe und Monaden In Haskell
Typklassen, Eingabe und Monaden In Haskell Felix Rahmati Jonathan Beierle 1 Einleitung In dieser Ausarbeitung befassen wir uns mit den Vorteilen einiger fortgeschrittener Konzepte der funktionalen Programmierung
Probeklausur: Programmierung WS04/05
Probeklausur: Programmierung WS04/05 Name: Hinweise zur Bearbeitung Nimm Dir für diese Klausur ausreichend Zeit, und sorge dafür, dass Du nicht gestört wirst. Die Klausur ist für 90 Minuten angesetzt,
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
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
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
BTree.dll - Balancierte und verkettete Bäume. Ecofor. BTree.dll. Realisiert mit Microsoft Visual Studio 16.04.2015 1/9
BTree.dll Realisiert mit Microsoft Visual Studio 16.04.2015 1/9 INHALT 1. Allgemein... 3 2. Class BTree1 (balanciert)... 3 3. Class BTree2 (balanciert und verkettet)... 4 4. Beschreibung BTree1 und BTree2...
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:
Funktionale Programmierung
Funktionale Programmierung Mitschrift von www.kuertz.name Hinweis: Dies ist kein offizielles Script, sondern nur eine private Mitschrift. Die Mitschriften sind teweilse unvollständig, falsch oder inaktuell,
Vorlesung Datenstrukturen
Vorlesung Datenstrukturen Binärbaum Suchbaum Dr. Frank Seifert Vorlesung Datenstrukturen - Sommersemester 2016 Folie 356 Datenstruktur Binärbaum Strukturrepräsentation des mathematischen Konzepts Binärbaum
Wiederholung ADT Menge Ziel: Verwaltung (Finden, Einfügen, Entfernen) einer Menge von Elementen
Was bisher geschah abstrakter Datentyp : Signatur Σ und Axiome Φ z.b. ADT Menge zur Verwaltung (Finden, Einfügen, Entfernen) mehrerer Elemente desselben Typs Spezifikation einer Schnittstelle Konkreter
Nützliche Utility-Klassen des JDK
Nützliche Utility-Klassen des JDK java.util :, Properties, I18N, Scanner java.text : Ausgabeformatierung u.a. java.util.prefs : Hierarchische Konfigurationsdaten (1.5) java.util.logging : Aufzeichnung
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
Übungen zur Vorlesung Funktionale Programmierung. Wintersemester 2012/2013 Übungsblatt 1
Übungsblatt 1 Installieren Sie die Haskell-Platform (http://www.haskell.org/platform/) auf ihrem Rechner. Stellen Sie zudem sicher, dass ghci zu ihrer Pfadvariablen hinzugefügt wird. Unter Windows nden
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,
On a Sunday Morning summary
On a Sunday Morning summary Connect the English sentences and their German translation Verbinde die englischen Sätze mit ihrer deutschen Übersetzung The hedgehog was standing at the door of his house He
Kapitel 7: Benutzerdefinierte Datentypen
Kapitel 7: Benutzerdefinierte Datentypen Andreas Abel LFE Theoretische Informatik Institut für Informatik Ludwig-Maximilians-Universität München 10. Juni 2011 Quelle: Martin Wirsing, Benutzerdefinierte
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
Proseminar: Perlen der Informatik II Haskell List comprehensions & Typklassen
Proseminar: Perlen der Informatik II Haskell List comprehensions & Typklassen Dmitriy Traytel 8. Juli 2008 Diese Ausarbeitung im Rahmen des Proseminars Perlen der Informatik II beschäftigt sich mit einigen
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
Um nicht immer den Strukturnamen verwenden zu müssen, kann man auch alle Definitionen einer Struktur auf einmal sichtbar machen:
Öffnen von Strukturen Um nicht immer den Strukturnamen verwenden zu müssen, kann man auch alle Definitionen einer Struktur auf einmal sichtbar machen: open P a i r s ; opening Pairs type a Pair = a * a
1. Grundzüge der Objektorientierung 2. Methoden, Unterprogramme und Parameter 3. Datenabstraktion 4. Konstruktoren 5. Vordefinierte Klassen
1. Grundzüge der Objektorientierung 2. Methoden, Unterprogramme und Parameter 3. Datenabstraktion 4. Konstruktoren 5. Vordefinierte Klassen II.2.3 Datenabstraktion - 1 - public class Rechteck { Selektoren
HASKELL KURS RALF HINZE. Institut für Informatik III Universität Bonn Römerstraße 164 53117 Bonn Germany
HASKELL KURS RALF HINZE Institut für Informatik III Universität Bonn Römerstraße 164 53117 Bonn Germany Email: ralf@informatik.uni-bonn.de Homepage: http://www.informatik.uni-bonn.de/~ralf/ April 2002
ALP I. Funktionale Programmierung
ALP I Funktionale Programmierung Sortieren und Suchen (Teil 1) WS 2012/2013 Suchen 8 False unsortiert 21 4 16 7 19 11 12 7 1 5 27 3 8 False sortiert 2 4 6 7 9 11 12 18 21 24 27 36 Suchen in unsortierten
equals und hashcode SortedSet NavigableSet Assoziative Container Programmieren II Dr. Klaus Höppner Hochschule Darmstadt Sommersemester 2010 1 / 32
Programmieren II Dr. Klaus Höppner Hochschule Darmstadt Sommersemester 2010 1 / 32 equals und hashcode SortedSet NavigableSet Assoziative Container 2 / 32 HashSet mit eigener Klasse Wie kann man einen
Javakurs für Anfänger
Javakurs für Anfänger Einheit 10: Mehr zur Vererbung und abstrakte Klassen Lorenz Schauer Lehrstuhl für Mobile und Verteilte Systeme Heutige Agenda 1. Teil: Mehr zur Vererbung Methoden vererben und überschreiben
Fragen. f [ ] = [ ] f (x : y : ys) = x y : f ys f (x : xs) = f (x : x : xs) Wozu evaluiert f [1, 2, 3] (Abkürzung für f (1 : 2 : 3 : [ ]))?
![Fragen. f [ ] = [ ] f (x : y : ys) = x y : f ys f (x : xs) = f (x : x : xs) Wozu evaluiert f [1, 2, 3] (Abkürzung für f (1 : 2 : 3 : [ ]))?](/thumbs/24/4200701.jpg "Fragen. f [ ] = [ ] f (x : y : ys) = x y : f ys f (x : xs) = f (x : x : xs) Wozu evaluiert f [1, 2, 3] (Abkürzung für f (1 : 2 : 3 : [ ]))?")
Fragen f [ ] = [ ] f (x : y : ys) = x y : f ys f (x : xs) = f (x : x : xs) Wozu evaluiert f [1, 2, 3] (Abkürzung für f (1 : 2 : 3 : [ ]))? Wozu evaluiert [f [ ], f [ ]]? Weiteres Beispiel: f [ ] y = [
Übung Datenstrukturen. Objektorientierung in C++
Übung Datenstrukturen Objektorientierung in C++ Aufgabe 1a - Farben Schreiben Sie eine Klasse COLOR zur Beschreibung von Farben. Eine Farbe werde hierbei additiv durch ihren Rot-, Grün- und Blauanteil
XML Verarbeitung mit einer in Haskell eingebetteten DSL. Manuel Ohlendorf (xi2079)
XML Verarbeitung mit einer in Haskell eingebetteten DSL Manuel Ohlendorf (xi2079) 2.0.200 Manuel Ohlendorf Übersicht 1 2 Einführung Datenstruktur Verarbeitung Vergleich mit anderen Verfahren Fazit 2 Übersicht
Thomas Behr. 17. November 2011
in in Fakultät für Mathematik und Informatik Datenbanksysteme für neue Anwendungen FernUniversität in Hagen 17. November 2011 c 2011 FernUniversität in Hagen Outline in 1 2 3 4 5 6 - Was ist das? in über
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.
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
Humboldt Universität zu Berlin Institut für Informatik Seminar Systementwurf WS 05/06 Vortrag: Mike Herzog. AsmL
Humboldt Universität zu Berlin Institut für Informatik Seminar Systementwurf WS 05/06 Vortrag: Mike Herzog AsmL Abstract State Machine Language ins kalte Wasser var A = [3, 10, 5, 7, 1] indices = {0, 1,
Objektorientierte Programmierung
Unterlagen zur Veranstaltung Einführung in die Objektorientierte Programmierung Mit Processing Alexis Engelke Sommer 2012 Alexis Engelke Inhalt Level 1: Geometrie Hintergrundfarben Punkte, Linien und deren
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
Verträge für die funktionale Programmierung Design und Implementierung
1 Verträge für die funktionale Programmierung Design und Implementierung RALF HINZE Institut für Informatik III, Universität Bonn Römerstraße 164, 53117 Bonn, Germany Email: ralf@informatik.uni-bonn.de
II.3.1 Rekursive Algorithmen - 1 -
1. Grundelemente der Programmierung 2. Objekte, Klassen und Methoden 3. Rekursion und dynamische Datenstrukturen 4. Erweiterung von Klassen und fortgeschrittene Konzepte II.3.1 Rekursive Algorithmen -
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
Newsletter2Go - API Dokumentation
Newsletter2Go - API Dokumentation Changelog: (version 1.0 version 1.1) - Zwei neue optionale Parameter (opentracking, linktracking) in Email versenden Funktion (version 0.9 version 1.0) - category ist
THE GO PROGRAMMING LANGUAGE. Michael Karnutsch & Marko Sulejic
THE GO PROGRAMMING LANGUAGE Part 1: Michael Karnutsch & Marko Sulejic Gliederung Geschichte / Motivation Compiler Formatierung, Semikolons Variablen, eigene Typen Kontrollstrukturen Funktionen, Methoden
Escher funktionale und logische Programmierung
Escher funktionale und logische Programmierung Seminar Programming Languages From Hell Lars Hupel 2010-06-07 Dieses Werk ist lizenziert unter den Bedingungen der Creative Commons Namensnennung 3.0 Deutschland.
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
1. Erste Schritte 2. Einfache Datentypen 3. Anweisungen und Kontrollstrukturen 4. Verifikation 5. Reihungen (Arrays)
1. Erste Schritte 2. Einfache Datentypen 3. Anweisungen und Kontrollstrukturen 4. Verifikation 5. Reihungen (Arrays) II.1.3. Anweisungen und Kontrollsttukturen - 1 - 3. Anweisungen und Kontrollstrukturen
Grundlagen der Objektorientierung
Grundlagen der Objektorientierung Klassen, Attribute, Methoden Kapselung und Konstruktoren Vererbung Packages Interfaces und Adapterklassen 04.06.2008 Marcel Wieczorek 14 Klassen, Attribute, Methoden package
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
Die Algorithmenbeschreibungssprache Jana
Jana 1 Die Algorithmenbeschreibungssprache Jana Günther Blaschek, Institut für Systemsoftware, JKU Linz Juni 2011 Jana (Java-based Abstract Notation for Algorithms) ist eine Beschreibungssprache zur Formulierung
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
TECHNISCHE UNIVERSITÄT MÜNCHEN FAKULTÄT FÜR INFORMATIK
TECHNISCHE UNIVERSITÄT MÜNCHEN FAKULTÄT FÜR INFORMATIK WS 11/12 Einführung in die Informatik II Übungsblatt 2 Univ.-Prof. Dr. Andrey Rybalchenko, M.Sc. Ruslán Ledesma Garza 8.11.2011 Dieses Blatt behandelt
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
Silke Trißl, Prof. Ulf Leser Wissensmanagement in der Bioinformatik. Jede Applikation braucht eine Klasse mit einer main-methode
Methoden und Klassen Silke Trißl, Prof. Ulf Leser Wissensmanagement in der Bioinformatik Wiederholung Jede Applikation braucht eine Klasse mit einer main-methode Eintrittspunkt in das Programm Die main-methode
1 On Monday no cornflakes Hörverstehen. Voraussetzungen Stage 1; Wochentage und Wörter zum Thema Frühstück
1 On Monday no cornflakes Hörverstehen Voraussetzungen Stage 1; Wochentage und Wörter zum Thema Frühstück Monday: Tuesday: Wednesday: Thursday: Friday: Saturday: Sunday: Listen and cross out the right
Nachweis der Verhaltensäquivalenz von Feldbus-Komponenten auf unterschiedlichen Abstraktionsebenen
Nachweis der Verhaltensäquivalenz von Feldbus-Komponenten auf unterschiedlichen Abstraktionsebenen Diplomarbeit Martin Pitt martin@piware.de Technische Universität Dresden 11. November 2004 1 Aufgabenstellung
Funktionale Programmierung mit Haskell
Funktionale Programmierung mit Haskell Prof. Dr. Hans J. Schneider Lehrstuhl für Programmiersprachen und Programmiermethodik Friedrich-Alexander-Universität Erlangen-Nürnberg Sommersemester 2012 I. Die