Asymptotic Improvement of Computations over Free Monads Janis - - PowerPoint PPT Presentation

Asymptotic Improvement of Computations over Free Monads

Janis Voigtl¨ ander

Technische Universit¨ at Dresden

MPC’08

Monads for IO in Haskell

Program: echo :: IO () echo = do c ← getChar when (c = ‘∗’) $ do putChar c echo

2

Monads for IO in Haskell

Program: echo :: IO () echo = do c ← getChar when (c = ‘∗’) $ do putChar c echo Behaviour: stdin : stdout :

2

Monads for IO in Haskell

Program: echo :: IO () echo = do c ← getChar when (c = ‘∗’) $ do putChar c echo Behaviour: stdin : a stdout : a

2

Monads for IO in Haskell

Program: echo :: IO () echo = do c ← getChar when (c = ‘∗’) $ do putChar c echo Behaviour: stdin : a b stdout : a b

2

Monads for IO in Haskell

Program: echo :: IO () echo = do c ← getChar when (c = ‘∗’) $ do putChar c echo Behaviour: stdin : a b c stdout : a b c

2

Monads for IO in Haskell

Program: echo :: IO () echo = do c ← getChar when (c = ‘∗’) $ do putChar c echo Behaviour: stdin : a b c ∗ stdout : a b c

2

Monads for IO in Haskell

Program: echo :: IO () echo = do c ← getChar when (c = ‘∗’) $ do putChar c echo Behaviour: stdin : a b c ∗ stdout : a b c

2

Testing IO Programs: IOSpec [Swierstra & Altenkirch, 07]

Program: echo :: IOSpec Teletype () echo = do c ← getChar when (c = ‘∗’) $ do putChar c echo

3

Testing IO Programs: IOSpec [Swierstra & Altenkirch, 07]

Program: echo :: IOSpec Teletype () echo = do c ← getChar when (c = ‘∗’) $ do putChar c echo Testing: > run (evalIOSpec echo singleThreaded) “abc∗”

3

Testing IO Programs: IOSpec [Swierstra & Altenkirch, 07]

Program: echo :: IOSpec Teletype () echo = do c ← getChar when (c = ‘∗’) $ do putChar c echo Testing: > run (evalIOSpec echo singleThreaded) “abc∗” Read (Print ‘a’ (Read (Print ‘b’ (Read (Print ‘c’ (Read (Finish ())))))))

3

Testing IO Programs: IOSpec [Swierstra & Altenkirch, 07]

Program: echo :: IOSpec Teletype () echo = do c ← getChar when (c = ‘∗’) $ do putChar c echo Testing: prop cs = run (evalIOSpec echo singleThreaded) (cs + + “∗”) ≡ copy cs where copy (c : cs) = Read (Print c (copy cs)) copy [ ] = Read (Finish ())

3

Testing IO Programs: IOSpec [Swierstra & Altenkirch, 07]

Program: echo :: IOSpec Teletype () echo = do c ← getChar when (c = ‘∗’) $ do putChar c echo Testing: prop cs = run (evalIOSpec echo singleThreaded) (cs + + “∗”) ≡ copy cs where copy (c : cs) = Read (Print c (copy cs)) copy [ ] = Read (Finish ()) > quickCheck prop OK, passed 100 tests.

3

A Slight Variation of the Example

Program: revEcho :: IO () revEcho = do c ← getChar when (c = ‘∗’) $ do revEcho putChar c

4

A Slight Variation of the Example

Program: revEcho :: IO () revEcho = do c ← getChar when (c = ‘∗’) $ do revEcho putChar c Behaviour: stdin : stdout :

4

A Slight Variation of the Example

Program: revEcho :: IO () revEcho = do c ← getChar when (c = ‘∗’) $ do revEcho putChar c Behaviour: stdin : a stdout :

4

A Slight Variation of the Example

Program: revEcho :: IO () revEcho = do c ← getChar when (c = ‘∗’) $ do revEcho putChar c Behaviour: stdin : a b stdout :

