Free Theorems about Monadic Code Janis Voigtl ander University of - - PowerPoint PPT Presentation

Free Theorems about Monadic Code

Janis Voigtl¨ ander

University of Bonn

EWCE’11

Functional Programming and Reasoning

Goodies of (pure) FP:

◮ declarative ◮ abstraction/modularity ◮ referential transparency

1

Functional Programming and Reasoning

Goodies of (pure) FP:

◮ declarative ◮ abstraction/modularity ◮ referential transparency

Methods for analysing/verifying programs:

◮ equational reasoning ◮ algebraic and logical techniques ◮ type-based reasoning

1

Programming with Side Effects (in Haskell)

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

2

Programming with Side Effects (in Haskell)

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

◮ program in imperative style where wanted

2

Programming with Side Effects (in Haskell)

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

◮ program in imperative style where wanted ◮ . . . , and only there!

2

Programming with Side Effects (in Haskell)

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

◮ program in imperative style where wanted ◮ . . . , and only there! ◮ type system ensures separation

2

Programming with Side Effects (in Haskell)

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

◮ program in imperative style where wanted ◮ . . . , and only there! ◮ type system ensures separation ◮ abstraction mechanisms fully available

2

Programming with Side Effects (in Haskell)

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

◮ program in imperative style where wanted ◮ . . . , and only there! ◮ type system ensures separation ◮ abstraction mechanisms fully available

But: formal reasoning techniques?

2

Papers (at the time)

• A. Filinski and K. Støvring.

Inductive reasoning about effectful data types. In International Conference on Functional Programming, Proceedings, pages 97–110. ACM Press, 2007.

• G. Hutton and D. Fulger.

Reasoning about effects: Seeing the wood through the trees. In Trends in Functional Programming, Draft Proceedings, 2008.

• 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.

3

Free Theorems [Wadler ’89]

For every function g :: [α] → [α] it holds map f (g l) = g (map f l) for arbitrary f and l, where map :: (α → β) → [α] → [β] map f [ ] = [ ] map f (a : as) = (f a) : (map f as)

4

Free Theorems [Wadler ’89]

For every function g :: [α] → [α] it holds map f (g l) = g (map f l) for arbitrary f and l, where map :: (α → β) → [α] → [β] map f [ ] = [ ] map f (a : as) = (f a) : (map f as) Some applications:

◮ efficiency improving program transformations [Gill et al. ’93] ◮ meta-theorems about classes of algorithms [V. ’08a] ◮ solutions to the view-update problem [V. ’09a] ◮ reducing testing effort [Bernardy et al. ’10]

4

From Programming to Reasoning

From: You must judge for yourself, but I believe that the monadic approach to programming, in which actions are first class values, is itself interesting, beautiful, and

• modular. In short, Haskell is the world’s finest imperative

programming language. [Peyton Jones ’01]

5

From Programming to Reasoning

From: You must judge for yourself, but I believe that the monadic approach to programming, in which actions are first class values, is itself interesting, beautiful, and

• modular. In short, Haskell is the world’s finest imperative

programming language. [Peyton Jones ’01] To: Parametricity [Wadler ’89] allows the derivation of theorems for a whole class of programs, only knowing their type. Voigtl¨ ander [V. ’09b] has recently shown how to extend the parametricity approach to type constructor classes such as Monad. This way we can derive theorems about effectful programs without knowing the particular effects used. [Oliveira et al. ’10]

5

Monads in Haskell

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

6

Monads in Haskell

Example 1: echo :: IO () echo = do c ← getChar when (c = ‘∗’) $ do putChar c echo Example 2: sequence :: Monad m ⇒ [m a] → m [a] sequence [ ] = return [ ] sequence (m : ms) = do a ← m as ← sequence ms return (a : as)

6

Monads in Haskell

Example 1: echo :: IO () echo = do c ← getChar when (c = ‘∗’) $ do putChar c echo Example 2: sequence :: Monad m ⇒ [m a] → m [a] sequence [ ] = return [ ] sequence (m : ms) = do a ← m as ← sequence ms return (a : as)

6

Effectful

• perations!

Monads in Haskell

Example 1: echo :: IO () echo = do c ← getChar when (c = ‘∗’) $ do putChar c echo Example 2: sequence :: Monad m ⇒ [m a] → m [a] sequence [ ] = return [ ] sequence (m : ms) = do a ← m as ← sequence ms return (a : as)

6

Effectful

• perations!

A specific monad!

Monads in Haskell

Example 1: echo :: IO () echo = do c ← getChar when (c = ‘∗’) $ do putChar c echo Example 2: sequence :: Monad m ⇒ [m a] → m [a] sequence [ ] = return [ ] sequence (m : ms) = do a ← m as ← sequence ms return (a : as)

6

Effectful

• perations!

A specific monad! Parametric over a monad!

Monads in Haskell

Example 1: echo :: IO () echo = do c ← getChar when (c = ‘∗’) $ do putChar c echo Example 2: sequence :: Monad m ⇒ [m a] → m [a] sequence [ ] = return [ ] sequence (m : ms) = do a ← m as ← sequence ms return (a : as)

6

Effectful

• perations!

A specific monad! Parametric over a monad! No specific (new) effects!

Monads in Haskell

Example 2: sequence :: Monad m ⇒ [m a] → m [a] sequence [ ] = return [ ] sequence (m : ms) = do a ← m as ← sequence ms return (a : as)

6

Parametric over a monad! No specific (new) effects!

Monads in Haskell

Example 2: sequence :: Monad m ⇒ [m a] → m [a]

6

Parametric over a monad! No specific (new) effects!

A Slightly More Simple Example

f :: Monad m ⇒ m a → m a → m a f m1 m2 =

7

A Slightly More Simple Example

f :: Monad m ⇒ m a → m a → m a f m1 m2 = do m1

7

A Slightly More Simple Example

