Einführung in die funktionale Programmierung
|
|
- Tristan Gerber
- vor 6 Jahren
- Abrufe
Transkript
1 Einführung in die funktionale Programmierung Prof. Dr. Manfred Schmidt-Schauÿ Künstliche Intelligenz und Softwaretechnologie 17. Oktober 2006
2 Einführung in Haskell: Syntax, Reduktionen, Kernsprachen Haskell, eine nicht-strikte funktionale Programmiersprache mit polymorphem Typsystem. Ziel dieses Kapitels ist: Darstellung der syntaktischen Grundlagen, Unterscheidung zwischen Kernbestandteilen der Programmiersprache und zusätzlichen Features, Progammierverständnis in Haskell, operationale Semantik: Auswertungen Einführung in die funktionale Programmierung; Folien Kap
3 Die Kernsprache KFPT Die Kernsprache folgt der Lambda-Schreibweise im Lambda-Kalkül, der von Alonzo Church entwickelt wurde. Der Lambda-Kalkül ist Teil der betrachteten Kernsprache und auch von Haskell. Einführung der Syntax und Reduktionsregeln Einführung in die funktionale Programmierung; Folien Kap
4 Syntax von KFPT Es gibt Konstantensymbole, die jeweils eine feste Stelligkeit haben. Diese nennen wir auch Konstruktoren. Konstruktoren mit Stelligkeit sind anzugeben (wir erfinden keine KFPT-Syntax dafür) Es gibt Typen Jeder Konstruktor gehört zu genau einem Typ. z.b. seien die Typen Bool und List; zu Bool gehören True und False, zu List gehören Cons und Nil. Es gibt pro Typ ein case-konstrukt: case T ypname. Einführung in die funktionale Programmierung; Folien Kap
5 Syntax von KFPT Kontextfreie Grammatik für KFPT Exp ::= V (Variable) (\V -> Exp) wobei V eine Variable ist. (Exp 1 Exp 2 ) (c Exp 1... Exp n ) wobei c Konstruktor und n = ar(c) (case Typ Exp of {P at 1 -> Exp 1 ;... ; P at n -> Exp n }) Hierbei ist P at i Pattern zum Konstruktor i, Es kommen genau die Konstruktoren zu Typname vor P at i Exp i heißt auch case-alternative. Pat ::= (c V 1... V ar(c) ) Die Variablen V i müssen alle verschieden sein. Einführung in die funktionale Programmierung; Folien Kap
6 Syntax von KFPT (c V 1... V ar(c) ) sind einfache Pattern bzw. Muster. λx.s im Lambda-Ausdrücke entspricht \x -> s in KFPT Zum Beispiel: λx.1 ist die Funktion, die konstant 1 liefert. Einführung in die funktionale Programmierung; Folien Kap
7 Beispiele in KFPT Die Funktion, die leere Listen erkennt: \xs -> (case_bool xs of {Nil -> True; Cons y ys -> False}) In Haskell: kein Typ-Index am case, sondern automatische Typerkennung Einführung in die funktionale Programmierung; Folien Kap
8 Ausdrücke in KFPT (Haskell) \x -> s sind Abstraktionen oder Funktionsausdrücke. (s t) sind Anwendungen (Applikationen). (c t 1... t ar(c) ) sind Konstruktor-Anwendungen. (case T e of Alts) sind case-ausdrücke (Fallunterscheidungen). Einführung in die funktionale Programmierung; Folien Kap
9 Beispiele und Kodierungen \x -> x ist die Identitätsfunktion. if A then B else C ist darstellbar durch: (case Bool A of {True -> B; False -> C}) Einführung in die funktionale Programmierung; Folien Kap
10 Beispiele und Kodierungen Sei Paar zweistelliger Konstruktor. (Paar True 1) ist ein Objekt zu Paar. Die Selektoren zu Paar sind definierbar: \x -> (case_paar x of (Paar y1 y2) -> y1) \x -> (case_paar x of (Paar y1 y2) -> y2) Tupel sind vordefiniert in Haskell: Schreibweise ist (x, y, z). Einführung in die funktionale Programmierung; Folien Kap
11 Programm zu Paaren Hat das Paar p als erstes Element ein False? wird implementiert durch: (case_paar p of {Paar x y -> (case_bool x of {True -> False; False -> True})}) Einführung in die funktionale Programmierung; Folien Kap
12 Listen Die Liste [True, False] ist darstellbar in KFPT als Cons True (Cons False Nil) In Haskell sind Listen bereits vorhanden Einführung in die funktionale Programmierung; Folien Kap
13 Zwei Abkürzungen Id K für die identische Abbildung für den konstanten Kombinator: Id ::= \x -> x (Lambda-Notation: λx.x) K x y ::= \x -> (\y-> x) (Lambda-Notation: λx.(λy.x)) Einführung in die funktionale Programmierung; Folien Kap
14 Ein nichtterminierender Ausdruck bot := (λx.(x x)) (λy.(y y)) wir werden später sehen, dass die Auswertung dieses Ausdrucks nicht terminiert. Einführung in die funktionale Programmierung; Folien Kap
15 Freie und gebundene Variablen Die Bindungsregeln in KFPT sind: In λx. e ist x eine gebundene Variable, der Gültigkeitsbereich (Skopus) ist e. In der case-alternative c x 1... x n -> e bindet das Pattern alle Variablen x i. der Gültigkeitsbereich (Skopus) ist e. Vorkommen von Variablen, die in keinem Gültigkeitsbereich einer Bindung stehen, sind frei. Bei Konflikten gilt die Regel: der innerste Bindungsbereich zählt Beispiel (λx. (y x)) Einführung in die funktionale Programmierung; Folien Kap
16 Freie und gebundene Variablen verschiedene Vorkommen können zu verschiedenen Bindungen gehören: Beispiel λx. (x (λx. x)) Sichtbar durch Indizes bzw. Umbenennung λx 1. (x 1 (λx 2. x 2 )) Ausdrücke die bis auf Umbenennung gleich sind, nennt man auch α-äquivalent Genauer: durch ein Folge von Umbenennungen ineinander überführt werden können, Einführung in die funktionale Programmierung; Folien Kap
17 Freie und gebundene Variablen Ein Ausdruck ohne freie Variablen heißt geschlossener Ausdruck sonst offener Ausdruck. Ein KFPT-Programm ist definiert als ein geschlossener Ausdruck Einführung in die funktionale Programmierung; Folien Kap
18 Freie und gebundene Variablen. Beispiele \x -> (case_list x of {Cons y ys -> ys; Nil -> Nil}) ist ein geschlossener Ausdruck. Die Variable x ist frei im Unterausdruck case_list x of {Cons y ys -> ys; Nil -> Nil} Einführung in die funktionale Programmierung; Folien Kap
19 Auswertungsregeln; operationale Semantik operationale Semantik: Transformationssystem auf den Ausdrücken deterministisch Bei erfolgreichem Terminieren: Der letzte Ausdruck ist der Wert Einführung in die funktionale Programmierung; Folien Kap
20 Operationale Semantik: Wert Ein Wert in KFPT bzw. eine WHNF (weak head normal form, schwache Kopfnormalform) ist ein Ausdruck der Form (c t 1... t n ), wobei n = arity(c) und c ein Konstruktor ist, oder eine Abstraktion: λx. e. Eine WHNF kann sein: FWHNF, wenn die WHNF eine Abstraktion ist, oder CWHNF, wenn die WHNF eine Konstruktoranwendung der Form (c s 1... s n ) ist. Einführung in die funktionale Programmierung; Folien Kap
21 Ersetzungen in Ausdrücken s[t/x] Im Ausdruck s werden die freien Vorkommen der Variablen x durch t ersetzt. Zu Beachten: kein Einfangen von freien Variablen! Ausreichend: In s gebundene Variablen sind von den freien Variablen in t verschieden Wenn nicht, dann s umbenennen. Einführung in die funktionale Programmierung; Folien Kap
22 Umbenennung Abstraktion : λx.e: λz.e[z/x]: z sei bisher nicht verwendete Variable. In e ersetze alle freien Vorkommen von x durch z. case-alternative: c x 1... x n -> e c z 1... z n -> e[z 1 /x 1,... z n /x n ] ersetze x i durch neue Variablen z i, i = 1,..., n In e ersetze alle freien Vorkommen von x i durch z i : Einführung in die funktionale Programmierung; Folien Kap
23 Beispiel: Einfangen von Variablen Was ist die richtige Ersetzung in (λx.λy.(x z))[y/z]? falsch: richtig: (λx.λy.(x y)). (λx.λu.(x y)). mit Umbenennung: (λx.λy.(x z))[y/z] (λx.λu.(x z))[y/z] (λx.λu.(x y)) Einführung in die funktionale Programmierung; Folien Kap
24 Auswertungsregeln Auswertungsregeln (Reduktionsregeln): Beta Case ((λx.t) s) t[s/x] (case T (c t 1... t n ) of {... ; c x 1... x n -> s;...}) s[t 1 /x 1,..., t n /x n ] Zunächst darf man diese überall verwenden: in allen Programmkontexten Redex (reducible expression) nennt man den Unterausdruck s, der unmittelbar reduziert wird. Einführung in die funktionale Programmierung; Folien Kap
25 Beispiele (λx.(λy.x (y x))) (λz.z) (λy.(λz.z) (y (λz.z ))) (case List (Cons 1 (Cons 2 Nil)) {Cons y ys -> ys; Nil -> Nil}) (Cons 2 Nil) Einführung in die funktionale Programmierung; Folien Kap
26 Auswertungsregeln Die Anwendung der Auswertungsregeln ist noch nicht eindeutig: (λx.x)((λy.y)z) hat zwei Reduktionsmöglichkeiten. Ziel: die richtige deterministischen Auswertung Einführung in die funktionale Programmierung; Folien Kap
27 Reduktionskontexte Definition Reduktionskontexte: R ::= [] (R e) (case T R of {p 1 -> t 1 ;... ; p n -> t n }) Beobachtung: das Loch eines Reduktionskontextes ist: nicht in Abstraktionen nicht in einer Konstruktor-Anwendung nicht im Argument einer Anwendung. nicht in case-alternativen. Ê Einführung in die funktionale Programmierung; Folien Kap
28 Normalordnungs-Reduktion Normalordnungs-Reduktion (normal-order-reduktion): Der Ausdruck in einem Reduktionskontext wird reduziert: R[s] R[t] Ein-Schritt-Normalordnungsreduktion R ein Reduktionskontext, s keine WHNF und s reduziert unmittelbar zu t Der Unterterm s zusammen mit seiner Position ist der Normalordnungsredex Einführung in die funktionale Programmierung; Folien Kap
29 Normalordnungs-Reduktion Bezeichnungen n n,+ bzw.. n, n, eine Normalordnungsreduktion. die transitive und reflexiv-transitive Hülle von n ist die Normalordnungsrelation oder Auswertung eines Terms. Einführung in die funktionale Programmierung; Folien Kap
30 Terminierung Sei t geschlossener Term. Wenn ein t existiert mit t n, t und t ist WHNF, dann: t terminiert (auch: konvergiert) Bezeichnung: t. Wenn nicht, dann: t divergiert Bezeichnung: t. Einführung in die funktionale Programmierung; Folien Kap
31 Auswertungen Wenn t, sagen wir auch: hat eine WHNF. Es gilt: Aber: Wenn t n, t und t ist WHNF, dann ist t eindeutig t t und t ist WHNF, kann für viele verschiedene t gelten. Beispiel (cons ((λx.x) True)) Nil) ist WHNF, aber reduziert zu (cons True Nil) (das ist keine Normalordnung.) Einführung in die funktionale Programmierung; Folien Kap
32 Beispiel zur Normalordnung (λx.x)((λy.y)z) hat zwei Reduktionsmöglichkeiten, aber nur eine Normalordnungsreduktion: (λx.x)((λy.y)z) n ((λy.y)z). Der Reduktionskontext R ist: ([ ] ((λy.y)z)) Einführung in die funktionale Programmierung; Folien Kap
33 Beispiele zur Auswertung ((λx.x) Nil) n Nil ((λx.λy.x) s t) n ((λy.s) t) n s. Einführung in die funktionale Programmierung; Folien Kap
34 Eigenschaften der Normalordnung Lemma Jede unmittelbare Reduktion in einem Reduktionskontext ist eine Normalordnungsreduktion. Der Normalordnungsredex und die Normalordnungsreduktion sind eindeutig. Eine WHNF hat keinen Normalordnungsredex und erlaubt keine Normalordnungsreduktion. Einführung in die funktionale Programmierung; Folien Kap
35 Plotkins Sichtweise Gordon Plotkin: Eine Programmiersprache hat vier wichtige Komponenten: Ausdrücke Kontexte Werte eine Auswertungsrelation auf Ausdrücken. Das definiert dann u.a. t. Die Theorie der korrekten Transformationen kann man darauf aufbauen: s, t sind gleich, wenn für alle Kontexte C: C[s] C[t] (siehe zweite Semesterhälfte) Einführung in die funktionale Programmierung; Folien Kap
36 Dynamische Typregeln für KFPT Für case: (case T e of {alt 1 ;... ; alt m }) ist direkt dynamisch ungetypt wenn e eine der folgenden Formen hat: (c a 1... a arc ) und c ist ein Konstruktor, der nicht zum Typ T gehört, λx. t. für Konstruktoren: ((c a 1... a arc ) e) ist direkt dynamisch ungetypt. Einführung in die funktionale Programmierung; Folien Kap
37 Dynamische Typregeln für KFPT e ist dynamisch ungetypt, wenn e : e n, e und e ist direkt dynamisch ungetypt Einführung in die funktionale Programmierung; Folien Kap
38 Typisierung in KFPT Haskells Typisierung ist restriktiver als es tritt kein dynamischer Typfehler auf e ist wohlgetypt wenn e nicht dynamisch ungetypt ist. Einführung in die funktionale Programmierung; Folien Kap
39 Unwind Algorithmus zur Bestimmung des Normalordnungsredex: kann als Labelling-Regeln geschrieben werden: Sei R das Label: C[(s t) R ] C[(s R t)] C[(case s alts)] C[(case s R alts)] Start mit t R, Regel-Anwendung solange, bis keine Anwendung mehr möglich. Einführung in die funktionale Programmierung; Folien Kap
40 Unwind Danach die Normalordnungs-Reduktion: (falls möglich) Beta C[((λx.t) R s)] C[t[s/x]] Case C[(case T (c t 1... t n ) R of {... ; c x 1... x n -> s;...})] C[s[t 1 /x 1,..., t n /x n ]] wenn keine möglich ist, dann gibt es zwei Möglichkeiten: WHNF oder dynamischer Typfehler. WHNF: nur wenn R-Label sich nie bewegt hat. Einführung in die funktionale Programmierung; Folien Kap
41 Dynamisches Verhalten der Nortmalordnung Normalordnung reduziert den R-markierten Unterterme, bis diese in WHNF sind Dies ergibt einen rekursiven Auswertungsalgorithmus (leider einen ineffizienten, den man so nicht implementiert) Einführung in die funktionale Programmierung; Folien Kap
42 Beispiel: Auswertung bot := (λx.(x x)) (λy.(y y)) terminiert nicht: Die (beta)-reduktion ergibt: (λx.(x x)) (λy.(y y)) n ((λy.(y y)) (λy.(y y))) n... Einführung in die funktionale Programmierung; Folien Kap
43 Beispiel: Boolesche Funktionen aussagenlogische Verknüpfungen und, oder, nicht: und = λx. λy. case Bool x of {True-> y; False-> False} oder = λx. λy. case Bool x of {True-> True; False-> y} nicht = λx. case Bool x of {True-> False; False-> True} In Haskell sind die logischen Verknüpfungen bereits im Prelude definiert als &&,, not. Einführung in die funktionale Programmierung; Folien Kap
44 Syntax der funktionalen Kernsprache KFP Wir geben die Syntax von KFP hier zur Information schon mal an. Sie wird in der zweiten Semesterhälfte genauer besprochen KFP ist analog zu Kernsprachen von Compilern funktionaler Programmiersprachen. Einfache Syntax, möglichst wenig vordefiniert Einführung in die funktionale Programmierung; Folien Kap
45 Syntax der funktionalen Kernsprache KFP Syntax: von KFP: Es gibt N Konstruktoren c i, i = 1,..., N mit jeweils Stelligkeit ar(c i ) CFG für KFP-Ausdrücke: EXP ::= V V sind Variablen λv. EXP (EXP EXP ) (c EXP 1... EXP n ) wobei n = ar(c) (case EXP {P at 1 Exp 1 ;... ; P at N+1 Exp N+1 }) P at i ist Pattern zum Konstruktor i, und P at N+1 das Pattern lambda. Pat ::= (c V 1... V ar(c) ) lambda Einführung in die funktionale Programmierung; Folien Kap
46 KFP und KFPT KFP: Unterschied zu KFPT: KFP hat ein ungetyptes case-konstrukt Alle Konstruktoren im casehaben eine Alternative Abstraktionen haben auch eine Alternative zum Patternlambda Dadurch kann man seq in KFP definieren Einführung in die funktionale Programmierung; Folien Kap
47 Rekursive Superkombinatoren: KFPTS Wir erweitern KFPT um Haskells rekursive Superkombinatoren. Die Erweiterung nennen wir KFPTS Damit können wir in KFPTS wie in einem vereinfachten Haskell programmieren Einführung in die funktionale Programmierung; Folien Kap
48 KFPTS Syntax Ausdrücke wie in KFPT, nur um Superkombinatornamen erweitert. Es gibt Funktionsnamen (Superkombinatornamen) als neue Konstanten und eine Menge von Definitionen der Form Superkombinatorname V 1... V n = Exp Bedingungen: V 1... V n sind verschieden; In Exp lommen nur diese Variablen frei vor. Die Namensräume für Variablen, Konstruktoren, Kombinatornamen sind disjunkt. Jeder Superkombinator wird höchstens einmal definiert Als Zusatz eröffnet dies die Möglichkeit, rekursive Funktionen zu definieren, indem die Namen von Funktionen im Rumpf verwendet werden. Einführung in die funktionale Programmierung; Folien Kap
49 KFPTS-Programme Ein KFPTS-Programm besteht aus: 1. Einer Menge von Typen und Konstruktoren wie in KFPT, 2. einer Menge von Kombinator-Definitionen 3. und aus einem Ausdruck. definiert als main = Exp (main-konvention) Einführung in die funktionale Programmierung; Folien Kap
50 KFPTS-Auswertung Reduktionsregeln: Beta SK-Beta ((λx.t) s) t[s/x] (f a 1... a n ) r[a 1 /x 1,..., a n /x n ] wenn f definiert ist als: f x 1... x n = r d.h. wenn ar(f) = n Case (case T (c t 1... t n ) of {... ; c x 1... x n -> s;...}) s[t 1 /x 1,..., t n /x n ] wobei n = ar(c)und c ist T -Konstruktor Unterschied zu KFPT: SK-Beta reduziert nur bei ausreichend vielen Argumenten. Einführung in die funktionale Programmierung; Folien Kap
51 KFPTS-Normal-Ordnung Reduktionskontexte in KFPTS wie in KFPT Der Wert des Programms ist der Wert des main-ausdrucks nach Auswertung. KFPTS-Normalordnungsreduktion: innerhalb eines KFPTS-Reduktionskontexts wird unmittelbar mit Case, Beta oder SK-Beta reduziert. Neue Regel dazu: (SK R s 1... s ar(sk ) ) r SK [s 1 /V 1,..., s n /V n ] Einführung in die funktionale Programmierung; Folien Kap
52 KFPTS-WHNF Eine KFPTS-WHNF ist entweder ein Ausdruck (c t 1... t n ) ; oder ein Ausdruck (f t 1... t n ), wobei n < ar(f); oder ein Ausdruck λx.s Einführung in die funktionale Programmierung; Folien Kap
Einführung in Haskell
Kapitel 2 Einführung in Haskell Dieses Kapitel enthält eine Einführung in Haskell, eine nicht-strikte funktionale Programmiersprache mit polymorphem Typsystem. Ziel in diesem Kapitel ist: Darstellung der
MehrEinführung in Haskell
Kapitel 2 Einführung in Haskell Dieses Kapitel enthält eine Einführung in Haskell, eine nicht-strikte funktionale Programmiersprache mit polymorphem Typsystem. Ziel in diesem Kapitel ist: Darstellung der
MehrSemantik und Analyse von Funktionalen Programmen (SAFP):
Semantik und Analyse von Funktionalen Programmen (SAFP): KFPT mit Sharing und Striktheisanalyse: LR Prof. Dr. Manfred Schmidt-Schauß SAFP; WS 2014/15 Stand der Folien: 5. Februar 2015 LR: Syntax E ::=
MehrLR: Syntax. Semantik und Analyse von Funktionalen Programmen (SAFP): LR: Reduktions-Regeln. LR: Reduktions-Regeln
LR: Syntax Semantik und Analyse von Funktionalen Programmen (SAFP): KFPT mit Sharing und Striktheisanalyse: LR Prof. Dr. Manfred Schmidt-Schauß SAFP; WS 2014/15 E ::= V (c E 1... E ar(c) ) (seq E 1 E 2
MehrEinführung in Haskell
Kapitel 2 Einführung in Haskell Dieses Kapitel enthält eine Einführung in Haskell, eine nicht-strikte funktionale Programmiersprache mit polymorphem Typsystem. Ziel in diesem Kapitel ist: Darstellung der
MehrGrundlagen der Programmierung 2. Operationale Semantik
Grundlagen der Programmierung 2 Operationale Semantik Prof. Dr. Manfred Schmidt-Schauÿ Künstliche Intelligenz und Softwaretechnologie 29. April 2009 Semantik von Programmiersprachen Semantik = Bedeutung
MehrEinführung in die funktionale Programmierung
Einführung in die funktionale Programmierung Prof. Dr. Manfred Schmidt-Schauÿ Künstliche Intelligenz und Softwaretechnologie 26. Oktober 2006 Haskell - Einführung Syntax Typen Auswertung Programmierung
Mehr3 Exkurs: Der λ-kalkül
3 Exkurs: Der λ-kalkül Alonso Churchs λ-kalkül (ca. 1940) ist der formale Kern jeder funktionalen Programmiersprache. Der λ-kalkül ist eine einfache Sprache, mit nur wenigen syntaktischen Konstrukten und
MehrHaskell, Typen, und Typberechnung. Grundlagen der Programmierung 3 A. Überladung und Konversion in Haskell. 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 Sommersemester
MehrGrundlagen der Programmierung 3 A
Grundlagen der Programmierung 3 A Typen, Typberechnung und Typcheck Prof. Dr. Manfred Schmidt-Schauß Sommersemester 2017 Haskell, Typen, und Typberechnung Ziele: Haskells Typisierung Typisierungs-Regeln
MehrDer einfach getypter Lambda-Kalkül
Der einfach getypter Lambda-Kalkül Typprüfung und Typinferenz Tobias Nipkow und Steffen Smolka Technische Universität München 1 Einleitung 2 Explizit getypter λ-kalkül 3 Implizit getypter λ-kalkül Statische
MehrDer untypisierte Lambda-Kalkül als Programmiersprache
Der untypisierte Lambda-Kalkül als Programmiersprache November 29, 2006 betreut von Prof. Tobias Nipkow Einführung In den 1930er Jahren von Alonzo Church und Stephen Kleene eingeführt Der Lambda-Kalkül
MehrHaskell, 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
MehrFunktionale Programmierung ALP I. λ Kalkül WS 2012/2013. Prof. Dr. Margarita Esponda. Prof. Dr. Margarita Esponda
ALP I λ Kalkül WS 2012/2013 Berechenbarkeit - inspiriert durch Hilbert's Frage - im Jahr 1900, Paris - Internationaler Mathematikerkongress Gibt es ein System von Axiomen, aus denen alle Gesetze der Mathematik
MehrTheoretische Informatik II
Vorlesung Theoretische Informatik II Bernhard Beckert Institut für Informatik Wintersemester 2007/2008 B. Beckert Theoretischen Informatik II: WS 2007/08 1 / 179 Dank Diese Vorlesungsmaterialien basieren
MehrFunktionale Programmierung Einführung
Einführung Prof. Dr. Oliver Braun Fakultät für Informatik und Mathematik Hochschule München Letzte Änderung: 13.09.2017 15:29 Inhaltsverzeichnis Was ist imperative Programmierung.......................
MehrKontextuelle Gleichheit, Korrektheit, Programmtransformationen, Auswertungsänderung
Skript CEFP, WS 2013/14 Prof. Dr. Manfred Schmidt-Schauß Fachbereich Informatik Johann Wolfgang Goethe-Universität Postfach 11 19 32 D-60054 Frankfurt Germany E-mail:schauss@ki.informatik.uni-frankfurt.de
MehrWorkshop Einführung in die Sprache Haskell
Workshop Einführung in die Sprache Haskell Nils Rexin, Marcellus Siegburg und Alexander Bau Fakultät für Informatik, Mathematik und Naturwissenschaften Hochschule für Technik, Wirtschaft und Kultur Leipzig
MehrDer λ-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
MehrWas 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
MehrFunktionale Programmierung ALP I. λ Kalkül. Teil 2 WS 2012/2013. Prof. Dr. Margarita Esponda. Prof. Dr. Margarita Esponda
ALP I λ Kalkül Teil 2 WS 2012/2013 Lokale Variablennamen Haskell: let x = exp1 in exp2 Lambda: λ exp1. exp2 Einfache Regel: Der Geltungsbereich eines Lambda-Ausdrucks erstreckt sich soweit wie möglich
MehrGrundlagen der Programmierung 2 (2.A)
Grundlagen der Programmierung 2 (2.A) Prof. Dr. Manfred Schmidt-Schauß Künstliche Intelligenz und Softwaretechnologie 5. Mai 2011 Listen und Listenfunktionen Listen modellieren Folgen von gleichartigen,
MehrLösungen zum Aufgabenblatt 10 Logik und modelltheoretische Semantik
Lösungen zum Aufgabenblatt 10 Logik und modelltheoretische Semantik Universität München, CIS, SS 2013 Hans Leiß Abgabetermin: Do, 4.7.2013, 16 Uhr, in meinem Postfach Aufgabe 10.1 Vereinfache die folgenden
MehrEinführung in das λ-kalkül
Einführung in das λ-kalkül Max Wagner IPD Snelting 1 3.11.2017 Max Wagner - Einführung in das λ-kalkül IPD KIT Die Forschungsuniversität in der Helmholtz-Gemeinschaft www.kit.edu Syntax Abstrakte Syntax:
MehrListen und Listenfunktionen. Grundlagen der Programmierung 2 A (Listen) Listen und Listenfunktionen. Listen? Haskell: Listen
Listen und Listenfunktionen Grundlagen der Programmierung 2 A (Listen) Haskell: Listen Prof. Dr. Manfred Schmidt-Schauß Listen modellieren Folgen von gleichartigen, gleichgetypten Objekten. Ausdruck im
MehrAdressen. Praktikum Funktionale Programmierung Organisation und Überblick. Termine WWW
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
MehrPraktikum Funktionale Programmierung Organisation und Überblick
Praktikum Funktionale Programmierung Organisation und Überblick Dr. David Sabel Sommersemester 2013 Stand der Folien: SoSe 2013 Adressen Organisatorisches Software Projekt Adressen, Termine Studienleistung
MehrHaskell, Typen und Typberechnung
Kapitel 5 Haskell, Typen und Typberechnung 5.1 Typisierung in Haskell In diesem Kapitel sind die Typisierungsmethoden in Haskell beschrieben, wobei auch kurz auf die Typisierung in anderen Programmiersprachen
MehrHaskell, Typen und Typberechnung
Kapitel 5 Haskell, Typen und Typberechnung 5.1 Typisierung in Haskell In diesem Kapitel sind die Typisierungsmethoden in Haskell beschrieben, wobei auch kurz auf die Typisierung in anderen Programmiersprachen
MehrReduktionssysteme und Termersetzungssysteme
Reduktionssysteme und Termersetzungssysteme Untersuchung von Berechnungen mittels Reduktionsregeln Simplifikation von: Datenstrukturen / Termen usw. Erkennen von gleichen Objekten durch Normalisierung
MehrGrundlagen der Programmierung 2 (1.A)
Grundlagen der Programmierung 2 (1.A) Einführung Prof. Dr. Manfred Schmidt-Schauß Sommersemester 2015 Grundlagen der Programmierung 2 Geplanter Inhalt der ersten Hälfte: Programmieren in Haskell Definitionen;
MehrHaskell, Typen und Typberechnung
Kapitel 3 Haskell, Typen und Typberechnung 3.1 Typisierung in Haskell In diesem Kapitel sind die Typisierungsmethoden in Haskell beschrieben, wobei auch kurz auf die Typisierung in anderen Programmiersprachen
MehrDer untypisierte Lambda-Kalkül
Der untypisierte Lambda-Kalkül Der Lambda-Kalkül wurde zur Beschreibung des mathematischen Begriffs Funktion entwickelt. Die Menge aller Lambda-Ausdrücke Exp ist folgendermaßen definiert: x Exp wenn x
MehrDer untypisierte Lambda-Kalkül
Der untypisierte Lambda-Kalkül Fabian Immler 08.05.2008 1 Motivation und Einführung Der Lambda-Kalkül ist ein formales System zur Beschreibung von Funktionen, welches Funktionsdefinition sowie das Auswerten
MehrGrundlagen der Programmierung 2 A (Listen)
Grundlagen der Programmierung 2 A (Listen) Haskell: Listen Prof. Dr. Manfred Schmidt-Schauß Sommersemester 2017 Listen und Listenfunktionen Listen modellieren Folgen von gleichartigen, gleichgetypten Objekten.
MehrHaskell und Python. pures Programmieren, Auswerten von Ausdrücken rekursives Programmieren, Typsystem. Python: Eine prozedurale Programmiersprache
Haskell und Python Haskell: Eine funktionale Programmiersprache funktional, nicht-strikt, hat ein polymorphes und starkes Typsystem, flexible Datenstrukturen, gute Abstraktionseigenschaften, Ziele: pures
MehrInferenzmethoden. Einheit 18. Logik höherer Stufe
Inferenzmethoden Einheit 18 Logik höherer Stufe 1. Syntax und Semantik 2. Simulation mathematischer Konstrukte 3. Beweisführung in Logik höherer Stufe Logik höherer Stufe Logik erster Stufe hat nur einfache
MehrFunktionen und sprachliche Bedeutungen
Einführung in die Semantik,4. Sitzung Mehr zu Funktionen / Mengen, Relationen, Göttingen 1. November 2006 Mengen und sprachliche Bedeutungen Abstraktion und Konversion Rekursion Charakteristische Funktionen
Mehr1. Typen 1.1 Typsicherheit 1.2 Typprüfung
1. Typen 1.1 Typsicherheit 1.2 Typprüfung Ein Typsystem ist ein praktikables, syntaktisches Verfahren, mit dem man die Abwesenheit gewisser Laufzeit-Eigenschaften eines Programms beweisen kann, indem man
MehrLambda-Kalkül. Philipp Meyer. 28. April 2009
Lambda-Kalkül Philipp Meyer 28. April 2009 1 Einleitung Der λ-kalkül ist eine von Alonzo Church und Stephen Kleene in den 1930er Jahren eingeführtes Modell zur Beschreibung berechenbarer Funktionen. Es
MehrSemantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence
Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence David Sabel Institut für Informatik Fachbereich Informatik und Mathematik Goethe-Universität Frankfurt Kolloquium
MehrBerechnungsschemata: Funktion als Parameter abstrahiert Operation im Schema, wird bei Aufruf des Schemas konkretisiert
6. Funktionen als Daten, Übersicht Orthogonales Typsystem: Funktionen sind beliebig mit anderen Typen kombinierbar Notation für Funktionswerte (Lambda-Ausdruck): fn (z,k) => z*k Datenstrukturen mit Funktionen
MehrGrundlagen der Programmierung 2 (1.B)
Grundlagen der Programmierung 2 (1.B) Prof. Dr. Manfred Schmidt-Schauß Künstliche Intelligenz und Softwaretechnologie 27. April 2012 Beispiel: Aufrufhierarchie quadrat x = x*x quadratsumme x y = (quadrat
MehrGrundlagen der Programmierung 2 (1.B)
Grundlagen der Programmierung 2 (1.B) Prof. Dr. Manfred Schmidt-Schauß Künstliche Intelligenz und Softwaretechnologie 20. April 2011 Aufrufhierarchie und Rekursive Definitionen f, g, f i seien Haskell-definierte
MehrAdressen. 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
MehrFunktionale Programmierung - Grundlagen -
Funktionale Programmierung - Grundlagen - λ Logische und funktionale Programmierung - Universität Potsdam - M. Thomas - Funkt. Programmierung Gundlagen - IX.1 λ-ausdrücke 1) Variablen: x, y, z,...v,v 1,...
MehrKapitel 5: λ-kalkül und Laziness
Funktionale Programmierung (WS2005/2006) 5/1 Kapitel 5: λ-kalkül und Laziness Lernziele dieses Kapitels 1. Syntax des einfachen, ungetypten λ-kalküls Symbolische Manipulation von λ-ausdrücken in Haskell,
MehrFunktionale 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
Mehr3 Terme und Algebren 3.1 Terme
3 Terme und Algebren 3.1 Terme Mod - 3.1 In allen formalen Kalkülen benutzt man Formeln als Ausdrucksmittel. Hier betrachten wir nur ihre Struktur - nicht ihre Bedeutung. Wir nennen sie Terme. Terme bestehen
MehrEntwicklung eines korrekten Übersetzers
Entwicklung eines korrekten Übersetzers für eine funktionale Programmiersprache im Theorembeweiser Coq Thomas Strathmann 14.01.2011 Gliederung 1 Einleitung
MehrEinführung IMP-Syntax Reduktionssemantik Maschinen-Semantik. Teil IV. Semantik imperativer Sprachen
Teil IV Semantik imperativer Sprachen 201 1. Einführung Alternativen zur Beschreibung der Semantik: natürliche Sprache (bisher, unpräzise) operational Reduktionssemantik (vgl. Haskell-Semantik in Kap.
MehrVerarbeitung unendlicher Datenstrukturen Jetzt können wir z.b. die unendliche Liste aller geraden Zahlen oder aller Quadratzahlen berechnen:
Verarbeitung unendlicher Datenstrukturen Jetzt können wir z.b. die unendliche Liste aller geraden Zahlen oder aller Quadratzahlen berechnen: take 1 0 ( f i l t e r ( fn x => x mod 2=0) nat ) ; val it =
MehrKonzepte von Programmiersprachen
Konzepte von Programmiersprachen Kapitel 3: Ausdrücke Phillip Heidegger Universität Freiburg, Deutschland SS 2009 Phillip Heidegger (Univ. Freiburg) Konzepte von Programmiersprachen KvP 1 / 17 Inhalt Let
MehrKapitel 6: Typprüfung
Ludwig Maximilians Universität München Institut für Informatik Lehr- und Forschungseinheit für Datenbanksysteme Skript zur Vorlesung Informatik I Wintersemester 2006 Vorlesung: Prof. Dr. Christian Böhm
MehrPCF und denotationale Semantik
Kapitel 3 PCF und denotationale Semantik In diesem Kapitel soll ein Beispiel für eine denotationale Semantik vorgestellt und eingehend untersucht werden, die auf eine funktionale Programmiersprache mit
MehrTag 3. Funktionen. Num erfüllen, haben wir... ja, was nun eigentlich? Bei
Tag 3 Funktionen Heute werden wir den wichtigsten Typ (oder die wichtigste Klasse von Typen) in Haskell überhaupt genau unter die Lupe nehmen: Funktionen, die wir ansatzweise schon am letzten Tag kennengelernt
MehrEinführung in Haskell
Einführung in Haskell Axel Stronzik 21. April 2008 1 / 43 Inhaltsverzeichnis 1 Allgemeines 2 / 43 Inhaltsverzeichnis 1 Allgemeines 2 Funktions- und Typdefinitionen 2 / 43 Inhaltsverzeichnis 1 Allgemeines
MehrAbschnitt 3: Mathematische Grundlagen
Abschnitt 3: Mathematische Grundlagen 3. Mathematische Grundlagen 3.1 3.2 Induktion und Rekursion 3.3 Boolsche Algebra Peer Kröger (LMU München) Einführung in die Programmierung WS 14/15 48 / 155 Überblick
Mehr1 Formale Sprachen, reguläre und kontextfreie Grammatiken
Praktische Informatik 1, WS 2001/02, reguläre Ausdrücke und kontextfreie Grammatiken 1 1 Formale Sprachen, reguläre und kontextfreie Grammatiken Ein Alphabet A ist eine endliche Menge von Zeichen. Die
MehrGliederung. Funktionale Programmierung. Pattern matching in Haskell. Pattern matching in ERLANG. Materialien zur Vorlesung
Gliederung Funktionale Programmierung Materialien zur Vorlesung D. Rösner Institut für Wissens- und Sprachverarbeitung Fakultät für Informatik Otto-von-Guericke Universität Magdeburg 1 Sommer 2011, 7.
MehrFunktionale Programmierung. Das Funktionale Quiz. Das Funktionale Quiz. Das Funktionale Quiz
Funktionale Programmierung Das Funktionale Quiz 31.5.2005 Nenne eine Gemeinsamkeit zwischen Typklassen und OO-Klassen Das Funktionale Quiz Das Funktionale Quiz Nenne einen Unterschied zwischen Typklassen
Mehr5 BINÄRE ENTSCHEIDUNGS- DIAGRAMME (BDDS)
5 BINÄRE ENTSCHEIDUNGS- DIAGRAMME (BDDS) Sommersemester 2009 Dr. Carsten Sinz, Universität Karlsruhe Datenstruktur BDD 2 1986 von R. Bryant vorgeschlagen zur Darstellung von aussagenlogischen Formeln (genauer:
MehrImperative und funktionale Sprachen
Imperative und funktionale Sprachen Merkmale imperativer Sprachen: Konzepte: Variablen, Zuweisungen, Sequentialität Programm-Semantik spiegelt Rechnerarchitektur wider Schleifen spielen eine große Rolle
MehrDer untypisierte Lambda-Kalkül als Programmiersprache
Proseminar: Programmiersprachen bei Prof. Tobias Nipkow Der untypisierte Lambda-Kalkül als Programmiersprache von Benjamin Peherstorfer betreut von Prof. Tobias Nipkow 23. November 2006 Inhaltsverzeichnis
Mehr2.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
MehrLösung Probeklausur Informatik I
Lösung Probeklausur Informatik I 1 Lösung Aufgabe 1 (5 Punkte) Algorithmen und Programme Was ist der Unterschied zwischen einem Algorithmus und einem Programm? Ein Algorithmus ist eine Vorschrift zur Durchführung
MehrFunktionale Programmierung Grundlegende Datentypen
Grundlegende Datentypen Prof. Dr. Oliver Braun Fakultät für Informatik und Mathematik Hochschule München Letzte Änderung: 06.11.2017 16:45 Inhaltsverzeichnis Typen........................................
MehrWS 2013/2014. Robert Giegerich. 11. Dezember 2013
WS 2013/2014 Robert AG Praktische Informatik 11. Dezember 2013 höherer Ordnung Worum geht es heute? In Haskell gibt es, die als Argument haben oder als Ergebnis liefern. Diese nennt man höherer Ordnung.
MehrKlammersprache Definiere
Klammersprache w=w 1...w n {(,)}* heißt korrekt geklammert, falls die Anzahl ( ist gleich der Anzahl ). in jedem Anfangsstück w 1,...,w i (i n) ist die Anzahl ( nicht kleiner als die Anzahl ). Definiere
MehrReduktion. 2.1 Abstrakte Reduktion
2 Reduktion In diesem Kapitel studieren wir abstrakte Eigenschaften von Regeln. In den ersten beiden Abschnitten betrachten wir nicht einmal die Regeln selbst, sondern nur abstrakte Reduktionssysteme,
MehrVor(schau)kurs für Studienanfänger Mathematik: Aussagen und Mengen
Vor(schau)kurs für Studienanfänger Mathematik: Aussagen und Mengen 09.10.2014 Herzlich Willkommen zum 2. Teil des Vorschaukurses für Mathematik! Organisatorisches Der Vorkurs besteht aus sechs Blöcken
MehrLambda-Kalkül. Dr. Eva Richter. 27.April 2012
Lambda-Kalkül Dr. Eva Richter 27.April 2012 1 / 32 Historisches um 1200 Einführung des Zahlensystems in Europa u.a. durch Fibonacci; ist charakterisiert durch ein kleine Menge von Ziffern, deren Wert von
MehrInterpreter - 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
MehrLazy Pattern Matching. 10. Dezember 2014
Lazy Lazy s Universität Bielefeld AG Praktische Informatik 10. Dezember 2014 Themen-Vorschau : as-s und lazy s Client-Server-Programmierung Lazy s matching (alias Mustervergleich) kennen wir bereits aus
MehrAussagenlogik. Übersicht: 1 Teil 1: Syntax und Semantik. 2 Teil 2: Modellierung und Beweise. Aussagenlogik H. Kleine Büning 1/25
Aussagenlogik Übersicht: 1 Teil 1: Syntax und Semantik 2 Teil 2: Modellierung und Beweise Aussagenlogik H. Kleine Büning 1/25 Einführendes Beispiel Falls Lisa Peter trifft, dann trifft Lisa auch Gregor.
MehrEinführung in die Funktionale Programmierung
Einführung in die Funktionale Programmierung Wintersemester 2010/11 Dr. David Sabel Institut für Informatik Fachbereich Informatik und Mathematik Goethe-Universität Frankfurt am Main Postfach 11 19 32
MehrPraktische Informatik 3: Funktionale Programmierung Vorlesung 4 vom : Typvariablen und Polymorphie
Rev. 2749 1 [28] Praktische Informatik 3: Funktionale Programmierung Vorlesung 4 vom 04.11.2014: Typvariablen und Polymorphie Christoph Lüth Universität Bremen Wintersemester 2014/15 2 [28] Fahrplan Teil
Mehr4.4 Imperative Algorithmen Prozeduren
4.4.2 Prozeduren Der Wert eines Ausdrucks u in Zustand z Z lässt sich damit auch leicht definieren (jetzt W Z statt W σ ) Dazu erweitern wir die rekursive Definition von Folie 57 (Wert eines Ausdrucks):
MehrGTI. Hannes Diener. 18. Juni. ENC B-0123,
GTI Hannes Diener ENC B-0123, diener@math.uni-siegen.de 18. Juni 1 / 32 Als Literatur zu diesem Thema empfiehlt sich das Buch Theoretische Informatik kurzgefasst von Uwe Schöning (mittlerweile in der 5.
MehrEinführung in die Logik
Einführung in die Logik Klaus Madlener und Roland Meyer 24. April 2013 Inhaltsverzeichnis 1 Aussagenlogik 1 1.1 Syntax................................. 1 1.2 Semantik............................... 3 1.3
MehrKapitel 2. Mathematische Grundlagen. Skript zur Vorlesung Einführung in die Programmierung
LUDWIG- MAXIMILIANS- UNIVERSITY MUNICH DEPARTMENT INSTITUTE FOR INFORMATICS DATABASE Kapitel 2 Mathematische Grundlagen Skript zur Vorlesung Einführung in die Programmierung im Wintersemester 2012/13 Ludwig-Maximilians-Universität
MehrFormale Methoden der Softwaretechnik 1 Vorlesung vom : Grundlage von Isabelle
1 Formale Methoden der Softwaretechnik 1 Vorlesung vom 16.11.09: Grundlage von Isabelle Christoph Lüth, Lutz Schröder Universität Bremen Wintersemester 2009/10 2 Fahrplan Teil I: Grundlagen der Formalen
MehrDie Komplement-Funktion
Die Komplement-Funktion type IntMap α = [(Int, α)] compl :: [α] (Int, IntMap α) compl s = let n = (length s) 1 t = [0..n] g = zip t s g = filter (λ(i, _) notelem i (get t)) g in (n + 1, g ) Zum Beispiel:
MehrEinführung in die Theoretische Informatik
Einführung in die Theoretische Informatik Woche 4 Harald Zankl Institut für Informatik @ UIBK Wintersemester 2014/2015 Zusammenfassung Zusammenfassung der letzten LV Modus Ponens A B B A MP Axiome für
MehrOperationen auf Grammatiken
Operationen auf Grammatiken Ziel: Normalisierungen, Vereinfachungen, Elimination bestimmter Konstrukte Erzeugen eines Parsers Transformation G 1 G 2 mit L(G 1 ) = L(G 2 ) I.a. Parsebaum 1 (w) Parsebaum
MehrBerechenbarkeit und Komplexität Vorlesung 11
Berechenbarkeit und Komplexität Vorlesung 11 Prof. Dr. Wolfgang Thomas Lehrstuhl Informatik 7 RWTH Aachen 7. Dezember 2014 Wolfgang Thomas, Informatik 7 () Vorlesung Berechenbarkeit und Komplexität 7.
MehrGrammatiken. Eine Grammatik G mit Alphabet Σ besteht aus: Variablen V. Startsymbol S V. Kurzschreibweise G = (V, Σ, P, S)
Grammatiken Eine Grammatik G mit Alphabet Σ besteht aus: Variablen V Startsymbol S V Produktionen P ( (V Σ) \ Σ ) (V Σ) Kurzschreibweise G = (V, Σ, P, S) Schreibweise für Produktion (α, β) P: α β 67 /
MehrOperationale Semantik 1
Operationae Semantik 1 Side 1 Zie: Geschossene Terme t ι ι sind Programme, die auf Eingabe n die Ausgabe [t] n erzeugen. Ein-/Ausgabekonvention: Eingaben und Ausgaben sind Numerae! Def. Ein Numera ist
MehrUniversität Hannover Fakultät für Elektrotechnik und Informatik Institut für Theoretische Informatik. Thema: von. Paul Krüger
1 Universität Hannover Fakultät für Elektrotechnik und Informatik Institut für Theoretische Informatik Thema: - Kalkül von Paul Krüger Betreuer: Prof. Dr. Heribert Vollmer Das Rahmenthema ist " Berechenbarkeit
MehrNichtklassische Logiken
Nichtklassische Logiken Peter H. Schmitt pschmitt@ira.uka.de UNIVERSITÄT KARLSRUHE Sommersemester 2004 P. H. Schmitt: Nichtklassische Logiken p.1 Inhalt Wiederholung P. H. Schmitt: Nichtklassische Logiken
MehrWieviel Vorfahren? Grundlagen der Programmierung 2. Beispiel: Aufrufhierarchie. Aufrufhierarchie und Rekursive Definitionen. Haskell: Auswertung
Wieviel Vorfahren? Grundlagen der Programmierung 2 Haskell: Auswertung Prof. Dr. Manfred Schmidt-Schauß Sommersemester 2017..................... Oma-M Opa-M Oma-V Opa-V Mutter ich Vater Aufgabe: Wieviele
MehrBeispiele: (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))
MehrLogik I. Symbole, Terme, Formeln
Logik I Symbole, Terme, Formeln Wie jede geschriebene Sprache basiert die Prädikatenlogik erster Stufe auf einem Alphabet, welches aus den folgenden Symbolen besteht: (a) Variabeln wie zum Beispiel v 0,v
MehrKapitel 5. Mathematische Semantik. 1 Motivation
Kapitel 5 Mathematische Semantik In diesem Kapitel werden wir nun eine weitere Technik zur Definition der Semantik einer Programmiersprache vorstellen: die mathematische bzw. denotationale Semantik. Außerdem
MehrVorsicht 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
MehrSoftware Entwicklung 1
Software Entwicklung 1 Annette Bieniusa AG Softech FB Informatik TU Kaiserslautern Überblick für heute Programmierparadigmen Imperative vs. deklarative Programmierung Beispiele Funktionale Programmierung
MehrEinführung in die Theoretische Informatik. Inhalte der Lehrveranstaltung. Definition (Boolesche Algebra) Einführung in die Logik
Zusammenfassung Einführung in die Theoretische Informatik Woche 5 Harald Zankl Institut für Informatik @ UIBK Wintersemester 2014/2015 Zusammenfassung der letzten LV Jede binäre Operation hat maximal ein
MehrEinfache 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
MehrProgrammierparadigmen
in Haskell Programmierparadigmen in Haskell D. Rösner Institut für Wissens- und Sprachverarbeitung Fakultät für Informatik Otto-von-Guericke Universität Magdeburg Sommer 2011, 4. April 2011, c 2011 D.Rösner
Mehr