4

A Slight Variation of the Example

Program: revEcho :: IO () revEcho = do c ← getChar when (c = ‘∗’) $ do revEcho putChar c Behaviour: stdin : a b c stdout :

4

A Slight Variation of the Example

Program: revEcho :: IO () revEcho = do c ← getChar when (c = ‘∗’) $ do revEcho putChar c Behaviour: stdin : a b c ∗ stdout : c b a

4

A Slight Variation of the Example

Program: revEcho :: IO () revEcho = do c ← getChar when (c = ‘∗’) $ do revEcho putChar c Behaviour: stdin : a b c ∗ stdout : c b a

4

A Slight Variation of the Example

Program: revEcho :: IOSpec Teletype () revEcho = do c ← getChar when (c = ‘∗’) $ do revEcho putChar c Testing: > run (evalIOSpec revEcho singleThreaded) “abc∗”

4

A Slight Variation of the Example

Program: revEcho :: IOSpec Teletype () revEcho = do c ← getChar when (c = ‘∗’) $ do revEcho putChar c Testing: > run (evalIOSpec revEcho singleThreaded) “abc∗” Read (Read (Read (Read (Print ‘c’ (Print ‘b’ (Print ‘a’ (Finish ())))))))

4

A Slight Variation of the Example

Program: revEcho :: IOSpec Teletype () revEcho = do c ← getChar when (c = ‘∗’) $ do revEcho putChar c Testing: prop cs = run (evalIOSpec revEcho singleThreaded) (cs + + “∗”) ≡ mirror cs (Finish ()) where mirror (c : cs) acc = Read (mirror cs (Print c acc)) mirror [ ] acc = Read acc

4

A Slight Variation of the Example

Program: revEcho :: IOSpec Teletype () revEcho = do c ← getChar when (c = ‘∗’) $ do revEcho putChar c Testing: prop cs = run (evalIOSpec revEcho singleThreaded) (cs + + “∗”) ≡ mirror cs (Finish ()) where mirror (c : cs) acc = Read (mirror cs (Print c acc)) mirror [ ] acc = Read acc > quickCheck prop OK, passed 100 tests.

4

A Slight Variation of the Example: Ouch!

Program: revEcho :: IOSpec Teletype () revEcho = do c ← getChar when (c = ‘∗’) $ do revEcho putChar c Testing: prop cs = run (evalIOSpec revEcho singleThreaded) (cs + + “∗”) ≡ mirror cs (Finish ()) where mirror (c : cs) acc = Read (mirror cs (Print c acc)) mirror [ ] acc = Read acc > quickCheck prop OK, passed 100 tests. But each test takes quadratic time!

4

But Why?

Let’s take a closer look at “IOSpec Teletype”, henceforth “IOtt”.

5

But Why?

Let’s take a closer look at “IOSpec Teletype”, henceforth “IOtt”. data IOtt α = GetChar (Char → IOtt α) | PutChar Char (IOtt α) | Return α

5

But Why?

Let’s take a closer look at “IOSpec Teletype”, henceforth “IOtt”. data IOtt α = GetChar (Char → IOtt α) | PutChar Char (IOtt α) | Return α instance Monad IOtt where · · ·

5

But Why?

Let’s take a closer look at “IOSpec Teletype”, henceforth “IOtt”. data IOtt α = GetChar (Char → IOtt α) | PutChar Char (IOtt α) | Return α instance Monad IOtt where · · · getChar :: IOtt Char getChar = GetChar Return putChar :: Char → IOtt () putChar c = PutChar c (Return ())

5

But Why?

Let’s take a closer look at “IOSpec Teletype”, henceforth “IOtt”. data IOtt α = GetChar (Char → IOtt α) | PutChar Char (IOtt α) | Return α instance Monad IOtt where · · · getChar :: IOtt Char getChar = GetChar Return putChar :: Char → IOtt () putChar c = PutChar c (Return ()) run :: IOtt α → String → Output α run (GetChar f ) (c : cs) = Read (run (f c) cs) run (PutChar c p) cs = Print c (run p cs) run (Return a) cs = Finish a

