Polymorphic Contexts FP-Dag 2015

Transcription

1 Polymorphic Contexts FP-Dag 2015 Doaitse Swierstra January 14, 2015

2 Goal of this Talk To show you: that lazy evaluation requires a type system which extend beyond system-f how the Utrecht Haskell Compiler can handle such extensions how to achieve the desired effects in GHC anyway 2

3 Message to take home In languages with lazy evaluation: A function takes arguments and returns results A context takes results and provides arguments 3

4 The repmin problem The repmin program computes, given a tree, a tree of the same shape with in its leaves the minimal leave value of the argument tree. Essential is that part of the result (i.e. m) is passed back as argument: data Tree = Leaf Int Bin Tree Tree deriving Show repmin :: Tree Tree repmin t = let (m, r) = repmin t m in r repmin :: Tree Int (Int, Tree) repmin (Leaf v) m = (v, Leaf m) repmin (Bin l r) m = (ml min mr, tl Bin tr) where (ml, tl) = repmin l m (mr, tr) = repmin r m 4

5 We strictify this function We can make the two-pass behaviour explicit by defining an intermediate representation: data IR rm = IR rm Int (Int Tree) repmin2 :: Tree Tree repmin2 t = case repmin2 t of IR rm m reconstruct reconstruct m repmin2 :: Tree IR rm repmin2 (Leaf v) = IR rm v Leaf repmin2 (Bin l r) = IR rm (ml min mr) (λm tfl m Bin tfr m) where (IR rm ml tfl) = repmin2 l (IR rm mr tfr) = repmin2 r 5

6 We strictify this function We can make the two-pass behaviour explicit by defining an intermediate representation: data IR rm = IR rm Int (Int Tree) repmin2 :: Tree Tree repmin2 t = case repmin2 t of IR rm m reconstruct reconstruct m repmin2 :: Tree IR rm repmin2 (Leaf v) = IR rm v Leaf repmin2 (Bin l r) = IR rm (ml min mr) (λm tfl m Bin tfr m) where (IR rm ml tfl) = repmin2 l (IR rm mr tfr) = repmin2 r 5 So far so good.

7 A complicated version of id :: Tree Tree We traverse the tree and construct a nested cartesian product of leave values together with a function which will reconstruct the tree from these values: the data IR id = vs.ir id vs (vs Tree) idtree2 :: Tree Tree idtree2 t = case idtree2 t of IR id vs reconstruct reconstruct vs 6 idtree2 :: Tree IR id idtree2 (Leaf v) = IR id v Leaf idtree2 (Bin l r) = case (idtree2 l, idtree2 r) of (IR id vsl rcl, IR id vsr rcr) IR id (vsl, vsr) (λ(vsl, vsr) rcs vsl Bin rcr vsr)

8 Translating this back to a lazy varinat If we translate this function back to a one-pass solution (compare with first version of repmin) we get: idtree :: Tree Tree idtree t = let (vs, r) = idtree t vs in r idtree (Leaf v) w = (v, Leaf w) idtree (Bin l r) (vsl, vsr ) = ((vsl, vsr), tl Bin tr) where (vsl, tl) = idtree l vsl (vsr, tr) = idtree r vsr 7

9 Translating this back to a lazy varinat If we translate this function back to a one-pass solution (compare with first version of repmin) we get: idtree :: Tree Tree idtree t = let (vs, r) = idtree t vs in r idtree (Leaf v) w = (v, Leaf w) idtree (Bin l r) (vsl, vsr ) = ((vsl, vsr), tl Bin tr) where (vsl, tl) = idtree l vsl (vsr, tr) = idtree r vsr Unfortunately this does not type-check! So the question arises why the first version of repmin is permitted, and our equivalent version of idtree is rejected? 7

10 An attempt using GADT s Our first attempt to attack the problem is by using GADT s. All the parameters and results can be described by the type: data Vals a where Leaf vals :: a Vals a Bin vals : Vals l Vals r Vals (l, r) And hence we can rewrite idtree to idtree gadt as: 8 idtree gadt :: Tree Tree idtree gadt t = let (vs, r) = idtree t vs in r idtree gadt :: Tree Vals a (Vals a, Tree) idtree gadt (Leaf v) (Leaf vals w) = (Leaf vals, Leaf w) idtree gadt (Bin l r) (Bin vals vsl vsr ) = ((Bin vals vsl vsr), tl Bin tr) where (vsl, tl) = idtree gadt l vsl (vsr, tr) = idtree gadt r vsr