f :: Monad m ⇒ m a → m a → m a f m1 m2 = do m1 a ← m1

7

A Slightly More Simple Example

f :: Monad m ⇒ m a → m a → m a f m1 m2 = do m1 a ← m1 m2

7

A Slightly More Simple Example

f :: Monad m ⇒ m a → m a → m a f m1 m2 = do m1 a ← m1 m2 b ← m1

7

A Slightly More Simple Example

f :: Monad m ⇒ m a → m a → m a f m1 m2 = do m1 a ← m1 m2 b ← m1 c ← m2

7

A Slightly More Simple Example

f :: Monad m ⇒ m a → m a → m a f m1 m2 = do m1 a ← m1 m2 b ← m1 c ← m2 return b

7

A Slightly More Simple Example

f :: Monad m ⇒ m a → m a → m a f m1 m2 = do m1 a ← m1 m2 b ← m1 c ← m2 return b

7

No effects introduced!

A Slightly More Simple Example

f :: Monad m ⇒ m a → m a → m a f m1 m2 = do m1 a ← m1 m2 b ← m1 c ← m2 return b

7

No effects introduced! But m1, m2 may encapsulate ones!

A Slightly More Simple Example

Assume m1, m2 are pure. f :: Monad m ⇒ m a → m a → m a f m1 m2 = do m1 a ← m1 m2 b ← m1 c ← m2 return b

7

A Slightly More Simple Example

Assume m1, m2 are pure. That is, m1 = (return u) and m2 = (return v) for some u, v. f :: Monad m ⇒ m a → m a → m a f m1 m2 = do m1 a ← m1 m2 b ← m1 c ← m2 return b

7

A Slightly More Simple Example

Assume m1, m2 are pure. That is, m1 = (return u) and m2 = (return v) for some u, v. Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do return u a ← return u return v b ← return u c ← return v return b

7

A Slightly More Simple Example

Assume m1, m2 are pure. That is, m1 = (return u) and m2 = (return v) for some u, v. Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do return u a ← return u return v b ← return u c ← return v return b (return u) > > m = m

7

A Slightly More Simple Example

Assume m1, m2 are pure. That is, m1 = (return u) and m2 = (return v) for some u, v. Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do return u a ← return u return v b ← return u c ← return v return b (return u) > > m = m

7

A Slightly More Simple Example

Assume m1, m2 are pure. That is, m1 = (return u) and m2 = (return v) for some u, v. Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do a ← return u return v b ← return u c ← return v return b (return u) > > m = m

7

A Slightly More Simple Example

Assume m1, m2 are pure. That is, m1 = (return u) and m2 = (return v) for some u, v. Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do a ← return u return v b ← return u c ← return v return b (return u) > > = (λa → m) = m[u/a]

7

A Slightly More Simple Example

Assume m1, m2 are pure. That is, m1 = (return u) and m2 = (return v) for some u, v. Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do return v b ← return u c ← return v return b (return u) > > = (λa → m) = m[u/a]

7

A Slightly More Simple Example

Assume m1, m2 are pure. That is, m1 = (return u) and m2 = (return v) for some u, v. Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do return v b ← return u c ← return v return b (return v) > > m = m

7

A Slightly More Simple Example

Assume m1, m2 are pure. That is, m1 = (return u) and m2 = (return v) for some u, v. Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do b ← return u c ← return v return b (return v) > > m = m

7

A Slightly More Simple Example

Assume m1, m2 are pure. That is, m1 = (return u) and m2 = (return v) for some u, v. Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do b ← return u c ← return v return b (return u) > > = (λb → m) = m[u/b]

7

A Slightly More Simple Example

Assume m1, m2 are pure. That is, m1 = (return u) and m2 = (return v) for some u, v. Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do c ← return v return u (return u) > > = (λb → m) = m[u/b]

7

A Slightly More Simple Example

Assume m1, m2 are pure. That is, m1 = (return u) and m2 = (return v) for some u, v. Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do c ← return v return u (return v) > > = (λc → m) = m[v/c]

7

A Slightly More Simple Example

Assume m1, m2 are pure. That is, m1 = (return u) and m2 = (return v) for some u, v. Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do return u (return v) > > = (λc → m) = m[v/c]

7

A Slightly More Simple Example

Assume m1, m2 are pure. That is, m1 = (return u) and m2 = (return v) for some u, v. Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do return u Purity is propagated!

7

A Slightly More Simple Example

Assume m1, m2 are pure. That is, m1 = (return u) and m2 = (return v) for some u, v. Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do return u Purity is propagated! What about other “invariants”?

7

Propagating Invariants

f :: Monad m ⇒ m a → m a → m a f m1 m2 = do m1 a ← m1 m2 b ← m1 c ← m2 return b

8

Propagating Invariants

Assume m1, m2 :: State σ τ, f :: Monad m ⇒ m a → m a → m a f m1 m2 = do m1 a ← m1 m2 b ← m1 c ← m2 return b

8

Propagating Invariants

Assume m1, m2 :: State σ τ, but execState mi = id. f :: Monad m ⇒ m a → m a → m a f m1 m2 = do m1 a ← m1 m2 b ← m1 c ← m2 return b

8

Propagating Invariants

Assume m1, m2 :: State σ τ, but execState mi = id. Can we show that execState (f m1 m2) = id ? Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do m1 a ← m1 m2 b ← m1 c ← m2 return b

8

Propagating Invariants

Assume m1, m2 :: State σ τ, but execState mi = id. Can we show that execState (f m1 m2) = id ? Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do m1 a ← m1 m2 b ← m1 c ← m2 return b

8

s

Propagating Invariants

Assume m1, m2 :: State σ τ, but execState mi = id. Can we show that execState (f m1 m2) = id ? Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do m1 a ← m1 m2 b ← m1 c ← m2 return b

8

s s

Propagating Invariants