5

But Why?

Now, revEcho desugared and with some inlining: revEcho :: IOtt () revEcho = GetChar f where f = λc → when (c = ‘∗’) $ revEcho > > putChar c

6

But Why?

Now, revEcho desugared and with some inlining: revEcho :: IOtt () revEcho = GetChar f where f = λc → when (c = ‘∗’) $ revEcho > > putChar c An example evaluation, counting (certain) steps: run revEcho “abc∗” a

6

But Why?

Now, revEcho desugared and with some inlining: revEcho :: IOtt () revEcho = GetChar f where f = λc → when (c = ‘∗’) $ revEcho > > putChar c An example evaluation, counting (certain) steps: run revEcho “abc∗” a

6

But Why?

Now, revEcho desugared and with some inlining: revEcho :: IOtt () revEcho = GetChar f where f = λc → when (c = ‘∗’) $ revEcho > > putChar c An example evaluation, counting (certain) steps: run GetChar f “abc∗” a

6

But Why?

Now, revEcho desugared and with some inlining: revEcho :: IOtt () revEcho = GetChar f where f = λc → when (c = ‘∗’) $ revEcho > > putChar c An example evaluation, counting (certain) steps: run GetChar f “abc∗” a run (GetChar f ) (c : cs) = Read (run (f c) cs)

6

But Why?

Now, revEcho desugared and with some inlining: revEcho :: IOtt () revEcho = GetChar f where f = λc → when (c = ‘∗’) $ revEcho > > putChar c An example evaluation, counting (certain) steps: Read run > > “bc∗” revEcho putChar ‘a’ a run (GetChar f ) (c : cs) = Read (run (f c) cs)

6

But Why?

Now, revEcho desugared and with some inlining: revEcho :: IOtt () revEcho = GetChar f where f = λc → when (c = ‘∗’) $ revEcho > > putChar c An example evaluation, counting (certain) steps: Read run > > “bc∗” revEcho putChar ‘a’ a run (GetChar f ) (c : cs) = Read (run (f c) cs)

6

But Why?

Now, revEcho desugared and with some inlining: revEcho :: IOtt () revEcho = GetChar f where f = λc → when (c = ‘∗’) $ revEcho > > putChar c An example evaluation, counting (certain) steps: Read run > > “bc∗” GetChar f putChar ‘a’ a run (GetChar f ) (c : cs) = Read (run (f c) cs)

6

But Why?

Now, revEcho desugared and with some inlining: revEcho :: IOtt () revEcho = GetChar f where f = λc → when (c = ‘∗’) $ revEcho > > putChar c An example evaluation, counting (certain) steps: Read run > > “bc∗” GetChar f putChar ‘a’ a run (GetChar f ) (c : cs) = Read (run (f c) cs) (GetChar f ) > > m = GetChar (λc → f c > > m)

6

But Why?

Now, revEcho desugared and with some inlining: revEcho :: IOtt () revEcho = GetChar f where f = λc → when (c = ‘∗’) $ revEcho > > putChar c An example evaluation, counting (certain) steps: 1 Read run GetChar “bc∗” λc > > f c putChar ‘a’ a run (GetChar f ) (c : cs) = Read (run (f c) cs) (GetChar f ) > > m = GetChar (λc → f c > > m)

6

But Why?

Now, revEcho desugared and with some inlining: revEcho :: IOtt () revEcho = GetChar f where f = λc → when (c = ‘∗’) $ revEcho > > putChar c An example evaluation, counting (certain) steps: 1 Read run GetChar “bc∗” λc > > f c putChar ‘a’ a run (GetChar f ) (c : cs) = Read (run (f c) cs) (GetChar f ) > > m = GetChar (λc → f c > > m)

6

But Why?

