Problem: Zwischenergebnisse Ein Beispiel: filter

(1)

Problem: Zwischenergebnisse

Ein Beispiel:

filter((== 1)◦(‘mod‘3)) (map (ˆ2) [1..5])

= filter((== 1)◦(‘mod‘3)) (1: (map (ˆ2) [2..5]))

= 1: (filter ((==1)◦(‘mod‘3)) (map (ˆ2) [2..5]))

= 1: (filter ((==1)◦(‘mod‘3)) (4: (map (ˆ2) [3..5])))

= 1:4: (filter((== 1)◦(‘mod‘3)) (map (ˆ2) [3..5]))

= 1:4: (filter((== 1)◦(‘mod‘3)) (9: (map (ˆ2) [4,5])))

= 1:4: (filter((== 1)◦(‘mod‘3)) (map (ˆ2) [4,5]))

= 1:4: (filter((== 1)◦(‘mod‘3)) (16: (map (ˆ2) [5])))

= 1:4:16: (filter((== 1)◦(‘mod‘3)) (map(ˆ2) [5]))

= 1:4:16: (filter((== 1)◦(‘mod‘3)) (25: (map (ˆ2) [ ])))

= 1:4:16:25: (filter((== 1)◦(‘mod‘3)) (map(ˆ2) [ ]))

= 1:4:16:25: (filter((== 1)◦(‘mod‘3)) [ ] )

= 1:4:16:25: [ ]

(2)

Problem: Zwischenergebnisse

Ein Beispiel:

filter((== 1)◦(‘mod‘3)) (map (ˆ2) [1..5])

= filter((== 1)◦(‘mod‘3)) (1: (map (ˆ2) [2..5]))

= 1: (filter ((==1)◦(‘mod‘3)) (map (ˆ2) [2..5]))

= 1: (filter ((==1)◦(‘mod‘3)) (4: (map (ˆ2) [3..5])))

= 1:4: (filter((== 1)◦(‘mod‘3)) (map (ˆ2) [3..5]))

= 1:4: (filter((== 1)◦(‘mod‘3)) (9: (map (ˆ2) [4,5])))

= 1:4: (filter((== 1)◦(‘mod‘3)) (map (ˆ2) [4,5]))

= 1:4: (filter((== 1)◦(‘mod‘3)) (16: (map (ˆ2) [5])))

= 1:4:16: (filter((== 1)◦(‘mod‘3)) (map(ˆ2) [5]))

= 1:4:16: (filter((== 1)◦(‘mod‘3)) (25: (map (ˆ2) [ ])))

= 1:4:16:25: (filter((== 1)◦(‘mod‘3)) (map(ˆ2) [ ]))

= 1:4:16:25: (filter((== 1)◦(‘mod‘3)) [ ] )

= 1:4:16:25: [ ]

1

(3)

Problem: Zwischenergebnisse

Ein Beispiel:

filter((== 1)◦(‘mod‘3)) (map (ˆ2) [1..5])

= filter((== 1)◦(‘mod‘3)) (1: (map (ˆ2) [2..5]))

= 1: (filter((== 1)◦(‘mod‘3)) (map (ˆ2) [2..5]))

= 1: (filter ((==1)◦(‘mod‘3)) (4: (map (ˆ2) [3..5])))

= 1:4: (filter((== 1)◦(‘mod‘3)) (map (ˆ2) [3..5]))

= 1:4: (filter((== 1)◦(‘mod‘3)) (9: (map (ˆ2) [4,5])))

= 1:4: (filter((== 1)◦(‘mod‘3)) (map (ˆ2) [4,5]))

= 1:4: (filter((== 1)◦(‘mod‘3)) (16: (map (ˆ2) [5])))

= 1:4:16: (filter((== 1)◦(‘mod‘3)) (map(ˆ2) [5]))

= 1:4:16: (filter((== 1)◦(‘mod‘3)) (25: (map (ˆ2) [ ])))

= 1:4:16:25: (filter((== 1)◦(‘mod‘3)) (map(ˆ2) [ ]))

= 1:4:16:25: (filter((== 1)◦(‘mod‘3)) [ ] )

= 1:4:16:25: [ ]

(4)

Problem: Zwischenergebnisse

Ein Beispiel:

filter((== 1)◦(‘mod‘3)) (map (ˆ2) [1..5])

= filter((== 1)◦(‘mod‘3)) (1: (map (ˆ2) [2..5]))

= 1: (filter((== 1)◦(‘mod‘3)) (map (ˆ2) [2..5]))

= 1: (filter((== 1)◦(‘mod‘3)) (4: (map (ˆ2) [3..5])))

= 1:4: (filter((== 1)◦(‘mod‘3)) (map (ˆ2) [3..5]))

= 1:4: (filter((== 1)◦(‘mod‘3)) (9: (map (ˆ2) [4,5])))

