Loading in 5 sec....

A Generic Programming Extension for CleanPowerPoint Presentation

A Generic Programming Extension for Clean

- By
**jadon** - Follow User

- 119 Views
- Uploaded on

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

Artem Alimarine and Rinus Plasmeijer

University of Nijmegen

Contents (1)

- Introduction to generic programming
- Generics in Clean
- Customized instances
- Conclusion

A Generic Programming Extension for Clean

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)

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

- 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

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

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

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

- Instances on UNIT, PAIR and EITHER cannot be defined: the kinds do not match

A Generic Programming Extension for Clean

Contents (2)

- Introduction to Generic programming
- Generics in Clean
- Customized instances
- Conclusion

A Generic Programming Extension for Clean

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

- Derivable type classes of Hinze and P. Jones
- One generic function works for all kinds
- Overloaded functions can be defined generically

A Generic Programming Extension for Clean

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

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

- 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 ::

(a1b1) (a2b2) (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

- 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

- 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

- 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 :: (a1b1) (a2b2) (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

- 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)

- Introduction to Generic programming
- Generics in Clean
- Customized instances
- Conclusion

A Generic Programming Extension for Clean

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

:: 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)

- Introduction to Generic programming
- Generics in Clean
- Customized instances
- Conclusion

A Generic Programming Extension for Clean

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

- 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

Download Presentation

Connecting to Server..