Now, revEcho desugared and with some inlining: revEcho :: IOtt () revEcho = GetChar f where f = λc → when (c = ‘∗’) $ revEcho > > putChar c An example evaluation, counting (certain) steps: 1 Read Read run > > “c∗” > > putChar ‘a’ revEcho putChar ‘b’ a run (GetChar f ) (c : cs) = Read (run (f c) cs) (GetChar f ) > > m = GetChar (λc → f c > > m)

6

But Why?

Now, revEcho desugared and with some inlining: revEcho :: IOtt () revEcho = GetChar f where f = λc → when (c = ‘∗’) $ revEcho > > putChar c An example evaluation, counting (certain) steps: 1 Read Read run > > “c∗” > > putChar ‘a’ revEcho putChar ‘b’ a run (GetChar f ) (c : cs) = Read (run (f c) cs) (GetChar f ) > > m = GetChar (λc → f c > > m)

6

But Why?

Now, revEcho desugared and with some inlining: revEcho :: IOtt () revEcho = GetChar f where f = λc → when (c = ‘∗’) $ revEcho > > putChar c An example evaluation, counting (certain) steps: 1 Read Read run > > “c∗” > > putChar ‘a’ GetChar f putChar ‘b’ a run (GetChar f ) (c : cs) = Read (run (f c) cs) (GetChar f ) > > m = GetChar (λc → f c > > m)

6

But Why?

Now, revEcho desugared and with some inlining: revEcho :: IOtt () revEcho = GetChar f where f = λc → when (c = ‘∗’) $ revEcho > > putChar c An example evaluation, counting (certain) steps: 1 Read Read run > > “c∗” > > putChar ‘a’ GetChar f putChar ‘b’ a run (GetChar f ) (c : cs) = Read (run (f c) cs) (GetChar f ) > > m = GetChar (λc → f c > > m)

6

But Why?

· · · where f = λc → when (c = ‘∗’) $ revEcho > > putChar c An example evaluation, counting (certain) steps: 1 + 1 Read Read run > > “c∗” GetChar putChar ‘a’ λc > > f c putChar ‘b’ a run (GetChar f ) (c : cs) = Read (run (f c) cs) (GetChar f ) > > m = GetChar (λc → f c > > m)

6

But Why?

· · · where f = λc → when (c = ‘∗’) $ revEcho > > putChar c An example evaluation, counting (certain) steps: 1 + 1 Read Read run > > “c∗” GetChar putChar ‘a’ λc > > f c putChar ‘b’ a run (GetChar f ) (c : cs) = Read (run (f c) cs) (GetChar f ) > > m = GetChar (λc → f c > > m)

6

But Why?

· · · where f = λc → when (c = ‘∗’) $ revEcho > > putChar c An example evaluation, counting (certain) steps: 1 + 2 Read Read run GetChar “c∗” λc > > > > putChar ‘a’ f c putChar ‘b’ a run (GetChar f ) (c : cs) = Read (run (f c) cs) (GetChar f ) > > m = GetChar (λc → f c > > m)

6

But Why?

· · · where f = λc → when (c = ‘∗’) $ revEcho > > putChar c An example evaluation, counting (certain) steps: 1 + 2 Read Read run GetChar “c∗” λc > > > > putChar ‘a’ f c putChar ‘b’ a run (GetChar f ) (c : cs) = Read (run (f c) cs) (GetChar f ) > > m = GetChar (λc → f c > > m)

6

But Why?

· · · where f = λc → when (c = ‘∗’) $ revEcho > > putChar c An example evaluation, counting (certain) steps: 1 + 2 Read Read Read run > > “∗” > > putChar ‘a’ > > putChar ‘b’ revEcho putChar ‘c’ a run (GetChar f ) (c : cs) = Read (run (f c) cs) (GetChar f ) > > m = GetChar (λc → f c > > m)

6

But Why?

· · · where f = λc → when (c = ‘∗’) $ revEcho > > putChar c An example evaluation, counting (certain) steps: 1 + 2 Read Read Read run > > “∗” > > putChar ‘a’ > > putChar ‘b’ revEcho putChar ‘c’ a run (GetChar f ) (c : cs) = Read (run (f c) cs) (GetChar f ) > > m = GetChar (λc → f c > > m)