= 1:4: (filter((== 1)◦(‘mod‘3)) (map (ˆ2) [4,5]))

= 1:4: (filter((== 1)◦(‘mod‘3)) (16: (map (ˆ2) [5])))

= 1:4:16: (filter((== 1)◦(‘mod‘3)) (map(ˆ2) [5]))

= 1:4:16: (filter((== 1)◦(‘mod‘3)) (25: (map (ˆ2) [ ])))

= 1:4:16:25: (filter((== 1)◦(‘mod‘3)) (map(ˆ2) [ ]))

= 1:4:16:25: (filter((== 1)◦(‘mod‘3)) [ ] )

= 1:4:16:25: [ ]

1

(5)

Problem: Zwischenergebnisse

Ein Beispiel:

filter((== 1)◦(‘mod‘3)) (map (ˆ2) [1..5])

= filter((== 1)◦(‘mod‘3)) (1: (map (ˆ2) [2..5]))

= 1: (filter((== 1)◦(‘mod‘3)) (map (ˆ2) [2..5]))

= 1: (filter((== 1)◦(‘mod‘3)) (4: (map (ˆ2) [3..5])))

= 1:4: (filter((== 1)◦(‘mod‘3)) (map (ˆ2) [3..5]))

= 1:4: (filter((== 1)◦(‘mod‘3)) (9: (map (ˆ2) [4,5])))

= 1:4: (filter((== 1)◦(‘mod‘3)) (map (ˆ2) [4,5]))

= 1:4: (filter((== 1)◦(‘mod‘3)) (16: (map (ˆ2) [5])))

= 1:4:16: (filter((== 1)◦(‘mod‘3)) (map(ˆ2) [5]))

= 1:4:16: (filter((== 1)◦(‘mod‘3)) (25: (map (ˆ2) [ ])))

= 1:4:16:25: (filter((== 1)◦(‘mod‘3)) (map(ˆ2) [ ]))

= 1:4:16:25: (filter((== 1)◦(‘mod‘3)) [ ] )

= 1:4:16:25: [ ]

(6)

Problem: Zwischenergebnisse

Ein Beispiel:

filter((== 1)◦(‘mod‘3)) (map (ˆ2) [1..5])

= filter((== 1)◦(‘mod‘3)) (1: (map (ˆ2) [2..5]))

= 1: (filter((== 1)◦(‘mod‘3)) (map (ˆ2) [2..5]))

= 1: (filter((== 1)◦(‘mod‘3)) (4: (map (ˆ2) [3..5])))

= 1:4: (filter((== 1)◦(‘mod‘3)) (map (ˆ2) [3..5]))

= 1:4: (filter((== 1)◦(‘mod‘3)) (9: (map (ˆ2) [4,5])))

= 1:4: (filter((== 1)◦(‘mod‘3)) (map (ˆ2) [4,5]))

= 1:4: (filter((== 1)◦(‘mod‘3)) (16: (map (ˆ2) [5])))

= 1:4:16: (filter((== 1)◦(‘mod‘3)) (map(ˆ2) [5]))

= 1:4:16: (filter((== 1)◦(‘mod‘3)) (25: (map (ˆ2) [ ])))

= 1:4:16:25: (filter((== 1)◦(‘mod‘3)) (map(ˆ2) [ ]))

= 1:4:16:25: (filter((== 1)◦(‘mod‘3)) [ ] )

= 1:4:16:25: [ ]

1

(7)

Problem: Zwischenergebnisse

Ein Beispiel:

filter((== 1)◦(‘mod‘3)) (map (ˆ2) [1..5])

= filter((== 1)◦(‘mod‘3)) (1: (map (ˆ2) [2..5]))

= 1: (filter((== 1)◦(‘mod‘3)) (map (ˆ2) [2..5]))

= 1: (filter((== 1)◦(‘mod‘3)) (4: (map (ˆ2) [3..5])))

= 1:4: (filter((== 1)◦(‘mod‘3)) (map (ˆ2) [3..5]))

= 1:4: (filter((== 1)◦(‘mod‘3)) (9: (map (ˆ2) [4,5])))

= 1:4: (filter((== 1)◦(‘mod‘3)) (map (ˆ2) [4,5]))

= 1:4: (filter((== 1)◦(‘mod‘3)) (16: (map (ˆ2) [5])))

= 1:4:16: (filter((== 1)◦(‘mod‘3)) (map(ˆ2) [5]))

= 1:4:16: (filter((== 1)◦(‘mod‘3)) (25: (map (ˆ2) [ ])))

= 1:4:16:25: (filter((== 1)◦(‘mod‘3)) (map(ˆ2) [ ]))

= 1:4:16:25: (filter((== 1)◦(‘mod‘3)) [ ] )

= 1:4:16:25: [ ]

(8)

Problem: Zwischenergebnisse

Ein Beispiel:

filter((== 1)◦(‘mod‘3)) (map (ˆ2) [1..5])

= filter((== 1)◦(‘mod‘3)) (1: (map (ˆ2) [2..5]))

= 1: (filter((== 1)◦(‘mod‘3)) (map (ˆ2) [2..5]))

= 1: (filter((== 1)◦(‘mod‘3)) (4: (map (ˆ2) [3..5])))

= 1:4: (filter((== 1)◦(‘mod‘3)) (map (ˆ2) [3..5]))

= 1:4: (filter((== 1)◦(‘mod‘3)) (9: (map (ˆ2) [4,5])))

= 1:4: (filter((== 1)◦(‘mod‘3)) (map (ˆ2) [4,5]))

= 1:4: (filter((== 1)◦(‘mod‘3)) (16: (map (ˆ2) [5])))

= 1:4:16: (filter((== 1)◦(‘mod‘3)) (map(ˆ2) [5]))

= 1:4:16: (filter((== 1)◦(‘mod‘3)) (25: (map (ˆ2) [ ])))

= 1:4:16:25: (filter((== 1)◦(‘mod‘3)) (map(ˆ2) [ ]))

= 1:4:16:25: (filter((== 1)◦(‘mod‘3)) [ ] )

= 1:4:16:25: [ ]

1

(9)

Problem: Zwischenergebnisse

Ein Beispiel:

filter((== 1)◦(‘mod‘3)) (map (ˆ2) [1..5])

= filter((== 1)◦(‘mod‘3)) (1: (map (ˆ2) [2..5]))

= 1: (filter((== 1)◦(‘mod‘3)) (map (ˆ2) [2..5]))

= 1: (filter((== 1)◦(‘mod‘3)) (4: (map (ˆ2) [3..5])))

= 1:4: (filter((== 1)◦(‘mod‘3)) (map (ˆ2) [3..5]))

= 1:4: (filter((== 1)◦(‘mod‘3)) (9: (map (ˆ2) [4,5])))

= 1:4: (filter((== 1)◦(‘mod‘3)) (map (ˆ2) [4,5]))

= 1:4: (filter((== 1)◦(‘mod‘3)) (16: (map (ˆ2) [5])))

= 1:4:16: (filter((== 1)◦(‘mod‘3)) (map(ˆ2) [5]))

= 1:4:16: (filter((== 1)◦(‘mod‘3)) (25: (map (ˆ2) [ ])))

= 1:4:16:25: (filter((== 1)◦(‘mod‘3)) (map(ˆ2) [ ]))

= 1:4:16:25: (filter((== 1)◦(‘mod‘3)) [ ] )

= 1:4:16:25: [ ]

(10)

Problem: Zwischenergebnisse

Ein Beispiel:

filter((== 1)◦(‘mod‘3)) (map (ˆ2) [1..5])

= filter((== 1)◦(‘mod‘3)) (1: (map (ˆ2) [2..5]))

= 1: (filter((== 1)◦(‘mod‘3)) (map (ˆ2) [2..5]))

= 1: (filter((== 1)◦(‘mod‘3)) (4: (map (ˆ2) [3..5])))

= 1:4: (filter((== 1)◦(‘mod‘3)) (map (ˆ2) [3..5]))

= 1:4: (filter((== 1)◦(‘mod‘3)) (9: (map (ˆ2) [4,5])))

= 1:4: (filter((== 1)◦(‘mod‘3)) (map (ˆ2) [4,5]))

= 1:4: (filter((== 1)◦(‘mod‘3)) (16: (map (ˆ2) [5])))

= 1:4:16: (filter((== 1)◦(‘mod‘3)) (map(ˆ2) [5]))

= 1:4:16: (filter((== 1)◦(‘mod‘3)) (25: (map (ˆ2) [ ])))

= 1:4:16:25: (filter((== 1)◦(‘mod‘3)) (map(ˆ2) [ ]))

= 1:4:16:25: (filter((== 1)◦(‘mod‘3)) [ ] )

= 1:4:16:25: [ ]

1

(11)

Problem: Zwischenergebnisse

Ein Beispiel:

filter((== 1)◦(‘mod‘3)) (map (ˆ2) [1..5])

= filter((== 1)◦(‘mod‘3)) (1: (map (ˆ2) [2..5]))

= 1: (filter((== 1)◦(‘mod‘3)) (map (ˆ2) [2..5]))

= 1: (filter((== 1)◦(‘mod‘3)) (4: (map (ˆ2) [3..5])))

= 1:4: (filter((== 1)◦(‘mod‘3)) (map (ˆ2) [3..5]))

= 1:4: (filter((== 1)◦(‘mod‘3)) (9: (map (ˆ2) [4,5])))

= 1:4: (filter((== 1)◦(‘mod‘3)) (map (ˆ2) [4,5]))