Assume m1, m2 :: State σ τ, but execState mi = id. Can we show that execState (f m1 m2) = id ? Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do m1 a ← m1 m2 b ← m1 c ← m2 return b

8

s s s

Propagating Invariants

Assume m1, m2 :: State σ τ, but execState mi = id. Can we show that execState (f m1 m2) = id ? Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do m1 a ← m1 m2 b ← m1 c ← m2 return b

8

s s s s

Propagating Invariants

Assume m1, m2 :: State σ τ, but execState mi = id. Can we show that execState (f m1 m2) = id ? Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do m1 a ← m1 m2 b ← m1 c ← m2 return b

8

s s s s s

Propagating Invariants

Assume m1, m2 :: State σ τ, but execState mi = id. Can we show that execState (f m1 m2) = id ? Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do m1 a ← m1 m2 b ← m1 c ← m2 return b

8

s s s s s s

Propagating Invariants

Assume m1, m2 :: State σ τ, but execState mi = id. Can we show that execState (f m1 m2) = id ? Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do m1 a ← m1 m2 b ← m1 c ← m2 return b

8

s s s s s s s

Propagating Invariants

Assume m1, m2 :: State σ τ, but execState mi = id. Can we show that execState (f m1 m2) = id ? Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do m1 a ← m1 m2 b ← m1 c ← m2 return b

8

s s s s s s s s

Propagating Invariants

Assume m1, m2 :: State σ τ, but execState mi = id. Can we show that execState (f m1 m2) = id ? Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do m1 a ← m1 m2 b ← m1 c ← m2 return b

8

s s s s s s s s s

Propagating Invariants

Assume m1, m2 :: State σ τ, but execState mi = id. Can we show that execState (f m1 m2) = id ? Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do m1 a ← m1 m2 b ← m1 c ← m2 return b

8

s s s s s s s s s s

Propagating Invariants

Assume m1, m2 :: State σ τ, but execState mi = id. Can we show that execState (f m1 m2) = id ? Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do m1 a ← m1 m2 b ← m1 c ← m2 return b

8

s s s s s s s s s s s

Propagating Invariants

Assume m1, m2 :: State σ τ, but execState mi = id. Can we show that execState (f m1 m2) = id ? Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do m1 a ← m1 m2 b ← m1 c ← m2 return b

8

s s s s s s s s s s s s

Propagating Invariants

Assume m1, m2 :: State σ τ, but execState mi = id. Can we show that execState (f m1 m2) = id ? Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do m1 a ← m1 m2 b ← m1 c ← m2 return b

8

Propagating Invariants

Assume m1, m2 :: State σ τ, but execState mi = id. Can we show that execState (f m1 m2) = id ? Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do m1 a ← m1 m2 b ← m1 c ← m2 State (λs → (b, s))

8

Propagating Invariants

Assume m1, m2 :: State σ τ, but execState mi = id. Can we show that execState (f m1 m2) = id ? Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do m1 a ← m1 m2 b ← m1 c ← State (λs → (· · ·, s)) State (λs → (b, s))

8

Propagating Invariants

Assume m1, m2 :: State σ τ, but execState mi = id. Can we show that execState (f m1 m2) = id ? Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do m1 a ← m1 m2 b ← m1 c ← State (λs → (· · ·, s)) State (λs → (b, s)) (State (λs → (· · ·, s))) > > = (λc → State (λs → (b, s))) = ?

8

Propagating Invariants

Assume m1, m2 :: State σ τ, but execState mi = id. Can we show that execState (f m1 m2) = id ? Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do m1 a ← m1 m2 b ← m1 State (λs → (b, s)) (State (λs → (· · ·, s))) > > = (λc → State (λs → (b, s))) = ?

8

Propagating Invariants

Assume m1, m2 :: State σ τ, but execState mi = id. Can we show that execState (f m1 m2) = id ? Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do m1 a ← m1 m2 b ← m1 State (λs → (b, s))

8

Propagating Invariants

Assume m1, m2 :: State σ τ, but execState mi = id. Can we show that execState (f m1 m2) = id ? Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do m1 a ← m1 m2 b ← State (λs → (· · ·, s)) State (λs → (b, s))

8

Propagating Invariants

Assume m1, m2 :: State σ τ, but execState mi = id. Can we show that execState (f m1 m2) = id ? Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do m1 a ← m1 m2 b ← State (λs → (· · ·, s)) State (λs → (b, s)) (State (λs → (· · ·, s))) > > = (λb → State (λs → (b, s))) = ?

8

Propagating Invariants

Assume m1, m2 :: State σ τ, but execState mi = id. Can we show that execState (f m1 m2) = id ? Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do m1 a ← m1 m2 State (λs → (· · ·, s)) (State (λs → (· · ·, s))) > > = (λb → State (λs → (b, s))) = ?

8

Propagating Invariants

Assume m1, m2 :: State σ τ, but execState mi = id. Can we show that execState (f m1 m2) = id ? Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do m1 a ← m1 m2 State (λs → (· · ·, s))

8

Propagating Invariants

Assume m1, m2 :: State σ τ, but execState mi = id. Can we show that execState (f m1 m2) = id ? Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do m1 a ← m1 State (λs → (· · ·, s)) State (λs → (· · ·, s))

8

Propagating Invariants

Assume m1, m2 :: State σ τ, but execState mi = id. Can we show that execState (f m1 m2) = id ? Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do m1 a ← m1 State (λs → (· · ·, s)) State (λs → (· · ·, s)) (State (λs → (· · ·, s))) > > (State (λs → (· · ·, s))) = ?

8

Propagating Invariants

Assume m1, m2 :: State σ τ, but execState mi = id. Can we show that execState (f m1 m2) = id ? Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do m1 a ← m1 State (λs → (· · ·, s)) (State (λs → (· · ·, s))) > > (State (λs → (· · ·, s))) = ?

8

Propagating Invariants