6

But Why?

· · · where f = λc → when (c = ‘∗’) $ revEcho > > putChar c An example evaluation, counting (certain) steps: 1 + 2 Read Read Read run > > “∗” > > putChar ‘a’ > > putChar ‘b’ GetChar f putChar ‘c’ a run (GetChar f ) (c : cs) = Read (run (f c) cs) (GetChar f ) > > m = GetChar (λc → f c > > m)

6

But Why?

· · · where f = λc → when (c = ‘∗’) $ revEcho > > putChar c An example evaluation, counting (certain) steps: 1 + 2 Read Read Read run > > “∗” > > putChar ‘a’ > > putChar ‘b’ GetChar f putChar ‘c’ a run (GetChar f ) (c : cs) = Read (run (f c) cs) (GetChar f ) > > m = GetChar (λc → f c > > m)

6

But Why?

An example evaluation, counting (certain) steps: 1 + 2 + 1 Read Read Read run > > “∗” > > putChar ‘a’ GetChar putChar ‘b’ λc > > f c putChar ‘c’ a run (GetChar f ) (c : cs) = Read (run (f c) cs) (GetChar f ) > > m = GetChar (λc → f c > > m)

6

But Why?

An example evaluation, counting (certain) steps: 1 + 2 + 1 Read Read Read run > > “∗” > > putChar ‘a’ GetChar putChar ‘b’ λc > > f c putChar ‘c’ a run (GetChar f ) (c : cs) = Read (run (f c) cs) (GetChar f ) > > m = GetChar (λc → f c > > m)

6

But Why?

An example evaluation, counting (certain) steps: 1 + 2 + 2 Read Read Read run > > “∗” GetChar putChar ‘a’ λc > > > > putChar ‘b’ f c putChar ‘c’ a run (GetChar f ) (c : cs) = Read (run (f c) cs) (GetChar f ) > > m = GetChar (λc → f c > > m)

6

But Why?

An example evaluation, counting (certain) steps: 1 + 2 + 2 Read Read Read run > > “∗” GetChar putChar ‘a’ λc > > > > putChar ‘b’ f c putChar ‘c’ a run (GetChar f ) (c : cs) = Read (run (f c) cs) (GetChar f ) > > m = GetChar (λc → f c > > m)

6

But Why?

An example evaluation, counting (certain) steps: 1 + 2 + 3 Read Read Read run GetChar “∗” λc > > > > putChar ‘a’ > > putChar ‘b’ f c putChar ‘c’ a run (GetChar f ) (c : cs) = Read (run (f c) cs) (GetChar f ) > > m = GetChar (λc → f c > > m)

6

But Why?

An example evaluation, counting (certain) steps: 1 + 2 + 3 Read Read Read run GetChar “∗” λc > > > > putChar ‘a’ > > putChar ‘b’ f c putChar ‘c’ a run (GetChar f ) (c : cs) = Read (run (f c) cs) (GetChar f ) > > m = GetChar (λc → f c > > m)

6

But Why?

An example evaluation, counting (certain) steps: 1 + 2 + 3 Read Read Read run GetChar “∗” λc > > > > putChar ‘a’ > > putChar ‘b’ f c putChar ‘c’ a run (GetChar f ) (c : cs) = Read (run (f c) cs) (GetChar f ) > > m = GetChar (λc → f c > > m)

6

What to Do?

Switch type yet again: revEcho :: C () revEcho = do c ← getChar when (c = ‘∗’) $ do revEcho putChar c

7

What to Do?

Switch type yet again: revEcho :: C () revEcho = do c ← getChar when (c = ‘∗’) $ do revEcho putChar c type C α = ∀β. (α → IOtt β) → IOtt β

7

What to Do?

Switch type yet again: revEcho :: C () revEcho = do c ← getChar when (c = ‘∗’) $ do revEcho putChar c type C α = ∀β. (α → IOtt β) → IOtt β instance Monad C where · · ·