11 Problems with GADT approach Unfortunately this does not work out as expected. 1. it is not allowed to lazily match on a constructor of a GADT. 2. we are less efficient since we have introduced an extra pattern 3. is is less type-safe since the following is not excluded: idtree gadt t = let (vs, r) = idtree t (convert vs) in r where convert (Leaf vals a) = Leaf vals a convert (Val bin l r) = Val leaf (lvs, rvs) where (Leaf vals lvs) = convert l (Leaf vals rvs) = convert r 9

12 What is going on? Compare the following: When calling a polymorphic function it is the context which chooses the type and then passes a value of this type, and it is the obligation of the function to honour this choice in the result it returns. In our case it is the function which chooses the type and returns a value of this type, and it is the obligation of the context to honour this choice in the arguments it passes 10

13 What is going on? Compare the following: When calling a polymorphic function it is the context which chooses the type and then passes a value of this type, and it is the obligation of the function to honour this choice in the result it returns. In our case it is the function which chooses the type and returns a value of this type, and it is the obligation of the context to honour this choice in the arguments it passes Hence the rôle of the function and the calling environment are reversed. 10

14 Solution using existential types in UHC The Utrecht Haskell Compiler (UHC) has wide support for existential types, so we can write: idtree :: Tree vs.vs (vs, Tree) idtree (Leaf v) = λw (v, Leaf w) idtree (Bin l r) = λ (vsl, vsr ) let (vsl, tl) = idtree l vsl (vsr, tr) = idtree r vsr in ((vsl, vsr), tl Bin tr) Note that the current implementation requires the explicit lambda s in the right hand sides of these alternatives. 11

15 A more useful example We want to sort a Tree and use the type system to enforce that the values in the resulting Tree were taken from the argument Tree. We first provide an implementation using lists: 12 sorttree :: Tree [Int ] [Int ] ([Int ], [Int ], Tree) sorttree t = let (vs,, res) = sorttree t [ ] vs in res insert v [ ] = [v ] insert v (w : ws) = if v < w then (v : w : w) s else (w : insert v ws) sorttree (Leaf v) rest (x : xs) = (insert v rest, xs, Leaf x) sorttree (Bin l r) rest xs = (vl, xsr, Bin tl tr) where (vl, xsl, tl) = sorttree l vr xs (vr, xsr, tr) = sorttree r rest xsl

16 ADT style equivalent We start by mimicking the use of a class dictionary; it is explicitly passed around as a field in record. This makes more explicit what is going on. Hence we define: data OrdList cl = OrdList cl (Int cl (Int, cl)) 13

17 contn d 14 sorttree :: Tree rest.ordlist rest xs.xs (OrdList xs, rest, Tree) sorttree (Leaf v) (OrdList rest insert) = λ (x, xs) (OrdList (ins v rest) (λw (x, xs) if w < x then (w, (x, xs)) else (x, insert w xs)), xs, Leaf x) sorttree (Bin l r) rest = λxs let (vl, xsl, tl) = sorttree l vr xs (vr, xsr, tr) = sorttree r rest xsl in (vl, xsr, Bin tl tr)

18 Top level call sorttree t = let (OrdList vs,, res) = sorttree t (OrdList () (λv () (v, ()))) vs in res 15

19 GHC approach Tom Schrijvers showed that using GHC s existential types in constructors we can achieve the same effect: 16 data Pack = vs.p (vs (vs, Tree)) idt :: Tree Tree idt t = case id1 t of P f let (vs, t ) = f vs in t id1 :: Tree Pack id1 (Leaf v) = P (λw (v, Leaf w)) id1 (Bin l r) = case (id1 l, id1 r) of (P f1, P f2 ) P (λ (vsl, vsr) let (vl, tl) = f1 vsl (vr, tr) = f2 vsr in ((vl, vr), Bin tl tr) )

20 Extending with classes Just as we can pass class instances implicitly when calling a polymorphic function we should be able to return class instances as part of a result: class Insertable cl where insert :: Int cl (Int, cl) instance Insertable cl Insertable (Int, cl) where insert w (x, xs) = if w < x then (w, (x, xs)) else (x, insert w xs)) instance Insertable () where insert w () = (w, ()) data OrdList cl where OrdList :: Insertable cl cl OrdList cl 17

21 Using this extension We can now write something which closely follows the types: sorttree (Leaf v) (OrdList rest) = λ (x, xs) (OrdList (insert v rest), xs, Leaf x) sorttree (Bin l r) rest = λxs let (vl, xsl, tl) = sorttree l vr xs (vr, xsr, tr) = sorttree r rest xsl in (vl, xsr, Bin tl tr) sorttree t = let (OrdList vs,, res) = sorttree t (OrdList ()) vs in res 18

22 Conclusion 1. A function takes arguments and returns results 2. A context takes results and provides arguments 3. when using lazy evaluation we need this kind of existentials 4. functions and contexts are yin and yang 5. is for contexts what is for functions 19