LR: Syntax. Semantik und Analyse von Funktionalen Programmen (SAFP): LR: Reduktions-Regeln. LR: Reduktions-Regeln
|
|
- Artur Dunkle
- vor 6 Jahren
- Abrufe
Transkript
1 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 ) (case T E Alt 1... Alt T ) (E 1 E 2 ) (λ V.E) (letrec V 1 = E 1,..., V n = E n in E) Alt ::= (P at E) P at ::= (c V 1... V ar(c) ) Definition: Ein Wert (bzw Value) ist Eine Abstraktion Ein Konstruktor-Anwendung (zb (Cons s t)) Stand der Folien: 5. Februar 2015 EFP KFPT mit Sharing und Striktheisanalyse: LR SAFP; WS 2014/15 M. Schmidt-Schauß 2/35 LR: Reduktions-Regeln LR: Reduktions-Regeln (lbeta) C[((λx.s) S r) C[(letrec x = r in s)] (cp-in) (letrec x 1 = v S, {x i = x i 1 } m i=2, Env in C[xV m]) (letrec x 1 = v, {x i = x i 1 } m i=2, Env in C[v]) wobei v eine Abstraktion (cp-e) (letrec x 1 = v S, {x i = x i 1 } m i=2, Env, y = C[xV m] in r) (letrec x 1 = v, {x i = x i 1 } m i=2, Env, y = C[v] in r) wobei v eine Abstraktion (llet-in) (letrec Env 1 in (letrec Env 2 in r) S ) (letrec Env 1, Env 2 in r) (llet-e) (letrec Env 1, x = (letrec Env 2 in s x ) S in r) (letrec Env 1, Env 2, x = s x in r) (lapp) C[((letrec Env in t) S s)] C[(letrec Env in (t s))] (lcase) C[(case T (letrec Env in t) S alts)] C[(letrec Env in (case T t alts))] (seq-c) C[(seq v S t)] C[t] wenn v ein Value (seq-in) (letrec x 1 = v S, {x i = x i 1 } m i=2, Env in C[(seq xv m t)]) (letrec x 1 = v, {x i = x i 1 } m i=2, Env in C[t]) wennvein Value (seq-e) (letrec x 1 = v S, {x i = x i 1 } m i=2, Env, y = C[(seq xv m t)] in r) (letrec x 1 = v, {x i = x i 1 } m i=2, Env, y = C[t] in r) wenn v ein Value (lseq) C[(seq (letrec Env in s) S t)] C[(letrec Env in (seq s t))] EFP KFPT mit Sharing und Striktheisanalyse: LR SAFP; WS 2014/15 M. Schmidt-Schauß 3/35 EFP KFPT mit Sharing und Striktheisanalyse: LR SAFP; WS 2014/15 M. Schmidt-Schauß 4/35
2 LR: Reduktions-Regeln LR: Reduktions-Regeln (case-c) C[(case T (c i t ) S... ((c i y ) t)...)] C[(letrec {y i = t i } n i=1 in t)] wobei n = ar(c i ) 1 (case-c) C[(case T c S i... (c i t)...)] C[t] wenn ar(c i ) = 0 (case-in) letrec x 1 = (c i t ) S, {x i = x i 1 } m i=2, Env in C[case T x V m... ((c i z )... t)...] letrec x 1 = (c i y ), {yi = t i } n i=1, {x i = x i 1 } m i=2, Env in C[(letrec {z i = y i } n i=1 in t)] wobei n = ar(c i ) 1 und y i frische Variablen (case-in) letrec x 1 = c S i, {x i = x i 1 } m i=2, Env in C[case T x V m... (c i t)...] letrec x 1 = c i, {x i = x i 1 } m i=2, Env in C[t] wenn ar(c i ) = 0 (case-e) letrec x 1 = (c i t ) S, {x i = x i 1 } m i=2, u = C[case T x V m... ((c i z ) r1 )... ], Env in r 2 letrec x 1 = (c i y ), {yi = t i } n i=1, {x i = x i 1 } m i=2, u = C[(letrec z 1 = y 1,..., z n = y n in r 1 )], Env in r 2 wobei n = ar(c i ) 1 und y i frische Variablen (case-e) letrec x 1 = c S i, {x i = x i 1 } m i=2, u = C[case T x V m... (c i r 1 )...], Env in r 2 letrec x 1 = c i, {x i = x i 1 } m i=2..., u = C[r 1], Env in r 2 wenn ar(c i ) = 0 EFP KFPT mit Sharing und Striktheisanalyse: LR SAFP; WS 2014/15 M. Schmidt-Schauß 5/35 EFP KFPT mit Sharing und Striktheisanalyse: LR SAFP; WS 2014/15 M. Schmidt-Schauß 6/35 Reduktionskontext: Normalordnungsredex-Suche Markierungs-Algorithmus; T = Top, S = Sub, V = Visited (letrec Env in t) T (letrec Env in t S ) V (s t) S T (s S t) V (seq s t) S T (seq s S t) V (case T s alts) S T (case T s S alts) V (letrec x = s, Env in C[x S ]) (letrec x = s S, Env in C[x V ]) (letrec x = s, y = C[x S ], Env in t) (letrec x = s S, y = C[x V ], Env in t) wenn C[x] x (letrec x = s, y = x S, Env in t) (letrec x = s S, y = x W, Env in t) C ist ein Reduktions-Kontext, wenn das Loch des Kontexts markiert wird mit obigen Algorithmus. C ist Surface-Kontext, wenn das Loch des Kontexts nicht innerhalb einer Abstraktion ist. Reduktionen: Gruppen Gruppen von Reduktionen: beta cp-reduktionen case-reduktionen Let-Verschiebungen Vergleich mit KFPT: Ohne Sharing LR (mit) Sharing beta lbeta cp-reduktionen case case-reduktionen Let-Verschiebungen EFP KFPT mit Sharing und Striktheisanalyse: LR SAFP; WS 2014/15 M. Schmidt-Schauß 7/35 EFP KFPT mit Sharing und Striktheisanalyse: LR SAFP; WS 2014/15 M. Schmidt-Schauß 8/35
3 WHNFs NO-Beispiel Normalordnungsreduktion von Ω = (λz.(z z)) (λx.(x x)): (λz.(z z)) (λx.(x x)) Definition Eine weak head normal form (WHNF) ist Ein Value v. Ein Ausdruck (letrec Env in v), wobei v ein Value Ein Ausdruck der Form (letrec x 1 = v, {x i = x i 1 } m i=2, Env in x m), wobei v = (c t ). n,lbeta (letrec z = λx.(x x) in (z z)) n,cp (letrec z = λx.(x x) in ((λx 1.(x 1 x 1 )) z)) n,lbeta (letrec z = λx.(x x) in (letrec x 1 = z in (x 1 x 1 ))) n,llet (letrec z = λx.(x x), x 1 = z in (x 1 x 1 )) LR-Reduktion: n,lcp (letrec z = λx.(x x), x 1 = z in ((λx 2.(x 2 x 2 )) x 1 )) n,lbeta letrec z = λx.(x x), x 1 = z in (letrec x 2 = x 1 in (x 2 x 2 ) n,llet letrec z = λx.(x x), x 1 = z, x 2 = x 1 in (x 2 x 2 ) EFP KFPT mit Sharing und Striktheisanalyse: LR SAFP; WS 2014/15 M. Schmidt-Schauß 9/35 EFP KFPT mit Sharing und Striktheisanalyse: LR SAFP; WS 2014/15 M. Schmidt-Schauß 10/35 Das Maß für let-reduktionen Das Maß µ lll (t) ist ein Paar (µ 1 (t), µ 2 (t)), lexikographisch geordnet. µ 1 (t) ist die Anzahl der letrec-unterausdrücke in t µ 2 (t) ist die Summe der lrdepth(c) aller letrec-unterausdrücke s von t wobei C definiert ist durch t = C[s], und wobei lrdepth so definiert ist: lrdepth([ ]) = { lrdepth(c lrdepth(c (1) [C []]) = []) wenn C (1) kein letrec lrdepth(c []) wenn C (1) ein letrec C (1) ist ein Kontext dessen Loch in Tiefe 1 ist. Lemma: Die let-reduktionen machen das Maß µ lll (.) echt kleiner. D.h. die (lll)-reduktion terminiert (mit einer lll-nf) Kontextuelle Ordnung und Gleichheit Definition Kontext Lemma s c t gdw C[ ] : C[s] = C[t] s c t gdw s c t t c s Seien s, t Ausdrücke. Wenn für alle Reduktions-Kontexte R: (R[s] = R[t] ), dann auch C : (C[s] = C[t] ); d.h. s c t. Beweis: mit Induktion (konzeptuell einfach wg. Sharing) EFP KFPT mit Sharing und Striktheisanalyse: LR SAFP; WS 2014/15 M. Schmidt-Schauß 11/35 EFP KFPT mit Sharing und Striktheisanalyse: LR SAFP; WS 2014/15 M. Schmidt-Schauß 12/35
4 Weitere Transformationen Weitere Transformationen (gc1) (letrec {x i = s i } n i=1, Env in t) (letrec Env in t) if for all i : x i does not occur in Env nor in t (gc2) (letrec {x i = s i } n i=1 in t) t if for all i : x i does not occur in t (cpx-in) (letrec x = y, Env in C[x]) (letrec x = y, Env in C[y]) wobeiy Variable undx y (cpx-e) (letrec x = y, z = C[x], Env in t) (letrec x = y, z = C[y], Env in t) (cpax) (letrec x = y, Env in s) (letrec x = y, Env[y/x] in s[y/x]) where y is a variable, x y and y FV (s, Env) (cpcx-in) (letrec x = c t, Env in C[x]) wobei y Variable und x y (letrec x = c y, {y i = t i } ar(c) i=1, Env in C[c y ]) (cpcx-e) (letrec x = c t, z = C[x], Env in t) (letrec x = c y, {y i = t i } ar(c) i=1, z = C[c y ], Env in t) (abs) (letrec x = c t, Env in s) (letrec x = c x, {x i = t i } ar(c) i=1, Env in s) wobei ar(c) 1 (abse) (c t ) (letrec {x i = t i } ar(c) i=1 in c x ) wobei ar(c) 1 (xch) (letrec x = t, y = x, Env in r) (letrec y = t, x = y, Env in r) (ucp1) (letrec Env, x = t in S[x]) (letrec Env in S[t]) (ucp2) (letrec Env, x = t, y = S[x] in r) (letrec Env, y = S[t] in r) (ucp3) (letrec x = t in S[x]) S[t] wobei in (ucp):, x hat höchstens eine Vorkommen in S[x] und kein Vorkommen in Env, t, r; und S ist Surface Kontext (lwas) W (1) [(letrec Env in s)] (letrec Env in W (1) [s]) wobei W (1) schwacher Applikations-Surface Kontext mit Lochtiefe 1 EFP KFPT mit Sharing und Striktheisanalyse: LR SAFP; WS 2014/15 M. Schmidt-Schauß 13/35 EFP KFPT mit Sharing und Striktheisanalyse: LR SAFP; WS 2014/15 M. Schmidt-Schauß 14/35 Weitere Transformationen Korrekheiten (cpcxnoa) (letrec x = c x 1... x m, Env in C[x]) (letrec x = c x 1... x m, Env in C[c x 1... x m ]) (case-cx) letrec x = (c T,j x 1... x n ), Env in C[case T x ((c T,j y 1... y n ) s) alts] letrec x = (c T,j x 1... x n ), Env in C[(letrec y 1 = x 1,..., y n = x n in s)] (case-cx) letrec x = (c T,j x 1... x n ), Env, y = C[case T x ((c T,j y 1... y n ) s) alts] in r letrec x = (c x 1... x n ), Env, y = C[(letrec y 1 = x 1,..., y n = x n in s)] in r (case-cx) like (case) in all other cases Satz Alle Reduktionen und Transformationen in LR sind korrekt: d.h. s trans t = s c t trans wobei eine Reduktion oder Transformation aus den Tabellen ist. Das hat die Konsequenz, dass die Konversionsgleichheit die LR kontextuelle Gleichheit impliziert: c. EFP KFPT mit Sharing und Striktheisanalyse: LR SAFP; WS 2014/15 M. Schmidt-Schauß 15/35 EFP KFPT mit Sharing und Striktheisanalyse: LR SAFP; WS 2014/15 M. Schmidt-Schauß 16/35
5 Längenmaße von Normalordnungsreduktionen Definition Sei t ein geschlossener Ausdruck. nor(t) ist definiert als die (maximale) Normalordnungsreduktion von t. Dann 1 Wenn M {case,lbeta,seq,cp,lll}, dann ist rl M (t) die Anzahl der Normalordnungs-Reduktionen a in nor(t) mit a M. 2 rl (t) := rl {case,lbeta,seq} (t). 3 rl (t) := rl {case,lbeta,seq,cp} (t). 4 rl (t) := rl {lll} (t). 5 rl(t) := rl {case,lbeta,seq,cp,lll} (t). Das wichtigste Maß ist rl ( ). Längenerhaltung (seq), (case), (cp) angewendet in Surface Kontexten werden notiert als (seqs), (cases), (cps). Zur Erinnerung: Surface Kontexte: Loch nicht in einer Abstraktion. EFP KFPT mit Sharing und Striktheisanalyse: LR SAFP; WS 2014/15 M. Schmidt-Schauß 17/35 EFP KFPT mit Sharing und Striktheisanalyse: LR SAFP; WS 2014/15 M. Schmidt-Schauß 18/35 Längenerhaltung Satz Seien t 1, s 1 geschlossene Ausdrücke mit t 1 und t 1 s 1 mit einer Basisreduktion oder einer Extra Transformation. Dann gilt s 1 und das folgende: 1 Wenn t 1 a s1 mit a {case, seq, lbeta, cp}, then rl(t 1 ) rl(s 1 ), rl (t 1 ) rl (s 1 ) and rl (t 1 ) rl (s 1 ). S,a 2 If t 1 s 1 with a {cases, seqs, lbeta, cps}, dann rl (t 1 ) rl (s 1 ) rl (t 1 ) 1 und rl (t 1 ) rl (s 1 ) rl (t 1 ) 1. Für a = cps, gilt die Gleichung rl (t 1 ) = rl (s 1 ). 3 Wenn t 1 a s1 mit a {lll, gc}, dann rl(t 1 ) rl(s 1 ), rl (t 1 ) = rl (s 1 ) and rl (t 1 ) = rl (s 1 ). Für a = gc1 gilt zusätzlich rl(t 1 ) = rl(s 1 ). 4 Wenn t 1 a s1 mit a {cpx, cpax, xch, cpcx, abs}, dann rl(t 1 ) = rl(s 1 ), rl (t 1 ) = rl (s 1 ) und rl (t 1 ) = rl (s 1 ). 5 Wenn t 1 ucp s 1, dann rl(t 1 ) rl(s 1 ), rl (t 1 ) rl (s 1 ) and rl (t 1 ) = rl (s 1 ). EFP KFPT mit Sharing und Striktheisanalyse: lwas LR SAFP; WS 2014/15 M. Schmidt-Schauß 19/35 6 Wenn t 1 s 1, dann rl (t 1 ) = rl (s 1 ). Längenerhaltung: Vergleich nicht-normalordnungs-reduktionen in Surface Kontexten, zb im Argument: Reduktion call-by-need (LR) call-by-name beta/lbeta -1 -n: unbeschränkt case -1 -n: unbeschränkt EFP KFPT mit Sharing und Striktheisanalyse: LR SAFP; WS 2014/15 M. Schmidt-Schauß 20/35
6 Tiefe Unterterme Abstrakte Reduktion Definition. Sei t = (letrec Env, x = t x, x 1 = t 1 in x 1 ). t x ist ein tiefer Unterterm in t wenn t 1 eine Anwendung, eine seq-ausdruck, oder ein case-ausdruck ist. Aussage Sei t 1 = (letrec Env, x = t x, x 1 = t 1 in x 1) geschlossen; und t 1, und t x sei strikter und tiefer Unterterm von t 1. Dann rl (t 1 ) > rl (letrec Env, x = t x in x). (letrec Env, x = t x in x) wirkt wie ein Unterterm von t 1. Basis-Reduktionen: Kalkül-Reduktionen Extra-Reduktionen Bot-Reduktionen Tableau geschlossen, wenn alle Blätter entweder sind, oder ein Vorgänger existiert, wobei (nach verschiedenen Kriterien) der Vorgänger das Blatt subsumiert oder einen Unterterm des Blatts; und eine Normalordnungsreduktion dazwischen, die das rl (.)-Maß kleiner macht. EFP KFPT mit Sharing und Striktheisanalyse: LR SAFP; WS 2014/15 M. Schmidt-Schauß 21/35 EFP KFPT mit Sharing und Striktheisanalyse: LR SAFP; WS 2014/15 M. Schmidt-Schauß 22/35 Bot-Reduktionen Änderungen der Reduktionsstrategie durch Striktheit Folgende Ausdrücke können in Tableau zu reduziert werden: ( t), (seq t), ((c t ) r), Ausdrücke die direkt ungetypt sind (unter Beachtung der Umgebung) (f t 1... t i 1 t i+1... t n ), wenn f strikt im i-ten Argument. und folgende Transformationen: (letrec x =, Env in C[x]) (letrec x =, Env in C[ ]) (letrec x =, Env, y = C[x] in t) (letrec x =, Env, y = C[ ] in t) (letrec x = x, Env in r) (letrec x =, Env in r) Statt Normalordnung: eine strikte Auswertung: In Surface Kontexten können strikte Unterterme ausgewertet werden. Die Reduktionslänge rl (.) ( bzgl (case), (lbeta), (seq)) bzgl. Normalordnung und strikter Strategie ist unverändert Bzgl der anderen Reduktionsarten: unklares Bild. D.h. ein Optimierungseffekt wird nur in der abstrakten Maschine sichtbar. denn die Reduktionslängen rl (.) sind durch Sharing schon optimal. EFP KFPT mit Sharing und Striktheisanalyse: LR SAFP; WS 2014/15 M. Schmidt-Schauß 23/35 EFP KFPT mit Sharing und Striktheisanalyse: LR SAFP; WS 2014/15 M. Schmidt-Schauß 24/35
7 Striktheits-Analyse: ein Beispiel Striktheits-Analyse: Beispiel lenr letrec len = λlst.lenr lst 0 lenr = λlst.λs. case lst lst (Nil s) (x : xs (letrec z = 1 + s in lenr xs z)) in... := { } Fun (c 1... )... (c N... ) wobei c 1,..., c N alle Konstruktoren sind. wobei Fun Menge aller geschlossenen Abstraktionen. Inf := { } ( : Inf ) lenr lbeta case lst (Nil ) (x : xs lenr xs ( + 1)) case lst (Nil ) (x : xs lenr xs ) case lst ( : ) (Nil ) (x : xs lenr xs ) case lenr case lst Nil... EFP KFPT mit Sharing und Striktheisanalyse: LR SAFP; WS 2014/15 M. Schmidt-Schauß 25/35 EFP KFPT mit Sharing und Striktheisanalyse: LR SAFP; WS 2014/15 M. Schmidt-Schauß 26/35 Striktheits-Analyse Beispiel Striktheits-Analyse: Beispiel zu Sharing lenr Inf lbeta case lst Inf (Nil ) (x : xs lenr xs ( + 1)) case lst ( : Inf ) (Nil ) (x : xs lenr xs ( + 1)) case lenr Inf ( + 1) generalize lenr Inf f = λx.λz.g x x z g = λx.λy.λz. if x then (if y then z else False) else (if y then False else z) Ist f strikt im zweiten Argument? : (letrec top =, f =, g = in f top ) Abstrakte Reduktion: (letrec top =, f =, g =,... in g top top ) Variable top kommt zweimal vor EFP KFPT mit Sharing und Striktheisanalyse: LR SAFP; WS 2014/15 M. Schmidt-Schauß 27/35 EFP KFPT mit Sharing und Striktheisanalyse: LR SAFP; WS 2014/15 M. Schmidt-Schauß 28/35
8 Striktheits-Analyse: Beispiel zu Sharing Striktheits-Analyse: Anmerkungen letrec top = in True -Fall: letrec top = in if top then (if top then else False) else (if top then False else ) if True then (if True then else False) else (if True then False else ) ergibt. Der False Fall und ungetypte Fälle gehen genauso. Todo: Auswirkungen auf Parallelisierung der Auswertung Todo: Nachweis, dass Auswertungsumstellung eine Optimierung in abstrakten Maschinen ist. Todo: Verbesserungen im Kalkül mit Sharing. Todo: Polymorphe Typen im Kalkül mit Sharing. Wie sieht Striktheitsanalyse aus in Concurrent Haskell? Andere Analyse-Verfahren können das nicht, da die Gleichheit der s verlorengeht. EFP KFPT mit Sharing und Striktheisanalyse: LR SAFP; WS 2014/15 M. Schmidt-Schauß 29/35 EFP KFPT mit Sharing und Striktheisanalyse: LR SAFP; WS 2014/15 M. Schmidt-Schauß 30/35 Polymorphes LR Type variables: a A set of type variables Term variables: x, x i X set of term variables Types: τ Typ := a (τ 1 τ 2 ) (K τ 1... τ ar(k) ) Polymorphic ρ PTyp := τ λa.ρ types: Expressions: e Expr F := x : ρ u (e τ) (e 1 e 2 ) (c : τ e 1... e ar(c) ) (seq e 1 e 2 ) letrec x 1 : ρ 1 = e 1,..., x n : ρ n = e n in e case K e of (p 1 -> e 1 )... (p n -> e n ) there is a pattern p for every constructor in D K Polymorphic u PExpr F := x : λa.ρ λx : τ.e (u τ) Λa.u expressions Case-patterns: p := (c : τ x 1 : τ 1... x ar(c) : τ ar(c) ) where x i are different term variables Polymorphes LR, Beispiele Der polymorphe K-Kombinator λx.λy.x sieht jetzt so aus: K := Λa.Λb.λx : a.λy : b.x Typisierung ergibt: λa.λb.a (b a). das ist genau analog zu: a, b : a (b a). Λa.Λb.... Das ist ein λ für Typen. Die Typinstanziierung wird mittels Reduktion modelliert. Nach der Kompilierung kann man das weglassen, da es nicht zum Ergebnis beiträgt und nicht abgefragt werden kann. EFP KFPT mit Sharing und Striktheisanalyse: LR SAFP; WS 2014/15 M. Schmidt-Schauß 31/35 EFP KFPT mit Sharing und Striktheisanalyse: LR SAFP; WS 2014/15 M. Schmidt-Schauß 32/35
9 Polymorphes LR Beispiel map Anwenden von K := Λa.Λb.λx : a.λy : b.x auf drei Argumente: Bool, eine Typvariable a, True vom Typ Bool Reduktion ergibt: (Λa.Λb.λx : a, λy : b.x) Bool a True (letrec x : Bool = True in λy : a.x) map (letrec map = λf.λxs.case xs of Nil Nil; (y : ys) f y : map f ys in map) polymorphic map in L F (letrec map:: λa.λb.(a b) (List a) (List b) = Λa.Λb.λf:: (a b).λxs:: (List a).case xs of Nil:: (List a) Nil :: (List b); (Cons:: a (List a) (List a) (y:: a) (ys:: List a)) Cons:: (List b) (f y) (map a b f ys) in map) EFP KFPT mit Sharing und Striktheisanalyse: LR SAFP; WS 2014/15 M. Schmidt-Schauß 33/35 EFP KFPT mit Sharing und Striktheisanalyse: LR SAFP; WS 2014/15 M. Schmidt-Schauß 34/35 Beispiel map Verwendung von map z.b. als Funktion von Int Int: (cp) des voll polymorphen map, dann Typinstanziierung durch Reduktion: (innerhalb des in-expressions): map Int Int λf:: (Int Int).λxs:: (List Int).case xs of Nil:: (List Int) Nil :: (List Int); (Cons:: Int (List Int) (List Int) (y:: Int) (ys:: List a)) Cons:: (List Int) (f y) (map Int Int f ys) EFP KFPT mit Sharing und Striktheisanalyse: LR SAFP; WS 2014/15 M. Schmidt-Schauß 35/35
Semantik 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 ::=
MehrEinführung in die funktionale Programmierung
Einführung in die funktionale Programmierung Prof. Dr. Manfred Schmidt-Schauÿ Künstliche Intelligenz und Softwaretechnologie 17. Oktober 2006 Einführung in Haskell: Syntax, Reduktionen, Kernsprachen Haskell,
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
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
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
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
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
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
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
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
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
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
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:
MehrFormale 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
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
MehrTheorembeweiserpraktikum SS 2016
Institut für Programmstrukturen und Datenorganisation Lehrstuhl Programmierparadigmen Am Fasanengarten 5 76131 Karlsruhe http://pp.ipd.kit.edu/ Theorembeweiserpraktikum SS 2016 http://pp.ipd.kit.edu/lehre/ss2016/tba
MehrAllgemeine 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,
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
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
MehrReduktionssysteme und Termersetzungssysteme
Reduktionssysteme und Termersetzungssysteme Untersuchung von Berechnungen mittels Reduktionsregeln Simplifikation von: Datenstrukturen / Termen usw. Erkennen von gleichen Objekten durch Normalisierung
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
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
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
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.
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 =
MehrKlausur Programmierung WS 2002/03
Klausur Programmierung WS 2002/03 Prof. Dr. Gert Smolka, Dipl. Inf. Thorsten Brunklaus 14. Dezember 2002 Leo Schlau 45 Vor- und Nachname Sitz-Nr. 4711 007 Matrikelnummer Code Bitte öffnen Sie das Klausurheft
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
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
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
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
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,
MehrGrundlegende Datentypen
Funktionale Programmierung Grundlegende Datentypen Fakultät für Informatik und Mathematik Hochschule München Letzte Änderung: 14.11.2017 15:37 Inhaltsverzeichnis Typen........................................
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........................................
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.......................
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
MehrReduktionssysteme Termersetzungssysteme. Keine kritischen Paare. Betrachte Variablenüberlappung:
Beispiele Beispiel 9.4 Betrachte f (f (x, y), z) f (x, f (y, z)) f (f (x, y ), z ) f (x, f (y, z )) Unifizierbar mit x f (x, y ), y z f (f (f (x, y ), z ), z) t 1 = f (f (x, y ), f (z, z)) f (f (x, f (y,
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
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,
MehrÜbung zur Vorlesung Automatisierte Logik und Programmierung I
Übung zur Vorlesung Automatisierte Logik und Programmierung I Prof. Chr. Kreitz Universität Potsdam, Theoretische Informatik Wintersemester 2008/09 Blatt 3 Abgabetermin: 26.11.08 nach der Übung Das dritte
MehrHASKELL KAPITEL 2.1. Notationen: Currying und das Lambda-Kalkül
HASKELL KAPITEL 2.1 Notationen: Currying und das Lambda-Kalkül Bisheriges (Ende VL-Teil 1) weite :: (Float,Float) ->Float weite (v0, phi) = (square(v0)/9.81) * sin(2 * phi) (10, 30 ) smaller ::(Integer,
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
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
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.
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
MehrFrage, 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
MehrKorrektheit von Programmen und Programmiersprachen
Korrektheit von Programmen und Programmiersprachen Methoden, Analysen und Anwendungen David Sabel Goethe-Universität, Frankfurt am Main 13. November 2012 Überblick 1. Motivation 2. Grundlagen 3. Korrektheit
Mehr4.1 Bäume, Datenstrukturen und Algorithmen. Zunächst führen wir Graphen ein. Die einfachste Vorstellung ist, dass ein Graph gegeben ist als
Kapitel 4 Bäume 4.1 Bäume, Datenstrukturen und Algorithmen Zunächst führen wir Graphen ein. Die einfachste Vorstellung ist, dass ein Graph gegeben ist als eine Menge von Knoten und eine Menge von zugehörigen
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
MehrFAKULTÄT FÜR INFORMATIK
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 Übungsblatt 10 Prof. Dr. Helmut Seidl, T. M. Gawlitza,
MehrFunktionen höherer Ordnung. 3. Dezember 2014
höherer Ordnung Universität Bielefeld AG Praktische Informatik 3. Dezember 2014 höherer Ordnung Worum geht es heute? In Haskell gibt es, die als Argument haben oder als Ergebnis liefern. Diese nennt man
MehrTeil 7: Rekursion; Imperative Programme
1 Teil 7: Rekursion; Imperative Programme Terminierend rekursive Funktionen Im Tutorial: Kap. 3.5 / 9.2 Definition mit recdef, Nachweis der Terminierung Beweise über rekursive Funktionen Imperative Programme
MehrProgrammierung 1 (Wintersemester 2015/16) Wiederholungstutorium Lösungsblatt 15 (Linearer Speicher, Listen, Bäume)
Fachrichtung 6.2 Informatik Universität des Saarlandes Tutorenteam der Vorlesung Programmierung 1 Programmierung 1 (Wintersemester 2015/16) Wiederholungstutorium Lösungsblatt 15 (Linearer Speicher, Listen,
MehrProgrammierung und Modellierung
Programmierung und Modellierung Benutzerdefinierte Datentypen Martin Wirsing in Zusammenarbeit mit Moritz Hammer SS 2009 2 Inhalt Kap. 7 Benutzerdefinierte Datentypen 1. Aufzählungstypen 2. Typen mit zusammengesetzten
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.
MehrProgrammieren 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
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
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
Mehr2. Woche Eindeutige Entschlüsselbarleit, Sätze von Kraft und McMillan, Huffmancodierung
2 Woche Eindeutige Entschlüsselbarleit, Sätze von Kraft und McMillan, Huffmancodierung 2 Woche: Eindeutige Entschlüsselbarleit, Sätze von Kraft und McMillan, Huffmancodierung 24/ 44 Zwei Beispiele a 0
MehrOptimierungen in einer formalen Semantik Konstantenfaltung und Konstantenpropagation
Optimierungen in einer formalen Semantik Konstantenfaltung und Konstantenpropagation http://pp.info.uni-karlsruhe.de/lehre/ss2011/tba/ LEHRSTUHL PROGRAMMIERPARADIGMEN 0 KIT SS Universität 2011 desdenis
MehrProgrammieren 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
MehrSemantik von Programmiersprachen SS 2017
Lehrstuhl für Programmierparadigmen Denis Lohner Sebastian Ullrich denis.lohner@kit.edu sebastian.ullrich@kit.edu Semantik von Programmiersprachen SS 2017 http://pp.ipd.kit.edu/lehre/ss2017/semantik Lösungen
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:
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
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
MehrStratego/XT und ASF+SDF Meta-Environment. Paul Weder Seminar Transformationen Datum:
Stratego/XT und ASF+SDF Meta-Environment Paul Weder Seminar Transformationen Datum: 20.01.2006 Gliederung Allgemeines ASF+SDF Meta-Environment Stratego/XT Zusammenfassung/Vergleich SDF (Syntax Definition
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.
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
MehrWS 2011/2012. RobertGiegerich. November 12, 2013
WS 2011/2012 Robert AG Praktische Informatik November 12, 2013 Haskell-Syntax: Ergänzungen Es gibt noch etwas bequeme Notation für Fallunterscheidungen, die wir bisher nicht benutzt haben. Bisher kennen
MehrDie Korrektheit von Mergesort
Die Korrektheit von Mergesort Christoph Lüth 11. November 2002 Definition von Mergesort Die Funktion Mergesort ist wie folgt definiert: msort :: [Int]-> [Int] msort xs length xs
MehrDieÜbersetzung funktionaler Programmiersprachen
DieÜbersetzung funktionaler Programmiersprachen 107 11 Die Sprache PuF Wir betrachten hier nur die Mini-Sprache PuF( Pure Functions ). Insbesondere verzichten wir(vorerst) auf: Seiteneffekte; Datenstrukturen;
MehrWS 2011/2012. RobertGiegerich. November 12, 2013
WS 2011/2012 Robert AG Praktische Informatik November 12, 2013 Haskell-Syntax: Ergänzungen Es gibt noch etwas bequeme Notation für Fallunterscheidungen, die wir bisher nicht benutzt haben. Bisher kennen
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
MehrFunktionale Programmierung Teil 2 Methodik: Spezifikation, Implementierung, Verifikation
Grundlagen der Programm- und Systementwicklung Funktionale Programmierung Teil 2 Methodik: Spezifikation, Implementierung, Verifikation Technische Universität München Institut für Informatik Software &
MehrGliederung. Algorithmen und Datenstrukturen I. Listen in Haskell: Listen in Haskell: Listen in Haskell. Datentyp Liste Strings Listenkomprehension
Gliederung Algorithmen und Datenstrukturen I D. Rösner Institut für Wissens- und Sprachverarbeitung Fakultät für Informatik Otto-von-Guericke Universität Magdeburg 1 Winter 2009/10, 16. Oktober 2009, c
Mehr2.3 Spezifikation von Abstrakten Datentypen
Abstrakte Datentypen (ADT) 2.3 Spezifikation von Abstrakten Datentypen Sichtbare Schnittstelle: Typbezeichner Signaturen der Operationen Spezifikation der Operationen Abstraktionsbarriere Implementierung
MehrProgrammierung 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:
Mehr1. Probeklausur (Lösung) zu Programmierung 1 (WS 07/08)
Fachschaft Informatikstudiengänge Fachrichtung 6.2 Informatik Das Team der Bremser 1. Probeklausur (Lösung) zu Programmierung 1 (WS 07/08) http://fsinfo.cs.uni-sb.de Name Matrikelnummer Bitte öffnen Sie
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
MehrProgrammieren 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 s Wochenende Programmieren
MehrIntuitionistische Lineare Logik
Lineare Logik Intuitionistische Lineare Logik Zusammenhang zur intuitionistischen Logik Termzuweisung und funktionale Interpretation Intuitionistische Lineare Logik Sinn und Zweck : Kontrolle über Ressourcen
MehrWS 2011/2012. Robert Giegerich Dezember 2013
WS 2011/2012 Robert 1 AG Praktische Informatik 11. Dezember 2013 1 robert@techfak.uni-bielefeld.de Vorschau Themen heute: Funktionen höherer Ordnung (Fortsetzung) künstliche Striktheit mehr zu fold für
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
MehrFunktionale Programmierung. ALP I Lambda-Kalkül. Teil III SS Prof. Dr. Margarita Esponda. Prof. Dr. Margarita Esponda
ALP I Lambda-Kalkül Teil III SS 2011 Parser Hilfsfunktionen: Die break-funktion ist eine Funktion Höherer Ordnung, die eine Liste beim ersten Vorkommen einer Bedingung in zwei Listen spaltet. break ::
MehrProgrammieren 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
MehrGrundprinzipien 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
MehrWann sind Codes eindeutig entschlüsselbar?
Wann sind Codes eindeutig entschlüsselbar? Definition Suffix Sei C ein Code. Ein Folge s {0, 1} heißt Suffix in C falls 1 c i, c j C : c i = c j s oder 2 c C und einen Suffix s in C: s = cs oder 3 c C
MehrProgrammierkurs II. Typsynonyme & algebraische Datentypen
Programmierkurs II Typsynonyme & algebraische Datentypen 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
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))
MehrPraktische Informatik 3
Praktische Informatik 3 Christian Maeder WS 03/04 Vorlesung vom 12.1.2004: Ein/Ausgabe in funktionalen Sprachen Vorlesung vom 12.1.2004: Ein/Ausgabe in funktionalen Sprachen 3 Inhalt Wo ist das Problem?
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
MehrBeispiel: Hamming-Folge Erzeuge eine Folge X = x 0,x 2,... mit folgenden Eigenschaften: 1. x i+1 > x i für alle i
Beispiel: Hamming-Folge Erzeuge eine Folge X = x 0,x 2,... mit folgenden Eigenschaften: 1. x i+1 > x i für alle i FP-8.7 2. x 0 = 1 3. Falls x in der Folge X auftritt, dann auch 2x, 3x und 5x. 4. Nur die
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,...
MehrTableaukalkül für Aussagenlogik
Tableaukalkül für Aussagenlogik Tableau: Test einer Formel auf Widersprüchlichkeit Fallunterscheidung baumförmig organisiert Keine Normalisierung, d.h. alle Formeln sind erlaubt Struktur der Formel wird
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 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
MehrINFORMATIK FÜR BIOLOGEN
Technische Universität Dresden 15012015 Institut für Theoretische Informatik Professur für Automatentheorie INFORMATIK FÜR BIOLOGEN Musterklausur WS 2014/15 Studiengang Biologie und Molekulare Biotechnologie
MehrFormale Systeme. Aussagenlogik: Sequenzenkalkül. Prof. Dr. Bernhard Beckert WS 2010/2011 KIT INSTITUT FÜR THEORETISCHE INFORMATIK
Formale Systeme Prof. Dr. Bernhard Beckert WS 2010/2011 KIT INSTITUT FÜR THEORETISCHE INFORMATIK KIT University of the State of Baden-Württemberg and National Large-scale Research Center of the Helmholtz
MehrLösung: InfA - Übungsblatt 07
Lösung: InfA - Übungsblatt 07 Michele Ritschel & Marcel Schilling 23. Dezember 2008 Verwendete Abkürzungen: Beweis, vollständige Induktion, IA: Induktionsanfang/Induktionsanker, IS: Induktionsschritt/Induktionssprung,
Mehr