7

What to Do?

Switch type yet again: revEcho :: C () revEcho = do c ← getChar when (c = ‘∗’) $ do revEcho putChar c type C α = ∀β. (α → IOtt β) → IOtt β instance Monad C where · · · getChar :: C Char getChar = λh → GetChar (λc → h c) putChar :: Char → C () putChar c = λh → PutChar c (h ())

7

And Then?

Now, revEcho desugared and with some inlining: revEcho :: C () revEcho = λh → GetChar f where f = λc → (when (c = ‘∗’) $ revEcho > > putChar c) $ h

8

And Then?

Now, revEcho desugared and with some inlining: revEcho :: C () revEcho = λh → GetChar f where f = λc → (when (c = ‘∗’) $ revEcho > > putChar c) $ h An example evaluation: run $ “abc∗” revEcho Return a

8

And Then?

Now, revEcho desugared and with some inlining: revEcho :: C () revEcho = λh → GetChar f where f = λc → (when (c = ‘∗’) $ revEcho > > putChar c) $ h An example evaluation: run $ “abc∗” revEcho Return a run (GetChar f ) (c : cs) = Read (run (f c) cs)

8

And Then?

Now, revEcho desugared and with some inlining: revEcho :: C () revEcho = λh → GetChar f where f = λc → (when (c = ‘∗’) $ revEcho > > putChar c) $ h An example evaluation: Read run $ “bc∗” > > Return revEcho putChar ‘a’ a run (GetChar f ) (c : cs) = Read (run (f c) cs)

8

And Then?

Now, revEcho desugared and with some inlining: revEcho :: C () revEcho = λh → GetChar f where f = λc → (when (c = ‘∗’) $ revEcho > > putChar c) $ h An example evaluation: Read run $ “bc∗” > > Return revEcho putChar ‘a’ a run (GetChar f ) (c : cs) = Read (run (f c) cs) p > > m = λh → p $ (λ → m $ h)

8

And Then?

Now, revEcho desugared and with some inlining: revEcho :: C () revEcho = λh → GetChar f where f = λc → (when (c = ‘∗’) $ revEcho > > putChar c) $ h An example evaluation: Read run $ “bc∗” revEcho λ $ putChar ‘a’ Return a run (GetChar f ) (c : cs) = Read (run (f c) cs) p > > m = λh → p $ (λ → m $ h)

8

And Then?

Now, revEcho desugared and with some inlining: revEcho :: C () revEcho = λh → GetChar f where f = λc → (when (c = ‘∗’) $ revEcho > > putChar c) $ h An example evaluation: Read run $ “bc∗” revEcho λ $ putChar ‘a’ Return a run (GetChar f ) (c : cs) = Read (run (f c) cs) p > > m = λh → p $ (λ → m $ h)

8

And Then?

Now, revEcho desugared and with some inlining: revEcho :: C () revEcho = λh → GetChar f where f = λc → (when (c = ‘∗’) $ revEcho > > putChar c) $ h An example evaluation: Read Read run $ “c∗” > > λ revEcho putChar ‘b’ $ putChar ‘a’ Return a run (GetChar f ) (c : cs) = Read (run (f c) cs) p > > m = λh → p $ (λ → m $ h)

8

And Then?

Now, revEcho desugared and with some inlining: revEcho :: C () revEcho = λh → GetChar f where f = λc → (when (c = ‘∗’) $ revEcho > > putChar c) $ h An example evaluation: Read Read run $ “c∗” > > λ revEcho putChar ‘b’ $ putChar ‘a’ Return a run (GetChar f ) (c : cs) = Read (run (f c) cs) p > > m = λh → p $ (λ → m $ h)

8

And Then?

An example evaluation: Read Read run $ “c∗” revEcho λ $ putChar ‘b’ λ $ putChar ‘a’ Return a run (GetChar f ) (c : cs) = Read (run (f c) cs) p > > m = λh → p $ (λ → m $ h)