= 1:4: (filter((== 1)◦(‘mod‘3)) (16: (map (ˆ2) [5])))

= 1:4:16: (filter((== 1)◦(‘mod‘3)) (map(ˆ2) [5]))

= 1:4:16: (filter((== 1)◦(‘mod‘3)) (25: (map (ˆ2) [ ])))

= 1:4:16:25: (filter((== 1)◦(‘mod‘3)) (map(ˆ2) [ ]))

= 1:4:16:25: (filter((== 1)◦(‘mod‘3)) [ ] )

= 1:4:16:25: [ ]

(12)

Problem: Zwischenergebnisse

Ein Beispiel:

filter((== 1)◦(‘mod‘3)) (map (ˆ2) [1..5])

= filter((== 1)◦(‘mod‘3)) (1: (map (ˆ2) [2..5]))

= 1: (filter((== 1)◦(‘mod‘3)) (map (ˆ2) [2..5]))

= 1: (filter((== 1)◦(‘mod‘3)) (4: (map (ˆ2) [3..5])))

= 1:4: (filter((== 1)◦(‘mod‘3)) (map (ˆ2) [3..5]))

= 1:4: (filter((== 1)◦(‘mod‘3)) (9: (map (ˆ2) [4,5])))

= 1:4: (filter((== 1)◦(‘mod‘3)) (map (ˆ2) [4,5]))

= 1:4: (filter((== 1)◦(‘mod‘3)) (16: (map (ˆ2) [5])))

= 1:4:16: (filter((== 1)◦(‘mod‘3)) (map(ˆ2) [5]))

= 1:4:16: (filter((== 1)◦(‘mod‘3)) (25: (map (ˆ2) [ ])))

= 1:4:16:25: (filter((== 1)◦(‘mod‘3)) (map(ˆ2) [ ]))

= 1:4:16:25: (filter((== 1)◦(‘mod‘3)) [ ] )

= 1:4:16:25: [ ]

1

(13)

Problem: Zwischenergebnisse

Ein Beispiel:

filter((== 1)◦(‘mod‘3)) (map (ˆ2) [1..5])

= filter((== 1)◦(‘mod‘3)) (1: (map (ˆ2) [2..5]))

= 1: (filter((== 1)◦(‘mod‘3)) (map (ˆ2) [2..5]))

= 1: (filter((== 1)◦(‘mod‘3)) (4: (map (ˆ2) [3..5])))

= 1:4: (filter((== 1)◦(‘mod‘3)) (map (ˆ2) [3..5]))

= 1:4: (filter((== 1)◦(‘mod‘3)) (9: (map (ˆ2) [4,5])))

= 1:4: (filter((== 1)◦(‘mod‘3)) (map (ˆ2) [4,5]))

= 1:4: (filter((== 1)◦(‘mod‘3)) (16: (map (ˆ2) [5])))

= 1:4:16: (filter((== 1)◦(‘mod‘3)) (map(ˆ2) [5]))

= 1:4:16: (filter((== 1)◦(‘mod‘3)) (25: (map (ˆ2) [ ])))

= 1:4:16:25: (filter((== 1)◦(‘mod‘3)) (map(ˆ2) [ ]))

= 1:4:16:25: (filter((== 1)◦(‘mod‘3)) [ ] )

(14)

Problem: Zwischenergebnisse

Ein Beispiel:

filter((== 1)◦(‘mod‘3)) (map (ˆ2) [1..5])

= filter((== 1)◦(‘mod‘3)) (1: (map (ˆ2) [2..5]))

= 1: (filter((== 1)◦(‘mod‘3)) (map (ˆ2) [2..5]))

= 1: (filter((== 1)◦(‘mod‘3)) (4: (map (ˆ2) [3..5])))

= 1:4: (filter((== 1)◦(‘mod‘3)) (map (ˆ2) [3..5]))

= 1:4: (filter((== 1)◦(‘mod‘3)) (9: (map (ˆ2) [4,5])))

= 1:4: (filter((== 1)◦(‘mod‘3)) (map (ˆ2) [4,5]))

= 1:4: (filter((== 1)◦(‘mod‘3)) (16: (map (ˆ2) [5])))

= 1:4:16: (filter((== 1)◦(‘mod‘3)) (map(ˆ2) [5]))

= 1:4:16: (filter((== 1)◦(‘mod‘3)) (25: (map (ˆ2) [ ])))

= 1:4:16:25: (filter((== 1)◦(‘mod‘3)) (map(ˆ2) [ ]))

= 1:4:16:25: (filter((== 1)◦(‘mod‘3)) [ ] )

= 1:4:16:25: [ ]

1

(15)

Freies Theorem als Lösung?

Wir hatten, für jede Wahl vonp,h und l:

filterp (maph l) = map h (filter(p◦h) l)

Warum nicht einfache linke Seite durch rechte Seite ersetzen?

Probleme:

• immer noch zwei Durchläufe, bzw. Zwischenergebnis

• Gefahr von Doppelarbeit für h

• wenn Verlass nur auf Typ vonfilter:

I andere Funktion gleichen Typs könnte Listeverlängern

I . . . und/oderElemente verdoppeln

(16)

Freies Theorem als Lösung?

Probleme:

2

(17)

Freies Theorem als Lösung?

Probleme:

(18)

Freies Theorem als Lösung?

Probleme:

2

(19)

Freies Theorem als Lösung?

Probleme:

(20)

Freies Theorem als Lösung?

Probleme:

2

(21)

Freies Theorem als Lösung?

Probleme:

(22)

Versuch Herleitung effizienter Lösung „per Hand“

Man ersetze zunächst einfach wie folgt:

filterp (map h l) filterMap p h l

für eine angenommene neue Funktion:

filterMap:: (b→Bool)→(a→b)→[a]→[b] filterMap p h l =filterp (maph l)

Dann, Verfeinerung und Optimierung dieser Funktion. Zum Beispiel durch Instanziierung:

filterMap:: (b →Bool)→(a→b)→[a]→[b] filterMapp h [ ] =filterp (map h [ ]) filterMapp h (a:as) =filterp (map h (a:as)) Und Anwendung bekannter Definitionen:

filterMap:: (b→Bool)→(a→b)→[a]→[b] filterMap p h[ ] =filter p [ ]

filterMap p h(a:as) =filter p ((h a) : (map h as)) Gegebenenfalls wiederholt:

filterMap:: (b →Bool)→(a→b)→[a]→[b] filterMapp h [ ] = [ ]

filterMapp h (a:as) | p (h a) = (h a) : (filter p (map h as))

| otherwise=filterp (maph as) Wenn möglich, Rückgriff auf ursprünglich postulierte Gleichung:

Also:

filterMapp h (a:as) | p (h a) = (h a) : (filterMap p h as)

| otherwise=filterMapp h as

3

(23)

Versuch Herleitung effizienter Lösung „per Hand“

filterp (map h l) filterMap p h l für eine angenommene neue Funktion:

Dann, Verfeinerung und Optimierung dieser Funktion. Zum Beispiel durch Instanziierung:

Also:

(24)

Versuch Herleitung effizienter Lösung „per Hand“

Dann, Verfeinerung und Optimierung dieser Funktion.

Zum Beispiel durch Instanziierung:

Also:

3

(25)

Versuch Herleitung effizienter Lösung „per Hand“

filterMap:: (b →Bool)→(a→b)→[a]→[b] filterMapp h [ ] =filterp (map h [ ]) filterMapp h (a:as) =filterp (map h (a:as))

Und Anwendung bekannter Definitionen:

Also:

(26)

Versuch Herleitung effizienter Lösung „per Hand“

filterMap p h(a:as) =filter p ((h a) : (map h as))

Gegebenenfalls wiederholt:

Also:

3

(27)

Versuch Herleitung effizienter Lösung „per Hand“

filterMap:: (b→Bool)→(a→b)→[a]→[b]

filterMap p h[ ] =filter p [ ]

Also:

(28)

Versuch Herleitung effizienter Lösung „per Hand“

filterMap p h[ ] =filter p [ ]

filterMap:: (b →Bool)→(a→b)→[a]→[b]

filterMapp h [ ] = [ ]

| otherwise=filterp (map h as)

Wenn möglich, Rückgriff auf ursprünglich postulierte Gleichung: filterMap:: (b→Bool)→(a→b)→[a]→[b] filterMap p h l =filterp (maph l)

Also:

3

(29)

Versuch Herleitung effizienter Lösung „per Hand“

| otherwise=filterp (map h as)

Wenn möglich, Rückgriff auf ursprünglich postulierte Gleichung: filterMap:: (b→Bool)→(a→b)→[a]→[b] filterMap p h l =filterp (maph l)

Also:

(30)

Versuch Herleitung effizienter Lösung „per Hand“

| otherwise=filterp (map h as) Wenn möglich, Rückgriff auf ursprünglich postulierte Gleichung:

filterMap p h l =filterp (maph l)

Also:

3

(31)

Versuch Herleitung effizienter Lösung „per Hand“

| otherwise=filterp (map h as) Wenn möglich, Rückgriff auf ursprünglich postulierte Gleichung:

filterMap p h l =filterp (maph l) Also:

(32)

Probleme mit diesem Ansatz

Im Beispiel erzeugte Funktion:

| otherwise=filterMapp h as ist potentiell ineffizient wegen Verdopplung des Ausdrucks „(h a)“.

Weitere Probleme im Allgemeinen:

• Termination der Transformation (und somit des Compilers)

• Beliebige Berechnungen zur Compile-Zeit

• Geeigneter Rückgriff auf vorherige Definitionen nötig