Assume m1, m2 :: State σ τ, but execState mi = id. Can we show that execState (f m1 m2) = id ? Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do m1 a ← m1 State (λs → (· · ·, s))

8

Propagating Invariants

Assume m1, m2 :: State σ τ, but execState mi = id. Can we show that execState (f m1 m2) = id ? Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do m1 a ← State (λs → (· · ·, s)) State (λs → (· · ·, s))

8

Propagating Invariants

Assume m1, m2 :: State σ τ, but execState mi = id. Can we show that execState (f m1 m2) = id ? Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do m1 a ← State (λs → (· · ·, s)) State (λs → (· · ·, s)) (State (λs → (· · ·, s))) > > = (λa → State (λs → (· · ·, s))) = ?

8

Propagating Invariants

Assume m1, m2 :: State σ τ, but execState mi = id. Can we show that execState (f m1 m2) = id ? Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do m1 State (λs → (· · ·, s)) (State (λs → (· · ·, s))) > > = (λa → State (λs → (· · ·, s))) = ?

8

Propagating Invariants

Assume m1, m2 :: State σ τ, but execState mi = id. Can we show that execState (f m1 m2) = id ? Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do m1 State (λs → (· · ·, s))

8

Propagating Invariants

Assume m1, m2 :: State σ τ, but execState mi = id. Can we show that execState (f m1 m2) = id ? Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do State (λs → (· · ·, s)) State (λs → (· · ·, s))

8

Propagating Invariants

Assume m1, m2 :: State σ τ, but execState mi = id. Can we show that execState (f m1 m2) = id ? Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do State (λs → (· · ·, s)) State (λs → (· · ·, s)) (State (λs → (· · ·, s))) > > (State (λs → (· · ·, s))) = ?

8

Propagating Invariants

Assume m1, m2 :: State σ τ, but execState mi = id. Can we show that execState (f m1 m2) = id ? Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do State (λs → (· · ·, s)) (State (λs → (· · ·, s))) > > (State (λs → (· · ·, s))) = ?

8

Propagating Invariants

Assume m1, m2 :: State σ τ, but execState mi = id. Can we show that execState (f m1 m2) = id ? Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do State (λs → (· · ·, s)) Yes!

8

Propagating Invariants

Assume m1, m2 :: State σ τ, but execState mi = id. Can we show that execState (f m1 m2) = id ? Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do State (λs → (· · ·, s)) Yes! What about other invariants, other monads, . . . ?

8

Propagating Invariants

Assume m1, m2 :: State σ τ, but execState mi = id. Can we show that execState (f m1 m2) = id ? Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do m1 a ← m1 m2 b ← m1 c ← m2 return b What about other invariants, other monads, . . . ?

8

Propagating Invariants

Assume m1, m2 :: State σ τ, but execState mi = id. Can we show that execState (f m1 m2) = id ? Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do m1 a ← m1 m2 b ← m1 c ← m2 return b What about other invariants, other monads, . . . ?

8

“induction over normal form”

Propagating Invariants

Assume m1, m2 :: State σ τ, but execState mi = id. Can we show that execState (f m1 m2) = id ? Then: f :: Monad m ⇒ m a → m a → m a f m1 m2 = do m1 a ← m1 m2 b ← m1 c ← m2 return b What about other invariants, other monads, . . . ?

8

“induction over normal form” [Prehofer ’99]

Consider a More Specific Type

Instead of f :: Monad m ⇒ m a → m a → m a now f :: Monad m ⇒ m Int → m Int → m Int

9

Consider a More Specific Type

Instead of f :: Monad m ⇒ m a → m a → m a now f :: Monad m ⇒ m Int → m Int → m Int Then more possible behaviours of f are possible: f :: Monad m ⇒ m Int → m Int → m Int f m1 m2 = do m1 a ← m1 m2 b ← m1 c ← m2 return b

9

Consider a More Specific Type

Instead of f :: Monad m ⇒ m a → m a → m a now f :: Monad m ⇒ m Int → m Int → m Int Then more possible behaviours of f are possible: f :: Monad m ⇒ m Int → m Int → m Int f m1 m2 = do m1 a ← m1 m2 b ← m1 if b > 0 then else return (a + b) do c ← m2 return b

9

Reasoning via Monad Embedding

Assume m1, m2 :: State σ τ, but execState mi = id. f :: Monad m ⇒ m a → m a → m a f m1 m2 = do m1 a ← m1 m2 b ← m1 c ← m2 return b

10

Reasoning via Monad Embedding

Assume m1, m2 :: State σ τ, but execState mi = id. An m has this property iff it is an h-image for h :: Reader σ a → State σ a h (Reader g) = State (λs → (g s, s)) f :: Monad m ⇒ m a → m a → m a f m1 m2 = do m1 a ← m1 m2 b ← m1 c ← m2 return b

10

Reasoning via Monad Embedding

Assume m1, m2 :: State σ τ, but execState mi = id. An m has this property iff it is an h-image for h :: Reader σ a → State σ a h (Reader g) = State (λs → (g s, s)) Then: f :: Monad m ⇒ m a → m a → m a f (h m′

1) (h m′ 2) = do h m′ 1

a ← h m′

1

h m′

2

b ← h m′

1

c ← h m′

2

return b f m′

1 m′ 2 = do m′ 1

a ← m′

1

m′

2

b ← m′

1

c ← m′

2

return b

10

Reasoning via Monad Embedding

Assume m1, m2 :: State σ τ, but execState mi = id. An m has this property iff it is an h-image for h :: Reader σ a → State σ a h (Reader g) = State (λs → (g s, s)) Then: f :: Monad m ⇒ m a → m a → m a f (h m′

1) (h m′ 2) = do h m′ 1

a ← h m′

1

h m′

2

b ← h m′

1

c ← h m′

2

return b f m′

1 m′ 2 = do m′ 1

a ← m′

1

m′

2

b ← m′

1

c ← m′

2

return b

10

Reasoning via Monad Embedding

