A generic programming extension for clean
Download
1 / 23

A Generic Programming Extension for Clean - PowerPoint PPT Presentation


  • 119 Views
  • Uploaded on

A Generic Programming Extension for Clean. Artem Alimarine and Rinus Plasmeijer University of Nijmegen. Contents (1). Introduction to generic programming Generics in Clean Customized instances Conclusion. Generic programming (1).

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'A Generic Programming Extension for Clean' - jadon


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
A generic programming extension for clean

A Generic Programming Extension for Clean

Artem Alimarine and Rinus Plasmeijer

University of Nijmegen


Contents 1
Contents (1)

  • Introduction to generic programming

  • Generics in Clean

  • Customized instances

  • Conclusion

A Generic Programming Extension for Clean


Generic programming 1
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


Generic programming 2
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


Generic type representation
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


Generic equality
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


Specialization
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


Generic mapping
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


Contents 2
Contents (2)

  • Introduction to Generic programming

  • Generics in Clean

  • Customized instances

  • Conclusion

A Generic Programming Extension for Clean


Our approach
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


Instances to generate
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


Definition of generic mapping
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


Translation kind indexed classes
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


Translation instances are bound to classes
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


Translation instance for lists
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


Translation instance for trees
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


Applying map
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


Contents 3
Contents (3)

  • Introduction to Generic programming

  • Generics in Clean

  • Customized instances

  • Conclusion

A Generic Programming Extension for Clean


Customized instances
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


Collecting free variables
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


Contents 4
Contents (4)

  • Introduction to Generic programming

  • Generics in Clean

  • Customized instances

  • Conclusion

A Generic Programming Extension for Clean


Contributions
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


Future work
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


ad