• Wenn „unvorsichtig“, sogar Termination des Programms fraglich

• Einschränkungen nötig, sonst Aufwandsverdopplung möglich

• hoher Implementierungsaufwand

4

(33)

Probleme mit diesem Ansatz

(34)

Probleme mit diesem Ansatz

4

(35)

Probleme mit diesem Ansatz

(36)

Probleme mit diesem Ansatz

4

(37)

Probleme mit diesem Ansatz

(38)

Probleme mit diesem Ansatz

4

(39)

Populäre Strategie: Deforestation [Wadler 1990]

Funktioniert zum Beispiel fürfilterp (maph l), nach geeigneter Anpassung für higher-order.

Aber bringt keine Verbesserung zum Beispiel fürmap h (reverse l) mit effizientemreverse:

mapReverse:: (a→b)→[a]→[b] mapReverseh l =map h (reverse l) mapReverseh l =map h (reverse⁰ l [ ])

→

mapReverseh l =mapReverse⁰ h l [ ]

mapReverse⁰ :: (a→b)→[a]→[a]→[b] mapReverse⁰ h l l⁰ =map h (reverse⁰ l l⁰)

mapReverse⁰ h [ ] l⁰ =map h (reverse⁰ [ ] l⁰) mapReverse⁰ h (a:as) l⁰ =map h (reverse⁰ (a:as)l⁰)

→

mapReverse⁰ h [ ] l⁰ =map h l⁰

mapReverse⁰ h (a:as) l⁰ =map h (reverse⁰ as (a:l⁰))

→

mapReverse⁰ h (a:as) l⁰ =mapReverse⁰ h as (a:l⁰)

(40)

Populäre Strategie: Deforestation [Wadler 1990]

→

5

(41)

Populäre Strategie: Deforestation [Wadler 1990]

mapReverse:: (a→b)→[a]→[b] mapReverseh l =map h (reverse l)

mapReverseh l =map h (reverse⁰ l [ ])

→

(42)

Populäre Strategie: Deforestation [Wadler 1990]

→

5

(43)

Populäre Strategie: Deforestation [Wadler 1990]

→

(44)

Populäre Strategie: Deforestation [Wadler 1990]

→

mapReverse⁰ h [ ] l⁰ =map h (reverse⁰ [ ] l⁰) mapReverse⁰ h (a:as) l⁰ =map h (reverse⁰ (a:as) l⁰)

→

5

(45)

Populäre Strategie: Deforestation [Wadler 1990]

→

(46)

Populäre Strategie: Deforestation [Wadler 1990]

→

5

(47)

Populäre Strategie: Deforestation [Wadler 1990]

→ mapReverseh l =mapReverse⁰ h l [ ] mapReverse⁰ :: (a→b)→[a]→[a]→[b] mapReverse⁰ h l l⁰ =map h (reverse⁰ l l⁰)

→ mapReverse⁰ h [ ] l⁰ =map h l⁰

(48)

Weniger Syntax — Mehr Struktur

Man könnte es ja auch mal mitfoldr-fusion versuchen:

h (foldr f k l) = foldr g (h k)l sofern für allex und y,

h (f x y) = g x (h y)

Also, umformulieren:

map h l =foldr (λx ys →(h x) :ys) [ ] l

Folglich:

filterp (map h l) = foldrg (filterp [ ])l sofern für allex und ys,

filterp ((h x) :ys) = g x (filter p ys)

6

(49)

Weniger Syntax — Mehr Struktur

h (f x y) = g x (h y)

Folglich:

(50)

Weniger Syntax — Mehr Struktur

h (f x y) = g x (h y)

Folglich:

6

(51)

Weniger Syntax — Mehr Struktur

Die Bedingung

filterp ((h x) :ys) = g x (filter p ys) lässt sich weiter analysieren:

filterp ((h x) :ys)

=

let y =h x in (if p y then y : (filterp ys) elsefilterp ys)

=

g x (filter p ys)

bei Wahl von

g x ys⁰ = let y =h x in (if p y then y :ys⁰ elseys⁰)

Folglich, mit genau diesemg:

filterp (map h l) = foldr g [ ] l

Wenig überraschend (?) entspricht diesesfoldr g [ ] in etwa dem schon zuvor hergeleitetenfilterMap p h.

(52)

Weniger Syntax — Mehr Struktur

Die Bedingung

lässt sich weiter analysieren:

filterp ((h x) :ys)

=

let y =h x in (if p y then y : (filterp ys) elsefilterp ys)

=

g x (filterp ys)

bei Wahl von

7

(53)

Weniger Syntax — Mehr Struktur

Die Bedingung

filterp ((h x) :ys)

= let y =h x in (if p y then y : (filterp ys) elsefilterp ys)

=

g x (filterp ys)

bei Wahl von

(54)

Weniger Syntax — Mehr Struktur

Die Bedingung