Assume m1, m2 :: State σ τ, but execState mi = id. An m has this property iff it is an h-image for h :: Reader σ a → State σ a h (Reader g) = State (λs → (g s, s)) Then: f :: Monad m ⇒ m a → m a → m a f (h m′

1) (h m′ 2) = do h m′ 1

a ← h m′

1

h m′

2

b ← h m′

1

c ← h m′

2

return b f m′

1 m′ 2 = do m′ 1

a ← m′

1

m′

2

b ← m′

1

c ← m′

2

return b return b = h (return b)

10

Reasoning via Monad Embedding

Assume m1, m2 :: State σ τ, but execState mi = id. An m has this property iff it is an h-image for h :: Reader σ a → State σ a h (Reader g) = State (λs → (g s, s)) Then: f :: Monad m ⇒ m a → m a → m a f (h m′

1) (h m′ 2) = do h m′ 1

a ← h m′

1

h m′

2

b ← h m′

1

c ← h m′

2

h (return b) f m′

1 m′ 2 = do m′ 1

a ← m′

1

m′

2

b ← m′

1

c ← m′

2

return b

10

Reasoning via Monad Embedding

Assume m1, m2 :: State σ τ, but execState mi = id. An m has this property iff it is an h-image for h :: Reader σ a → State σ a h (Reader g) = State (λs → (g s, s)) Then: f :: Monad m ⇒ m a → m a → m a f (h m′

1) (h m′ 2) = do h m′ 1

a ← h m′

1

h m′

2

b ← h m′

1

c ← h m′

2

h (return b) f m′

1 m′ 2 = do m′ 1

a ← m′

1

m′

2

b ← m′

1

c ← m′

2

return b

10

Reasoning via Monad Embedding

Assume m1, m2 :: State σ τ, but execState mi = id. An m has this property iff it is an h-image for h :: Reader σ a → State σ a h (Reader g) = State (λs → (g s, s)) Then: f :: Monad m ⇒ m a → m a → m a f (h m′

1) (h m′ 2) = do h m′ 1

a ← h m′

1

h m′

2

b ← h m′

1

c ← h m′

2

h (return b) f m′

1 m′ 2 = do m′ 1

a ← m′

1

m′

2

b ← m′

1

c ← m′

2

return b (h m′

2) >

> = (λc → h (return b)) = ?

10

Reasoning via Monad Embedding

Assume m1, m2 :: State σ τ, but execState mi = id. An m has this property iff it is an h-image for h :: Reader σ a → State σ a h (Reader g) = State (λs → (g s, s)) Then: f :: Monad m ⇒ m a → m a → m a f (h m′

1) (h m′ 2) = do h m′ 1

a ← h m′

1

h m′

2

b ← h m′

1

c ← h m′

2

h (return b) f m′

1 m′ 2 = do m′ 1

a ← m′

1

m′

2

b ← m′

1

c ← m′

2

return b (h m′

2) >

> = (λc → h (return b)) = h (m′

2 >

> = (λc → return b))

10

Reasoning via Monad Embedding

Assume m1, m2 :: State σ τ, but execState mi = id. An m has this property iff it is an h-image for h :: Reader σ a → State σ a h (Reader g) = State (λs → (g s, s)) Then: f :: Monad m ⇒ m a → m a → m a f (h m′

1) (h m′ 2) = do h m′ 1

a ← h m′

1

h m′

2

b ← h m′

1

h (do c ← m′

2

return b) f m′

1 m′ 2 = do m′ 1

a ← m′

1

m′

2

b ← m′

1

c ← m′

2

return b (h m′

2) >

> = (λc → h (return b)) = h (m′

2 >

> = (λc → return b))

10

Reasoning via Monad Embedding

Assume m1, m2 :: State σ τ, but execState mi = id. An m has this property iff it is an h-image for h :: Reader σ a → State σ a h (Reader g) = State (λs → (g s, s)) Then: f :: Monad m ⇒ m a → m a → m a f (h m′

1) (h m′ 2) = do h m′ 1

a ← h m′

1

h m′

2

b ← h m′

1

h (do c ← m′

2

return b) f m′

1 m′ 2 = do m′ 1

a ← m′

1

m′

2

b ← m′

1

c ← m′

2

return b

10

Reasoning via Monad Embedding

Assume m1, m2 :: State σ τ, but execState mi = id. An m has this property iff it is an h-image for h :: Reader σ a → State σ a h (Reader g) = State (λs → (g s, s)) Then: f :: Monad m ⇒ m a → m a → m a f (h m′

1) (h m′ 2) = do h m′ 1

a ← h m′

1

h m′

2

b ← h m′

1

h (do c ← m′

2

return b) f m′

1 m′ 2 = do m′ 1

a ← m′

1

m′

2

b ← m′

1

c ← m′

2

return b

10

Reasoning via Monad Embedding

Assume m1, m2 :: State σ τ, but execState mi = id. An m has this property iff it is an h-image for h :: Reader σ a → State σ a h (Reader g) = State (λs → (g s, s)) Then: f :: Monad m ⇒ m a → m a → m a f (h m′

1) (h m′ 2) = do h m′ 1

a ← h m′

1

h m′

2

b ← h m′

1

h (do c ← m′

2

return b) f m′

1 m′ 2 = do m′ 1

a ← m′

1

m′

2

b ← m′

1

c ← m′

2

return b (h m) > > = (h ◦ k) = ?

10

Reasoning via Monad Embedding

Assume m1, m2 :: State σ τ, but execState mi = id. An m has this property iff it is an h-image for h :: Reader σ a → State σ a h (Reader g) = State (λs → (g s, s)) Then: f :: Monad m ⇒ m a → m a → m a f (h m′

1) (h m′ 2) = do h m′ 1

a ← h m′

1

h m′

2

b ← h m′

1

h (do c ← m′

2

return b) f m′

