haskell - types and typeclasses - new types

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]