filterp ((h x) :ys)

= g x (filterp ys) bei Wahl von

7

(55)

Weniger Syntax — Mehr Struktur

Die Bedingung

filterp ((h x) :ys)

(56)

Weniger Syntax — Mehr Struktur

Die Bedingung

filterp ((h x) :ys)

Wenig überraschend (?) entspricht diesesfoldr g [ ]in etwa dem schon zuvor hergeleitetenfilterMap p h.

7

(57)

Problem: Zwischenergebnisse

Ein Beispiel:

filter((== 1)◦(‘mod‘3)) (map (ˆ2) [1..5])

= filter((== 1)◦(‘mod‘3)) (1: (map (ˆ2) [2..5]))

= 1: (filter((== 1)◦(‘mod‘3)) (map (ˆ2) [2..5]))

= 1: (filter((== 1)◦(‘mod‘3)) (4: (map (ˆ2) [3..5])))

= 1:4: (filter((== 1)◦(‘mod‘3)) (map (ˆ2) [3..5]))

= 1:4: (filter((== 1)◦(‘mod‘3)) (9: (map (ˆ2) [4,5])))

= 1:4: (filter((== 1)◦(‘mod‘3)) (map (ˆ2) [4,5]))

= 1:4: (filter((== 1)◦(‘mod‘3)) (16: (map (ˆ2) [5])))

= 1:4:16: (filter((== 1)◦(‘mod‘3)) (map(ˆ2) [5]))

= 1:4:16: (filter((== 1)◦(‘mod‘3)) (25: (map (ˆ2) [ ])))

= 1:4:16:25: (filter((== 1)◦(‘mod‘3)) (map(ˆ2) [ ]))

= 1:4:16:25: (filter((== 1)◦(‘mod‘3)) [ ] )

(58)

Short Cut Deforestation [Gill et al. 1993]

Schreibe Listenkonsumenten mittelsfoldr:

foldr f k ( : x1 :

x2 X : xn [ ]

) = f x1 f

x2 X

f xn k

Schreibe Listenerzeuger mittelsbuild:

build:: (∀β.(α→β→β)→β →β)→[α] build prod =prod (:) [ ]

9

(59)

Short Cut Deforestation [Gill et al. 1993]

foldr f k ( : x1 :

x2 X : xn [ ]

) = f x1 f

x2 X

f xn k

build:: (∀β.(α→β→β)→β →β)→[α]

build prod =prod (:) [ ]

(60)

Short Cut Deforestation [Gill et al. 1993]

foldr f k ( : x1 :

x2 X : xn [ ]

) = f x1 f

x2 X

f xn k

build:: (∀β.(α→β→β)→β →β)→[α]

build prod =prod (:) [ ]

9

(61)

Short Cut Deforestation [Gill et al. 1993]

Jedes derart polymorpheprod muss einer Funktion der folgenden Form entsprechen, für festen≥0 undx₁, . . . ,x_n:

prod = λf k → f x1 f

x2 X

f xn k

Zum Beispiel:

filter:: (α →Bool)→[α]→[α]

filterp l =build (λf k→let f⁰ x y |p x =f x y

|otherwise=y in foldr f⁰ k l)

(62)

Short Cut Deforestation [Gill et al. 1993]

Jedes derart polymorpheprod muss einer Funktion der folgenden Form entsprechen, für festen≥0 undx₁, . . . ,x_n:

prod = λf k → f x1 f

x2 X

f xn k

Zum Beispiel:

filter:: (α→Bool)→[α]→[α]

