Algebraic Types. Chapter 14 of Thompson

Transcription

1 Algebraic Types Chapter 14 of Thompson

2 Types so far Base types Int, Integer, Float, Bool, Char Composite types: tuples (t 1,t 2,,t n ) lists [t 1 ] functions (t 1 -> t 2 ) Algebraic types enumerated, product (record), sum (union) Now, we will see more types that are recursive and polymorphic

3 Recursive types: example data NTree = NilT Node Integer NTree NTree Such types allow us to build data structures of arbitrary size

4

5 Polymorphic types: example data Maybe a = Nothing Just a Built into the Haskell prelude and used for modelling program errors. Reusable in different situations, such as the built in list type.

6 Review: algebraic data types in general data Typename = Con 1 t 11 t 12 t 1i Con 2 t 21 t 22 t 2j Con m t m1 t m2 t mk Each Con i is a constructor, followed by n types, where n 0, allowing us to build values of the type by using the constructor as a function: Con i :: t i1 -> t i2 -> -> t in -> Typename

7 Examples Enumerated types have constructors with no arguments: data Season = Spring Summer Autumn Winter Product types have a single constructor: data People = Person Name Age Sum types have a number of constructors taking different arguments: data Shape = Circle Float Rectangle Float Float

8 Examples: pattern matching To distinguish among alternatives and to extract components: area :: Shape -> Float area (Circle r) area (Rectangle h w) = pi*r*r = h*w

9 Recursive algebraic types: example A recursive type is a type described in terms of itself: data Expr = Lit Integer Add Expr Expr Sub Expr Expr This describes an integer expression as something that one of: a literal, like 42; Expr the sum of two subexpressions; or the difference between two subexpressions Lit 2 expr1 = Lit 2 expr2 = Add (Lit 2) (Lit 3) expr3 = Add (Sub (Lit 3) (Lit 1)) (Lit 3) Expr Add Lit 2 Lit 3 Expr Add Sub Lit 3 Lit 3 Lit 1

10 Primitive recursion over expressions [Live coding for eval and show over integer expressions]

11 Recursive algebraic types: trees A tree is either nil (empty) or the joining of two subtrees into a tree node: data NTree = NilT Node Integer NTree NTree For example: treeex1 = Node 10 NilT NilT treeex2 = Node 17 (Node 14 NilT NilT) (Node 20 NilT NilT) Similarly, a list is either the empty list [] or constructed from a head and a tail using : list1 = [10, [], []] list2 = [17, [14, [], []], [20, [], []]] 14 20

12 Primitive recursion over trees [live coding for sumtree, depth, occurs]

13 More recursion over expressions Since addition is associative, it would be nice to present integer expressions including addition in a normalized right-associative form: (2+3)+4 = 2+(3+4) ((2+3)+4)+5 = 2+(3+(4+5)) ((2-((6+7)+8))+4)+5 = (2-(6+(7+8)))+(4+5) Aim: spot occurrences of Add (Add e1 e2) e3 and transform them to Add e1 (Add e2 e3) [live coding for assoc]

14 Non-primitive recursion over expressions assoc :: Expr -> Expr assoc (Add (Add e1 e2) e3) = assoc (Add e1 (Add e2 e3)) assoc (Add e1 e2) = Add (assoc e1) (assoc e2) assoc (Sub e1 e2) = Sub (assoc e1) (assoc e2) assoc (Lit n) = Lit n

15 Termination assoc (Add (Add e1 e2) e3) = assoc (Add e1 (Add e2 e3)) The RHS makes progress by moving the expression tree from leftassociative to right-associative. None of the other equations move a plus in the other direction, so after applying the above equation some finite number of times there will be no more exposed addition symbols at the top level of the LHS.

16 Syntax: infix constructors Can also write: data Expr' = Lit' Integer Expr' :+: Expr' Expr' :-: Expr' The infix operators must start with :

17 Mutual recursion data Person = Adult Name Address Bio Child Name data Bio = Parent String [Person] NonParent String type Name = String type Address = [String]

18 Mutual recursion showperson (Adult nm ad bio) = show nm ++ show ad ++ showbio bio showperson (Child nm) = show nm showbio (Parent st perlist) = st ++ concat (map showperson perlist) showbio (NonParent st) = st

19

20 Polymorphic algebraic types Type variables can be used to make an algebraic type polymorphic. Example: data Pairs a = Pr a a pair1 = Pr 2 3 :: Pairs Int pair2 = Pr [] [3] :: Pairs [Int] pair3 = Pr [] [] :: Pairs [a] equalpair :: Eq a => Pairs a -> Bool equalpair (Pr x y) = (x==y)

21 Polymorphic algebraic types: lists infixr 5 ::: -- same fixity and associativity as list cons : data List a = NilL a ::: (List a) deriving (Eq,Ord,Show,Read) A user-defined list type: List a instead of builtin [a] NillL instead of builtin [] ::: instead of builtin : 2+3 ::: 4+5 ::: NilL 5 ::: (9 ::: NilL)

22 Polymorphic algebraic types: trees data Tree a = Nil Node a (Tree a) (Tree a) deriving (Eq,Ord,Show,Read) deptht :: Tree a -> Integer deptht Nil = 0 deptht (Node n t1 t2) = 1 + max (deptht t1) (deptht t2) collapse :: Tree a -> [a] collapse Nil = [] collapse (Node x t1 t2) = collapse t1 ++ [x] ++ collapse t2

23 Polymorphic algebraic types: trees collapse (Node 12 (Node 34 Nil Nil) (Node 3 (Node 17 Nil Nil) Nil)) = [34, 12, 17, 3]

24 Polymorphic algebraic types: trees maptree :: (a -> b) -> Tree a -> Tree b maptree f Nil = Nil maptree f (Node x t1 t2) = Node (f x) (maptree f t1) (maptree f t2)

25 Polymorphic algebraic types: sum types data Either a b = Left a Right b deriving (Eq,Ord,Read,Show) eithereg1 = Left "Duke of Prunes eithereg2 = Right :: Either String Int :: Either String Int isleft :: Either a b -> Bool isleft (Left _) = True isleft (Right _) = False

26 Polymorphic algebraic types: sum types either :: (a -> c) -> (b -> c) -> Either a b -> c This is a higher-order function: takes functions as arguments. Functions can also return functions as results! either f g (Left x) = f x either f g (Right y) = g y