8

And Then?

An example evaluation: Read Read run $ “c∗” revEcho λ $ putChar ‘b’ λ $ putChar ‘a’ Return a run (GetChar f ) (c : cs) = Read (run (f c) cs) p > > m = λh → p $ (λ → m $ h)

8

And Then?

An example evaluation: Read Read Read run $ “∗” > > λ revEcho putChar ‘c’ $ putChar ‘b’ λ $ putChar ‘a’ Return a run (GetChar f ) (c : cs) = Read (run (f c) cs) p > > m = λh → p $ (λ → m $ h)

8

And Then?

An example evaluation: Read Read Read run $ “∗” > > λ revEcho putChar ‘c’ $ putChar ‘b’ λ $ putChar ‘a’ Return a run (GetChar f ) (c : cs) = Read (run (f c) cs) p > > m = λh → p $ (λ → m $ h)

8

And Then?

An example evaluation: Read Read Read run $ “∗” revEcho λ $ putChar ‘c’ λ $ putChar ‘b’ λ $ putChar ‘a’ Return a

8

And Then?

An example evaluation: Read Read Read run $ “∗” revEcho λ $ putChar ‘c’ λ $ putChar ‘b’ λ $ putChar ‘a’ Return a

8

And Then?

An example evaluation: Read Read Read run $ “∗” revEcho λ $ putChar ‘c’ λ $ putChar ‘b’ λ $ putChar ‘a’ Return a Overall, linear time!

8

More General Considerations

◮ Was the transformation semantically correct?

9

More General Considerations

◮ Was the transformation semantically correct? ◮ Is something similar possible for other data types?

9

More General Considerations

◮ Was the transformation semantically correct? ◮ Is something similar possible for other data types? ◮ How to provide the transformation to the programmer?

9

More General Considerations

◮ Was the transformation semantically correct?

⇒ program calculation, monad laws

◮ Is something similar possible for other data types? ◮ How to provide the transformation to the programmer?

9

More General Considerations

◮ Was the transformation semantically correct?

⇒ program calculation, monad laws

◮ Is something similar possible for other data types?

⇒ generic development for arbitrary free monads

◮ How to provide the transformation to the programmer?

9

More General Considerations

◮ Was the transformation semantically correct?

⇒ program calculation, monad laws

◮ Is something similar possible for other data types?

⇒ generic development for arbitrary free monads

◮ How to provide the transformation to the programmer?

⇒ type constructor classes, rank-2 types

9

More General Considerations

◮ Was the transformation semantically correct?

⇒ program calculation, monad laws

◮ Is something similar possible for other data types?

⇒ generic development for arbitrary free monads

◮ How to provide the transformation to the programmer?

⇒ type constructor classes, rank-2 types Next:

◮ even more monads?

9

More General Considerations

◮ Was the transformation semantically correct?

⇒ program calculation, monad laws

◮ Is something similar possible for other data types?

⇒ generic development for arbitrary free monads

◮ How to provide the transformation to the programmer?

⇒ type constructor classes, rank-2 types Next:

◮ even more monads? ◮ dual concepts?

9

More General Considerations

◮ Was the transformation semantically correct?

⇒ program calculation, monad laws

◮ Is something similar possible for other data types?

⇒ generic development for arbitrary free monads

◮ How to provide the transformation to the programmer?

⇒ type constructor classes, rank-2 types Next:

◮ even more monads? ◮ dual concepts? ◮ . . . ?

9

References

• K. Claessen and R.J.M. Hughes.

QuickCheck: A lightweight tool for random testing of Haskell programs. In International Conference on Functional Programming, Proceedings, pages 268–279. ACM Press, 2000.

• W. Swierstra and T. Altenkirch.

Beauty in the beast: A functional semantics for the awkward squad. In Haskell Workshop, Proceedings, pages 25–36. ACM Press, 2007.

• W. Swierstra.

Data types ` a la carte. Journal of Functional Programming, 18(4):423–436, 2008.

10