filterp l =build (λf k →let f⁰ x y |p x =f x y

10

(63)

Short Cut Deforestation [Gill et al. 1993]

Benutze folgende Regel:

foldrf k (build prod) prod f k

Zur Rechtfertigung:

Für den Compiler (GHC):

{−#RULES “foldr/build”

∀(prod ::∀β.(α→β →β)→β →β)f k. foldrf k (build prod) =prod f k #−}

(64)

Short Cut Deforestation [Gill et al. 1993]

foldr f⁰ k⁰ (build prod) prod f⁰ k⁰

Zur Rechtfertigung:

11

(65)

Short Cut Deforestation [Gill et al. 1993]

foldr f⁰ k⁰ (build prod) prod f⁰ k⁰ Zur Rechtfertigung:

foldr f⁰ k⁰ (buildprod)

(66)

Short Cut Deforestation [Gill et al. 1993]

foldr f⁰ k⁰ (build (λf k → f x1 f

x2 X

f xn k

))

11

(67)

Short Cut Deforestation [Gill et al. 1993]

foldrf⁰ k⁰ ( : x1 :

x2 X : xn [ ]

)

(68)

Short Cut Deforestation [Gill et al. 1993]

Zur Rechtfertigung:

f^′ x1 f^′

x2 X

f^′ xn k^′

11

(69)

Short Cut Deforestation [Gill et al. 1993]

Zur Rechtfertigung:

f^′ x1 f^′

x2 X

f^′ xn k^′

(70)

Formaler Korrektheitsbeweis

Gegeben seiprod ::∀β.(τ →β→β)→β →β.

Dann:

(prod,prod)∈ ∀R.(id_τ → R → R)→(R → R)

⇔ ∀R.∀(f₁,f₂)∈(id_τ → R → R).∀(k₁,k₂)∈ R.

(prod_τ₁ f₁ k₁,prod_τ₂ f₂ k₂)∈ R

⇒ ((:),f₂)∈(id_τ →(foldr f₂ k₂)→(foldrf₂ k₂))

∧ ([ ],k₂)∈(foldrf₂ k₂)

⇒ (prod_[τ] (:) [ ],prod_τ⁰ f₂ k₂)∈(foldr f₂ k₂)

⇔foldr f₂ k₂ (prod_[τ] (:) [ ]) = prod_τ0 f₂ k₂

⇔foldr f₂ k₂ (build prod) = prod_τ0 f₂ k₂

für jede mögliche Wahl vonf2 ::τ →τ⁰→τ⁰ undk2 ::τ⁰.

12

(71)

Formaler Korrektheitsbeweis

Dann:

⇔ ∀R.∀(f₁,f₂)∈(id_τ → R → R).∀(k₁,k₂)∈ R.

∧ ([ ],k₂)∈(foldrf₂ k₂)

⇒ (prod_[τ] (:) [ ],prod_τ⁰ f₂ k₂)∈(foldr f₂ k₂)

für jede mögliche Wahl vonf2 ::τ →τ⁰→τ⁰ undk2 ::τ⁰.

(72)

Formaler Korrektheitsbeweis

Dann:

⇔ ∀R.∀(f₁,f₂)∈(id_τ → R → R).∀(k₁,k₂)∈ R.

(prod_τ₁ f₁ k₁,prod_τ₂ f₂ k₂)∈ R wegen Definition von ∀R.F(R)und R → S

⇒ ((:),f₂)∈(idτ →(foldr f₂ k₂)→(foldrf₂ k₂))

∧ ([ ],k₂)∈(foldrf₂ k₂)

⇒ (prod_[τ] (:) [ ],prod_τ⁰ f2 k2)∈(foldr f2 k2)

⇔foldr f₂ k₂ (prod_[τ] (:) [ ]) = prod_τ⁰ f₂ k₂

für jede mögliche Wahl vonf₂ ::τ →τ⁰→τ⁰ undk₂ ::τ⁰.

12

(73)

Formaler Korrektheitsbeweis

Dann:

⇔∀R.∀(f₁,f₂)∈(id_τ → R → R).∀(k₁,k₂)∈ R.

∧ ([ ],k₂)∈(foldrf₂ k₂)

⇒ (prod_[τ] (:) [ ],prod_τ⁰ f₂ k₂)∈(foldrf₂ k₂)

durch Spezialisierung zu R=foldrf₂ k₂,f₁= (:)und k₁= [ ]

⇔foldr f₂ k₂ (prod_[τ] (:) [ ]) = prod_τ⁰ f₂ k₂

(74)

Formaler Korrektheitsbeweis

Dann:

⇔ ∀R.∀(f₁,f₂)∈(id_τ → R → R).∀(k₁,k₂)∈ R.

∧ ([ ],k₂)∈(foldrf₂ k₂)

⇔foldr f₂ k₂ (prod_[τ] (:) [ ]) = prod_τ0 f₂ k₂ durch Vereinfachung

12

(75)

Formaler Korrektheitsbeweis

Dann:

⇔ ∀R.∀(f₁,f₂)∈(id_τ → R → R).∀(k₁,k₂)∈ R.

∧ ([ ],k₂)∈(foldrf₂ k₂)

⇔foldr f₂ k₂ (build prod) = prod_τ0 f₂ k₂ per Definition von build

(76)

Formaler Korrektheitsbeweis

Dann:

⇔ ∀R.∀(f₁,f₂)∈(id_τ → R → R).∀(k₁,k₂)∈ R.

∧ ([ ],k₂)∈(foldrf₂ k₂)

12

(77)

Anwendung am Beispiel

Funktionen mittelsfoldr undbuild schreiben:

filter:: (α→Bool)→[α]→[α]

filterp l =build (λf k →let f⁰ x y |p x =f x y

map:: (α→β)→[α]→[β]

map h l =build (λf k →foldr(λx y →f (h x) y) k l)

Dann:

filterp (map h l)

= build(λf k →

letf⁰ · · ·=· · · in foldrf⁰ k

(build (λf k →foldr(λx y →f (h x) y) k l)))

= build(λf k →

letf⁰ · · ·=· · ·

in foldr(λx y →f⁰ (h x) y) k l)