A Generic Programming Extension for Clean

1. A Generic Programming Extension for Clean Artem Alimarine and Rinus Plasmeijer University of Nijmegen

2. Contents (1) • Introduction to generic programming • Generics in Clean • Customized instances • Conclusion A Generic Programming Extension for Clean

3. Generic programming (1) • Functions are defined by induction on the structure of data types. • Defined once, specialized for an arbitrary data type. • Examples: • Equality, lex. comparison, unification. • Mapping, zipping, folding. • Pretty printers and parsers. A Generic Programming Extension for Clean

4. Generic programming (2) mapList f List a List b fromList toList gmap f Generic a Generic b fromRose toRose mapRose f Rose a Rose b A Generic Programming Extension for Clean

5. Generic type representation • Example types :: List a = Nil | Cons a (List a) :: Rose a = Rose a (List (Rose a)) :: Tree a b = Tip a | Bin b (Tree a b) (Tree a b) • Binary sums and products (in generic prelude) :: UNIT = UNIT :: PAIR a b = PAIR a b :: EITHER a b = LEFT a | RIGHT b • Generic type representations :: ListG a :== EITHER UNIT (PAIR a (List a)) :: RoseG a :== PAIR a (List (Rose a)) :: TreeG a b :== EITHER a (PAIR b (PAIR (Tree a b) (Tree a b))) A Generic Programming Extension for Clean

6. Generic equality class eq t :: t t  Bool instance eq Int where eq x y = eqInt x y instance eq UNIT where eq x y = True instance eq (EITHER a b) | eq a & eq b where eq (LEFT x) (LEFT y) = eq x y eq (RIGHT x) (RIGHT y) = eq x y eq _ _ = False instance eq (PAIR a b) | eq a & eq b where eq (PAIR x1 x2) (PAIR y1 y2) = eq x1 y1 && eq x2 y2 A Generic Programming Extension for Clean

7. Specialization instance eq (List a) | eq a where eq x y = eq (fromList x) (fromList y) instance eq (Rose a) | eq a where eq x y = eq (fromRose x) (fromRose y) instance eq (Tree a b) | eq a & eq b where eq x y = eq (fromTree x) (fromTree y) A Generic Programming Extension for Clean

8. Generic mapping • Mapping class map t :: (a  b) (t a)  (t b) • Specialization for lists instance map List where map f x = toList (map f (fromList x)) • Problems • Instances on UNIT, PAIR and EITHER cannot be defined: the kinds do not match instance map UNIT where map f x = x • This mapping function is defined only for kind **. A Generic Programming Extension for Clean

9. Contents (2) • Introduction to Generic programming • Generics in Clean • Customized instances • Conclusion A Generic Programming Extension for Clean

10. Our approach • Based on two approaches: • Derivable type classes of Hinze and P. Jones • Generic definition of class members • Limited to classes with class variables of kind * • Kind-indexed types of Hinze • One generic function works for types of all kinds • Overloaded functions cannot be defined generically • One generic function works for all kinds • Overloaded functions can be defined generically A Generic Programming Extension for Clean

11. Instances to generate instance map List generic instance map Rose generic instance map Tree generic instance map (,) generic instance map (,,) generic :: Sequ a = SequEmpty | SequZero (Sequ (a,a)) | SequOne a (Sequ (a,a)) instance map Sequ generic A Generic Programming Extension for Clean

12. Definition of generic mapping generic map a b :: a  b instance map Int where map x = x instance map UNIT where map x = x instance map PAIR where map mapx mapy (PAIR x y) = PAIR (mapx x)(mapy y) instance map EITHER where map mapl mapr (LEFT x) = LEFT (mapl x) map mapl mapr (RIGHT x) = RIGHT (mapr x) A Generic Programming Extension for Clean

13. Translation: kind indexed classes • Generic definition generic map a b :: a  b • Translated to a kind-indexed family of classes class map* t :: t  t class map** t :: (a  b) (t a)  t b class map*** t :: (a1b1) (a2b2) (t a1 a2)  t b1 b2 … • Each class has • One class variable • One class member with the member type derived from the generic type A Generic Programming Extension for Clean

14. Translation: instances are bound to classes • Instances of the generic definition instance map*Int where map* x = x instance map*UNIT where map* x = x instance map***PAIR where map*** mapx mapy (PAIR x y) = PAIR (mapx x)(mapy y) instance map***EITHER where map*** mapl mapr (LEFT x) = LEFT (mapl x) map*** mapl mapr (RIGHT x) = RIGHT (mapr x) • Instances to generate instance map**List generic instance map***Tree generic A Generic Programming Extension for Clean

15. Translation: instance for lists • Generic representation of lists :: ListG a :== EITHER UNIT (PAIR a (List a)) • Instance to generate instance map**List generic • Generated instance for lists instance map**Listwhere map** f x = toList (mapListG f (fromList x)) mapListG :: (a  b)  (ListG a)  ListG b mapListG f = map*** map* (map*** f (map** f)) • After resolving overloading mapListG f = mapEITHER mapUNIT (mapPAIR f (mapList f)) A Generic Programming Extension for Clean

16. Translation: instance for trees • Generic representation of trees :: TreeG a b :== EITHER a (PAIR b (PAIR (Tree a b) (Tree a b))) • Generated instance for trees instance map***Treewhere map*** f1 f2 x = toTree (mapTreeG f1 f2 (fromTree x)) mapTreeG :: (a1b1) (a2b2)  (TreeG a1 a2)  TreeG b1 b2 mapTreeG f1 f2 = map*** f1 (map*** f2 (map*** (map*** f1 f2) (map*** f1 f2))) • After resolving overloading mapTreeG f1 f2 = mapEITHER f1 (mapPAIR f2 (mapPAIR (mapTree f1 f2) (mapTree f1 f2))) A Generic Programming Extension for Clean

17. Applying map • Overloaded fmap and bimap can be defined in terms of generic map fmap :: (a  b) (t a)  (t b) | map{|**|} t fmap f x = map{|**|} f x bimap :: (a  b) (c  d) (t a c)  (t b d) | map{|***|} t bimap f g x = map{|***|} f g x • Kind index must be specified mapinc1 = map{|**|} inc mapinc2 = map{|***|} inc A Generic Programming Extension for Clean

18. Contents (3) • Introduction to Generic programming • Generics in Clean • Customized instances • Conclusion A Generic Programming Extension for Clean

19. Customized instances • Allow for mixing of • Generic behavior • Specific behavior • The user can specify an instance in terms of the generated instance A Generic Programming Extension for Clean

20. Collecting free variables :: Expr = Lambda Var Expr | App Expr Expr | … generic vars :: a  [Var] instance vars UNIT where vars x = [] instance vars EITHER where vars vl vr (LEFT x) = vl x vars vl vr (RIGHT x) = vr x instance vars PAIR where vars vx vy (PAIR x y) = removeDup (vx x ++ vy y) instance vars Var where vars v = [v] instance vars Expr where vars (Lambda arg expr) = removeMember arg (vars{|*|} expr) vars x = vars{|generic|} x A Generic Programming Extension for Clean

21. Contents (4) • Introduction to Generic programming • Generics in Clean • Customized instances • Conclusion A Generic Programming Extension for Clean

22. Contributions • Kind-indexed classes • One generic function works for all kinds • Overloaded functions can be defined generically • Customized instances provide a way to combine • Generic behavior • Specific behavior A Generic Programming Extension for Clean

23. Future work • Optimization • Types of higher-order kinds • Constructor information • Uniqueness typing • Array types • Explicit recursion in the generic representation of types A Generic Programming Extension for Clean