Semantik und Analyse von Funktionalen Programmen (SAFP):

Transkript

1 Semantik und Analyse von Funktionalen Programmen (SAFP): LR: Sharing und Striktheitsanalyse titleslide Prof. Dr. Manfred Schmidt-Schauß SAFP; WS 2017/18 Stand der Folien: 30. Januar 2018

2 LR: Syntax 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)) EFP LR: Sharing und Striktheitsanalyse SAFP; WS 2017/18 M. Schmidt-Schauß 2/37

3 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))] EFP LR: Sharing und Striktheitsanalyse SAFP; WS 2017/18 M. Schmidt-Schauß 3/37

4 LR: Reduktions-Regeln (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]) wenn v ein 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 LR: Sharing und Striktheitsanalyse SAFP; WS 2017/18 M. Schmidt-Schauß 4/37

5 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 EFP LR: Sharing und Striktheitsanalyse SAFP; WS 2017/18 M. Schmidt-Schauß 5/37

6 LR: Reduktions-Regeln (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 LR: Sharing und Striktheitsanalyse SAFP; WS 2017/18 M. Schmidt-Schauß 6/37

7 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. EFP LR: Sharing und Striktheitsanalyse SAFP; WS 2017/18 M. Schmidt-Schauß 7/37

8 Reduktionen: Gruppen von Regeln Gruppen von Reduktionen: beta cp-reduktionen case-reduktionen seq-reduktionen Let-Verschiebungen Vergleich mit KFPT: Ohne Sharing LR (mit) Sharing beta lbeta cp-reduktionen case case-reduktionen seq seq-reduktionen Let-Verschiebungen EFP LR: Sharing und Striktheitsanalyse SAFP; WS 2017/18 M. Schmidt-Schauß 8/37

9 WHNFs 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 ). EFP LR: Sharing und Striktheitsanalyse SAFP; WS 2017/18 M. Schmidt-Schauß 9/37

10 NO-Beispiel Normalordnungsreduktion von Ω = (λz.(z z)) (λx.(x x)): (λz.(z z)) (λx.(x x)) 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,cp (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 LR: Sharing und Striktheitsanalyse SAFP; WS 2017/18 M. Schmidt-Schauß 10/37

11 NO-Beispiel Normalordnungsreduktion von letrec u = True : Nil, y = u, x = (λz.z) y in case x of Nil -> 1; x : xs -> 0 letrec u = True : Nil, y = u, x = (λz.z) y in... n,lbeta letrec u = True : Nil, y = u, x = (letrec z = y in z) in... n,llet letrec u = True : Nil, y = u, x = z, z = y in case x of True -> 1; False -> 0 n,case letrec u = True : Nil, y = u, x = z, z = y in (letrec x = True, xs = Nil in 1) n,llet letrec u = True : Nil, y = u, x = z, z = y, x = True, xs = Nil in 1) WHNF EFP LR: Sharing und Striktheitsanalyse SAFP; WS 2017/18 M. Schmidt-Schauß 11/37

12 Einschub: Abstrakte Maschine Sestofts Abstrakte Maschine Mark1 EFP LR: Sharing und Striktheitsanalyse SAFP; WS 2017/18 M. Schmidt-Schauß 12/37

13 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) EFP LR: Sharing und Striktheitsanalyse SAFP; WS 2017/18 M. Schmidt-Schauß 13/37

14 Kontextuelle Ordnung und Gleichheit Definition s c t gdw C[ ] : C[s] = C[t] s c t gdw s c t t c s Kontext Lemma 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 LR: Sharing und Striktheitsanalyse SAFP; WS 2017/18 M. Schmidt-Schauß 14/37

15 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) EFP LR: Sharing und Striktheitsanalyse SAFP; WS 2017/18 M. Schmidt-Schauß 15/37

