We have already covered some existing haskell types and typeclasses. In this chapter, we'll learn how to make our own and how to put them to work!
First we will introduce new types and we will see how we can create new types with the "data" keyword.
- Declare a new type with "data" keyword and value constructor
- the record syntax
and as a sub-module, we will discuss the topic such as
- export a value constructor
- e.g. of record syntax
FIst let's see an example which shows basics of defining types such as Shape and points.
-- fie: -- own_type.hs -- description: -- create your own types and type classes -- Algebraic data types intro -- -- data: -- e.g. how the Bool type is defined. data Bool = False | True data Int = -2147483648 | -2147483647 | ... | -1 | 0 | 1 | 2 | ... | 2147483647 -- e.g. suppose that we are defining shapes which could be a Circle or a Rectangle -- data Shape = Circle Float Float Float | Rectangle Float Float Float Float -- -- value constructors: -- Cirlce as well as Rectangle are like value contructors -- Circle: Value contructors which takes 3 parameters -- Rectangle: Value constructors which takes 4 parameters :t Circle :t Rectangle -- make a function takes a Shape and returns something surface :: Shape -> Float surface (Circle _ _ r) = pi * r ^ 2 surface (Rectangle x1 y1 x2 y2) = (abs $ x2 - x1) * (abs $ y2 - y1) -- surface $ Circle 10 20 10 -- surface $ Rectangle 0 0 100 100 -- -- make Shape showable: data Shape = Circle Float Float Float | Rectangle Float Float Float Float deriving (Show) -- haskell automatically make "Shape" part of the Show typeeclass Circle 10 20 5 Rectangle 50 230 60 90 -- more usage on constructor as functions map (Circle 10 20) [4, 5, 6, 6] -- make it better -- re-org the type classes data Point = Point Float Float deriving (Show) data Shape = Circle Point Float | Rectangle Point Point deriving (Show) surface :: Shape -> Float surface (Circle _ r) = pi * r ^ 2 surface (Rectangle (Point x1 y1) (Point x2 y2)) = (abs $ x2 - x1) * (abs $ y2 - y1) surface (Rectangle (Point 0 0) (Point 100 100)) surface (Circle (Point 0 0) 24) -- yet anoter example nudge :: Shape -> Float -> Float -> Shape nudge (Circle (Point x y) r) a b = Circle (Point (x + a) (y + b)) r nudge (Rectangle (Point x1 y1) (Point x2 y2)) a b = Rectangle (Point (x1+a) (y1+b)) (Point (x2+a) (y2+b)) -- auxiliary functions to help dealing with Points baseCircle :: Float -> Shape baseCircle r = Circle (Point 0 0) r baseRect :: Float -> Float -> Shape baseRect with height = Rectangle (Point 0 0) (Point width height) -- nudge (baseRect 40 100) 60 23 -- -- -- exports both the type and functions within -- -- client use our code will by deafult import Rectangle, Circle and others without doing -- Shape (Rectangle, Circle) module Shapes ( Point(..) -- all the value constructors for Shape , Shape(..) , surface , nudge , baseCircle , baseRect ) where
But as we see that the Person type defined above is less readable, can we make it more readable?Here comes the record syntax, where it gives a understandable field names,. before we goes into the record, sytnax, let re-examine the person class.
-- file: -- Person.hs -- description: -- the file defines the Person object -- -- Record Syntax module Person ( Person(..) , firstName , lastName , age , height , phoneNumber , flavor ) where data Person = Person String String Int Float String String deriving (Show) firstName :: Person -> String firstName (Person firstName _ _ _ _ _) = firstName lastName :: Person -> String lastName (Person _ lastName _ _ _ _) = lastName age :: Person -> Int age (Person _ _ age _ _ _ ) = age height :: Person -> Float height (Person _ _ _ height _ _) = height phoneNumber :: Person -> String phoneNumber (Person _ _ _ _ number _) = number flavor :: Person -> String flavor (Person _ _ _ _ _ flavor) = flavor -- -- alternative way to write data types -- with mnemonic such as follo -- NOTE : -- Check on the Person2.hs
and then let's examine the new record sytnax, where you can define person class as follow. Together there are other types such as Car and methods which operate on Cars and Person.
-- file: -- Person2.hs -- description: -- Person2 module Person (Person(..) ,Car(..) ) where data Person = Person { firstName :: String , lastName :: String , age :: Int , height :: Float , phoneNumber :: String , flavor :: String } deriving (Show) -- Check the type of flavor and firstName -- :t flavor -- :t firstName -- data Car String String String Int deriving (Show) data Car = Car { company :: String, model :: String, year :: Int } deriving (Show) -- Car { company = "Ford", model = "Mustang", year=1967} -- Create the Car object -- Car "Ford" "Mustang" 1967 -- -- -- Type Parameter : -- the type parameter a data Maybe a = Nothing | Just a data Car = Car { company :: String , model :: String , year :: Int } deriving (Show) -- with type paramter data Car a b c = Car { company :: a , model :: b , year :: c } deriving (Show) tellCar :: Car -> String tellCar (Car {company = c, model = m, year = y}) = "This " ++ c ++ " " ++ m ++ " was made in " ++ show y -- to use the tellCar -- ghci> let stang = Car {company="Ford", model="Mustang", year=1967} -- ghci> tellCar stang -- "This Ford Mustang was made in 1967" tellCar :: (Show a) => Car String String a -> String tellCar (Car {company = c, model = m, year = y}) = "This " ++ c ++ " " ++ m ++ " was made in " ++ show y -- how to use the new tellCar method which has the new type paramter. -- ghci> tellCar (Car "Ford" "Mustang" 1967) -- "This Ford Mustang was made in 1967" -- ghci> tellCar (Car "Ford" "Mustang" "nineteen sixty seven") -- "This Ford Mustang was made in \"nineteen sixty seven\"" -- ghci> :t Car "Ford" "Mustang" 1967 -- Car "Ford" "Mustang" 1967 :: (Num t) => Car [Char] [Char] t -- ghci> :t Car "Ford" "Mustang" "nineteen sixty seven" -- Car "Ford" "Mustang" "nineteen sixty seven" :: Car [Char] [Char] [Char]