1 m′ 2 = do m′ 1

a ← m′

1

m′

2

b ← m′

1

c ← m′

2

return b (h m) > > = (h ◦ k) = h (m > > = k)

10

Reasoning via Monad Embedding

Assume m1, m2 :: State σ τ, but execState mi = id. An m has this property iff it is an h-image for h :: Reader σ a → State σ a h (Reader g) = State (λs → (g s, s)) Then: f :: Monad m ⇒ m a → m a → m a f (h m′

1) (h m′ 2) = do h m′ 1

a ← h m′

1

h m′

2

h (do b ← m′

1

c ← m′

2

return b) f m′

1 m′ 2 = do m′ 1

a ← m′

1

m′

2

b ← m′

1

c ← m′

2

return b (h m) > > = (h ◦ k) = h (m > > = k)

10

Reasoning via Monad Embedding

Assume m1, m2 :: State σ τ, but execState mi = id. An m has this property iff it is an h-image for h :: Reader σ a → State σ a h (Reader g) = State (λs → (g s, s)) Then: f :: Monad m ⇒ m a → m a → m a f (h m′

1) (h m′ 2) = do h m′ 1

a ← h m′

1

h m′

2

h (do b ← m′

1

c ← m′

2

return b) f m′

1 m′ 2 = do m′ 1

a ← m′

1

m′

2

b ← m′

1

c ← m′

2

return b

10

Reasoning via Monad Embedding

Assume m1, m2 :: State σ τ, but execState mi = id. An m has this property iff it is an h-image for h :: Reader σ a → State σ a h (Reader g) = State (λs → (g s, s)) Then: f :: Monad m ⇒ m a → m a → m a f (h m′

1) (h m′ 2) = do h m′ 1

a ← h m′

1

h (do m′

2

b ← m′

1

c ← m′

2

return b) f m′

1 m′ 2 = do m′ 1

a ← m′

1

m′

2

b ← m′

1

c ← m′

2

return b

10

Reasoning via Monad Embedding

Assume m1, m2 :: State σ τ, but execState mi = id. An m has this property iff it is an h-image for h :: Reader σ a → State σ a h (Reader g) = State (λs → (g s, s)) Then: f :: Monad m ⇒ m a → m a → m a f (h m′

1) (h m′ 2) = do h m′ 1

h (do a ← m′

1

m′

2

b ← m′

1

c ← m′

2

return b) f m′

1 m′ 2 = do m′ 1

a ← m′

1

m′

2

b ← m′

1

c ← m′

2

return b

10

Reasoning via Monad Embedding

Assume m1, m2 :: State σ τ, but execState mi = id. An m has this property iff it is an h-image for h :: Reader σ a → State σ a h (Reader g) = State (λs → (g s, s)) Then: f :: Monad m ⇒ m a → m a → m a f (h m′

1) (h m′ 2) = do h (do m′ 1

a ← m′

1

m′

2

b ← m′

1

c ← m′

2

return b) f m′

1 m′ 2 = do m′ 1

a ← m′

1

m′

2

b ← m′

1

c ← m′

2

return b

10

Reasoning via Monad Embedding

Assume m1, m2 :: State σ τ, but execState mi = id. An m has this property iff it is an h-image for h :: Reader σ a → State σ a h (Reader g) = State (λs → (g s, s)) Then: f :: Monad m ⇒ m a → m a → m a f (h m′

1) (h m′ 2) = do h (do m′ 1

a ← m′

1

m′

2

b ← m′

1

c ← m′

2

return b) f m′

1 m′ 2 = do m′ 1

a ← m′

1

m′

2

b ← m′

1

c ← m′

2

return b f (h m′

1) (h m′ 2)

= h (f m′

1 m′ 2)

10

A More General Theorem

Let f :: Monad m ⇒ m Int → m Int → m Int Let h :: κ1 a → κ2 a such that

◮ κ1, κ2 are monads ◮ h ◦ returnκ1 = returnκ2 ◮ for every m and k, h (m >

> = κ1 k) = (h m) > > = κ2 (h ◦ k) Then for every m1 and m2, f (h m1) (h m2) = h (f m1 m2) The same for f :: Monad m ⇒ m a → m a → m a

11

A More General Theorem

Let f :: Monad m ⇒ m Int → m Int → m Int Let h :: κ1 a → κ2 a such that

◮ κ1, κ2 are monads ◮ h ◦ returnκ1 = returnκ2 ◮ for every m and k, h (m >

> = κ1 k) = (h m) > > = κ2 (h ◦ k) Then for every m1 and m2, f (h m1) (h m2) = h (f m1 m2) The same for f :: Monad m ⇒ m a → m a → m a

11

Looking Back at the Concrete Invariant

For h :: Reader σ a → State σ a h (Reader g) = State (λs → (g s, s))

12

Looking Back at the Concrete Invariant

For h :: Reader σ a → State σ a h (Reader g) = State (λs → (g s, s)) the conditions

◮ h ◦ returnReader σ = returnState σ ◮ for every m and k,

h (m > > = Reader σ k) = (h m) > > = State σ (h ◦ k)

12

Looking Back at the Concrete Invariant

For h :: Reader σ a → State σ a h (Reader g) = State (λs → (g s, s)) the conditions

◮ h ◦ returnReader σ = returnState σ ◮ for every m and k,

h (m > > = Reader σ k) = (h m) > > = State σ (h ◦ k) imply that

◮ for every a, execState (returnState σ a) = id

12

Looking Back at the Concrete Invariant

For h :: Reader σ a → State σ a h (Reader g) = State (λs → (g s, s)) the conditions

◮ h ◦ returnReader σ = returnState σ ◮ for every m and k,

h (m > > = Reader σ k) = (h m) > > = State σ (h ◦ k) imply that

◮ for every a, execState (returnState σ a) = id ◮ for every m and k, execState (m >

> = State σ k) = id, provided:

◮ execState m = id ◮ for every a, execState (k a) = id

12

A More General Theorem

Let f :: Monad m ⇒ m Int → m Int → m Int Let h :: κ1 a → κ2 a such that

◮ κ1, κ2 are monads ◮ h ◦ returnκ1 = returnκ2 ◮ for every m and k, h (m >

> = κ1 k) = (h m) > > = κ2 (h ◦ k) Then for every m1 and m2, f (h m1) (h m2) = h (f m1 m2) The same for f :: Monad m ⇒ m a → m a → m a

13

Conceptual Ingredients

◮ Exploiting polymorphism ◮ Relational parametricity [Reynolds ’83] ◮ Free theorems [Wadler ’89]

14

Conceptual Ingredients

◮ Exploiting polymorphism ◮ Relational parametricity [Reynolds ’83] ◮ Free theorems [Wadler ’89] ◮ Extension to type classes: ◮ Folklore ◮ via dictionary translation [Wadler & Blott ’89]

14

Conceptual Ingredients

◮ Exploiting polymorphism ◮ Relational parametricity [Reynolds ’83] ◮ Free theorems [Wadler ’89] ◮ Extension to type classes: ◮ Folklore ◮ via dictionary translation [Wadler & Blott ’89] ◮ Extension to type constructors: ◮ Folklore? ◮ a recent formal account [Vytiniotis & Weirich ’10]

14

Conceptual Ingredients

◮ Exploiting polymorphism ◮ Relational parametricity [Reynolds ’83] ◮ Free theorems [Wadler ’89] ◮ Extension to type classes: ◮ Folklore ◮ via dictionary translation [Wadler & Blott ’89] ◮ Extension to type constructors: ◮ Folklore? ◮ a recent formal account [Vytiniotis & Weirich ’10] ◮ Monad morphisms: ◮ Representation independence for effects

[Filinski & Støvring ’07, Filinski ’07]

14

Example Uses

◮ Invariant propagation, e.g.: ◮ Purity ◮ Independence criteria for stateful computations ◮ Restrictions on IO

15

Example Uses

◮ Invariant propagation, e.g.: ◮ Purity ◮ Independence criteria for stateful computations ◮ Restrictions on IO ◮ Safe value extraction, e.g.: ◮ Discard logging ◮ Pick from a nondeterministic manifold

15

Example Uses

◮ Invariant propagation, e.g.: ◮ Purity ◮ Independence criteria for stateful computations ◮ Restrictions on IO ◮ Safe value extraction, e.g.: ◮ Discard logging ◮ Pick from a nondeterministic manifold ◮ Effect abstraction, e.g. ◮ From exceptions to partiality

15

Example Uses

◮ Invariant propagation, e.g.: ◮ Purity ◮ Independence criteria for stateful computations ◮ Restrictions on IO ◮ Safe value extraction, e.g.: ◮ Discard logging ◮ Pick from a nondeterministic manifold ◮ Effect abstraction, e.g. ◮ From exceptions to partiality ◮ Proper generalisations of standard free theorems

15

Example Uses

◮ Invariant propagation, e.g.: ◮ Purity ◮ Independence criteria for stateful computations ◮ Restrictions on IO ◮ Safe value extraction, e.g.: ◮ Discard logging ◮ Pick from a nondeterministic manifold ◮ Effect abstraction, e.g. ◮ From exceptions to partiality ◮ Proper generalisations of standard free theorems ◮ Transparent introduction of data type improvements [V. ’08b]

15

Example Uses

◮ Invariant propagation, e.g.: ◮ Purity ◮ Independence criteria for stateful computations ◮ Restrictions on IO ◮ Safe value extraction, e.g.: ◮ Discard logging ◮ Pick from a nondeterministic manifold ◮ Effect abstraction, e.g. ◮ From exceptions to partiality ◮ Proper generalisations of standard free theorems ◮ Transparent introduction of data type improvements [V. ’08b] ◮ Reasoning about “harmless advice” [Oliveira et al. ’10]

15

EffectiveAdvice: Disciplined Advice with Explicit Effects

Advice/AOP:

◮ Separation of cross-cutting concerns in software

16

EffectiveAdvice: Disciplined Advice with Explicit Effects

Advice/AOP:

◮ Separation of cross-cutting concerns in software ◮ “Weaving”:

+ =

16

EffectiveAdvice: Disciplined Advice with Explicit Effects

Advice/AOP:

◮ Separation of cross-cutting concerns in software ◮ “Weaving”:

+ =

◮ Modular analysis/reasoning?

16

EffectiveAdvice: Disciplined Advice with Explicit Effects

Advice/AOP:

◮ Separation of cross-cutting concerns in software ◮ “Weaving”:

+ =

◮ Modular analysis/reasoning?

EffectiveAdvice [Oliveira et al. ’10]:

◮ semantic model, `

a la Open Modules [Aldrich ’05]

16

EffectiveAdvice: Disciplined Advice with Explicit Effects

Advice/AOP:

◮ Separation of cross-cutting concerns in software ◮ “Weaving”:

+ =

◮ Modular analysis/reasoning?

EffectiveAdvice [Oliveira et al. ’10]:

◮ semantic model, `

a la Open Modules [Aldrich ’05]

◮ allows modular reasoning . . .

16

EffectiveAdvice: Disciplined Advice with Explicit Effects

Advice/AOP:

◮ Separation of cross-cutting concerns in software ◮ “Weaving”:

+ =

◮ Modular analysis/reasoning?

EffectiveAdvice [Oliveira et al. ’10]:

◮ semantic model, `

a la Open Modules [Aldrich ’05]

◮ allows modular reasoning . . . ◮ in the presence of side effects!

16

EffectiveAdvice: Disciplined Advice with Explicit Effects

Specifics from AOP perspective:

◮ components explicitly specify their “entry points for advice”

— types, open recursion

17

EffectiveAdvice: Disciplined Advice with Explicit Effects

Specifics from AOP perspective:

◮ components explicitly specify their “entry points for advice”

— types, open recursion

◮ advice composition is explicit

— combinator library

17

EffectiveAdvice: Disciplined Advice with Explicit Effects

Specifics from AOP perspective:

◮ components explicitly specify their “entry points for advice”

— types, open recursion

◮ advice composition is explicit

— combinator library

◮ components state the effects they are using

— monads, transformers, specialized classes

17

EffectiveAdvice: Disciplined Advice with Explicit Effects

Specifics from AOP perspective:

◮ components explicitly specify their “entry points for advice”

— types, open recursion

◮ advice composition is explicit

— combinator library

◮ components state the effects they are using

— monads, transformers, specialized classes Benefits:

◮ equational reasoning

17

EffectiveAdvice: Disciplined Advice with Explicit Effects

Specifics from AOP perspective:

◮ components explicitly specify their “entry points for advice”

— types, open recursion

◮ advice composition is explicit

— combinator library

◮ components state the effects they are using

— monads, transformers, specialized classes Benefits:

◮ equational reasoning ◮ type shapes (higher-rank) capture interference patterns

17

EffectiveAdvice: Disciplined Advice with Explicit Effects

Specifics from AOP perspective:

◮ components explicitly specify their “entry points for advice”

— types, open recursion

◮ advice composition is explicit

— combinator library

◮ components state the effects they are using

— monads, transformers, specialized classes Benefits:

◮ equational reasoning ◮ type shapes (higher-rank) capture interference patterns ◮ correctness proofs about non-interference

17

EffectiveAdvice: Disciplined Advice with Explicit Effects

Theorem 2 (Harmless Observation Advice) [Oliveira et al. ’10]: Consider any base program and any advice with the types: bse :: ∀t. (MonadTrans t, . . . ) ⇒ Open (. . . ) adv :: ∀m. MGet σ m ⇒ Augment . . . If a function proj :: ∀m a. Monad m ⇒ τ m a → m a exists that satisfies . . . , then advice adv is harmless with respect to bse: proj ◦ (weave (adv ⊙ bse)) = runIdT ◦ (weave bse)

18

References I

• J. Aldrich.

Open Modules: Modular reasoning about advice. In European Conference on Object-Oriented Programming, Proceedings, volume 3586 of LNCS, pages 144–168. Springer-Verlag, 2005. J.-P. Bernardy, P. Jansson, and K. Claessen. Testing polymorphic properties. In European Symposium on Programming, Proceedings, volume 6012 of LNCS, pages 125–144. Springer-Verlag, 2010

• A. Filinski.

On the relations between monadic semantics. Theoretical Computer Science, 375(1–3):41–75, 2007.

19

References II

• A. Filinski and K. Støvring.

Inductive reasoning about effectful data types. In International Conference on Functional Programming, Proceedings, pages 97–110. ACM Press, 2007.

• A. Gill, J. Launchbury, and S.L. Peyton Jones.

A short cut to deforestation. In Functional Programming Languages and Computer Architecture, Proceedings, pages 223–232. ACM Press, 1993.

• G. Hutton and D. Fulger.

Reasoning about effects: Seeing the wood through the trees. In Trends in Functional Programming, Draft Proceedings, 2008.

20

References III

• E. Moggi.

Notions of computation and monads. Information and Computation, 93(1):55–92, 1991. B.C.d.S. Oliveira, T. Schrijvers, and W.R. Cook. EffectiveAdvice: Disciplined advice with explicit effects. In Aspect-Oriented Software Development, Proceedings, pages 109–120. ACM Press, 2010. S.L. Peyton Jones. Tackling the awkward squad: Monadic input/output, concurrency, exceptions, and foreign-language calls in Haskell. In Engineering Theories of Software Construction, Marktoberdorf Summer School 2000, Proceedings, pages 47–96. IOS Press, 2001.

21

References IV

S.L. Peyton Jones and P. Wadler. Imperative functional programming. In Principles of Programming Languages, Proceedings, pages 71–84. ACM Press, 1993.

• C. Prehofer.

Flexible construction of software components: A feature

• riented approach.

Habilitation Thesis, Technische Universit¨ at M¨ unchen, 1999. J.C. Reynolds. Types, abstraction and parametric polymorphism. In Information Processing, Proceedings, pages 513–523. Elsevier, 1983.

22

References V

• 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.

• J. Voigtl¨

ander. Much ado about two: A pearl on parallel prefix computation. In Principles of Programming Languages, Proceedings, pages 29–35. ACM Press, 2008a.

• J. Voigtl¨

ander. Asymptotic improvement of computations over free monads. In Mathematics of Program Construction, Proceedings, volume 5133 of LNCS, pages 388–403. Springer-Verlag, 2008b.

23

References VI

• J. Voigtl¨

ander. Bidirectionalization for free! In Principles of Programming Languages, Proceedings, pages 165–176. ACM Press, 2009a.

• J. Voigtl¨

ander. Free theorems involving type constructor classes. In International Conference on Functional Programming, Proceedings, pages 173–184. ACM Press, 2009b.

• D. Vytiniotis and S. Weirich.

Parametricity, type equality, and higher-order polymorphism. Journal of Functional Programming, 20(2):175–210, 2010.

24

References VII

• P. Wadler.

Theorems for free! In Functional Programming Languages and Computer Architecture, Proceedings, pages 347–359. ACM Press, 1989.

• P. Wadler.

The essence of functional programming (Invited talk). In Principles of Programming Languages, Proceedings, pages 1–14. ACM Press, 1992.

• P. Wadler and S. Blott.

How to make ad-hoc polymorphism less ad hoc. In Principles of Programming Languages, Proceedings, pages 60–76. ACM Press, 1989.

25