16 Weitere Transformationen (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 LR: Sharing und Striktheitsanalyse SAFP; WS 2017/18 M. Schmidt-Schauß 16/37

17 Weitere Transformationen (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 EFP LR: Sharing und Striktheitsanalyse SAFP; WS 2017/18 M. Schmidt-Schauß 17/37

18 Korrekheiten 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. LR, Aber: c. EFP LR: Sharing und Striktheitsanalyse SAFP; WS 2017/18 M. Schmidt-Schauß 18/37

19 Längenmaße von Normalordnungsreduktionen Definition Sei t ein geschlossener Ausdruck. nor(t) ist definiert als die Normalordnungsreduktion von t bis zur WHNF. 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 ( ) = rln( ). EFP LR: Sharing und Striktheitsanalyse SAFP; WS 2017/18 M. Schmidt-Schauß 19/37

20 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 LR: Sharing und Striktheitsanalyse SAFP; WS 2017/18 M. Schmidt-Schauß 20/37

21 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 LR: Sharing und Striktheitsanalyse lwas SAFP; WS 2017/18 M. Schmidt-Schauß 21/37

22 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 LR: Sharing und Striktheitsanalyse SAFP; WS 2017/18 M. Schmidt-Schauß 22/37

23 Tiefe Unterterme 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. EFP LR: Sharing und Striktheitsanalyse SAFP; WS 2017/18 M. Schmidt-Schauß 23/37

24 Abstrakte Reduktion 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 LR: Sharing und Striktheitsanalyse SAFP; WS 2017/18 M. Schmidt-Schauß 24/37

25 Bot-Reduktionen 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) EFP LR: Sharing und Striktheitsanalyse SAFP; WS 2017/18 M. Schmidt-Schauß 25/37

26 Änderungen der Reduktionsstrategie durch Striktheit 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 LR: Sharing und Striktheitsanalyse SAFP; WS 2017/18 M. Schmidt-Schauß 26/37

27 Striktheits-Analyse: ein Beispiel 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 ) EFP LR: Sharing und Striktheitsanalyse SAFP; WS 2017/18 M. Schmidt-Schauß 27/37

28 Striktheits-Analyse: Beispiel lenr 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 LR: Sharing und Striktheitsanalyse SAFP; WS 2017/18 M. Schmidt-Schauß 28/37

29 Striktheits-Analyse Beispiel 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 EFP LR: Sharing und Striktheitsanalyse SAFP; WS 2017/18 M. Schmidt-Schauß 29/37

30 Striktheits-Analyse: Beispiel zu Sharing 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 LR: Sharing und Striktheitsanalyse SAFP; WS 2017/18 M. Schmidt-Schauß 30/37

31 Striktheits-Analyse: Beispiel zu Sharing letrec top = in if top then (if top then else False) else (if top then False else ) True -Fall: letrec top = in if True then (if True then else False) else (if True then False else ) ergibt. Der False Fall und ungetypte Fälle gehen genauso. Andere Analyse-Verfahren können das nicht, da die Gleichheit der s verlorengeht. EFP LR: Sharing und Striktheitsanalyse SAFP; WS 2017/18 M. Schmidt-Schauß 31/37

32 Striktheits-Analyse: Anmerkungen 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? EFP LR: Sharing und Striktheitsanalyse SAFP; WS 2017/18 M. Schmidt-Schauß 32/37

33 Striktheits-Analyse: Anmerkungen Todo: Auswirkungen auf Parallelisierung der Auswertung Todo: Nachweis, dass Auswertungsumstellung eine Optimierung in abstrakten Maschinen ist. kommt: Verbesserungen/ Optimierungen in LR kommt: Polymorphes LR Wie sieht Striktheitsanalyse aus in Concurrent Haskell? EFP LR: Sharing und Striktheitsanalyse SAFP; WS 2017/18 M. Schmidt-Schauß 32/37

34 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 EFP LR: Sharing und Striktheitsanalyse SAFP; WS 2017/18 M. Schmidt-Schauß 33/37

35 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 LR: Sharing und Striktheitsanalyse SAFP; WS 2017/18 M. Schmidt-Schauß 34/37

36 Polymorphes LR 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) EFP LR: Sharing und Striktheitsanalyse SAFP; WS 2017/18 M. Schmidt-Schauß 35/37

37 Beispiel map 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 LR: Sharing und Striktheitsanalyse SAFP; WS 2017/18 M. Schmidt-Schauß 36/37

38 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 LR: Sharing und Striktheitsanalyse SAFP; WS 2017/18 M. Schmidt-Schauß 37/37