| Making Our Own Types and Typeclasses

Making Our Own Types and Typeclasses

@wusyong, 吳昱緯

Algebraic data types intro

data Bool = False | True  
data Int = -2147483648 | -2147483647 | ... | -1 | 0 | 1 | 2 | ... | 2147483647

value constructor with fields

data Shape = Circle Float Float Float | Rectangle Float Float Float Float
ghci> :t Circle  
Circle :: Float -> Float -> Float -> Shape  
ghci> :t Rectangle  
Rectangle :: Float -> Float -> Float -> Float -> Shape

Usage in functions

Parameters are Shape not Circle (just like Bool but not True)
Can be pattern matched

surface :: Shape -> Float  
surface (Circle _ _ r) = pi * r ^ 2  
surface (Rectangle x1 y1 x2 y2) = (abs $ x2 - x1) * (abs $ y2 - y1)

ghci> surface $ Circle 10 20 10  
314.15927  
ghci> surface $ Rectangle 0 0 100 100  
10000.0

make Shape type part of the Show typeclass

data Shape = Circle Float Float Float | Rectangle Float Float Float Float deriving (Show)

partially applied functions

ghci> map (Circle 10 20) [4,5,6,6]  
[Circle 10.0 20.0 4.0,Circle 10.0 20.0 5.0,Circle 10.0 20.0 6.0,Circle 10.0 20.0 6.0]

more idiomatic way

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)

ghci> surface (Rectangle (Point 0 0) (Point 100 100))  
10000.0  
ghci> surface (Circle (Point 0 0) 24)  
1809.5574

More utilities

ghci> nudge (Circle (Point 34 34) 10) 5 10  
Circle (Point 39.0 44.0) 10.0

baseCircle :: Float -> Shape  
baseCircle r = Circle (Point 0 0) r  
  
baseRect :: Float -> Float -> Shape  
baseRect width height = Rectangle (Point 0 0) (Point width height)

ghci> nudge (baseRect 40 100) 60 23  
Rectangle (Point 60.0 23.0) (Point 100.0 123.0)

Export module

Export the type with Shape(..) or Shape (Rectangle, Circle) or Shape only with no value

module Shapes   
( Point(..)  
, Shape(..)
, surface  
, nudge  
, baseCircle  
, baseRect  
) where

Record syntax

If we want to define the field name for the data type:

data Person = Person String String Int Float String String deriving (Show)  
ghci> let guy = Person "Buddy" "Finklestein" 43 184.2 "526-2928" "Chocolate"  
ghci> guy  
Person "Buddy" "Finklestein" 43 184.2 "526-2928" "Chocolate"

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  
ghci> let guy = Person "Buddy" "Finklestein" 43 184.2 "526-2928" "Chocolate"  
ghci> firstName guy  
"Buddy"  
ghci> height guy  
184.2  
ghci> flavor guy  
"Chocolate"

record syntax

data Person = Person { firstName :: String  
                     , lastName :: String  
                     , age :: Int  
                     , height :: Float  
                     , phoneNumber :: String  
                     , flavor :: String  
                     } deriving (Show)
ghci> :t flavor  
flavor :: Person -> String  
ghci> :t firstName  
firstName :: Person -> String

Comparison

data Car = Car String String Int deriving (Show)
ghci> Car "Ford" "Mustang" 1967  
Car "Ford" "Mustang" 1967

data Car = Car {company :: String, model :: String, year :: Int} deriving (Show)
ghci> Car {company="Ford", model="Mustang", year=1967}  
Car {company = "Ford", model = "Mustang", year = 1967}

Type parameters

data Maybe a = Nothing | Just a

ghci> Just "Haha"  
Just "Haha"  
ghci> Just 84  
Just 84  
ghci> :t Just "Haha"  
Just "Haha" :: Maybe [Char]  
ghci> :t Just 84  
Just 84 :: (Num t) => Maybe t  
ghci> :t Nothing  
Nothing :: Maybe a  
ghci> Just 10 :: Maybe Double  
Just 10.0

The variable is part of the typeclass the type derives

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
-- Compare to original
tellCar :: (Show a) => Car String String a -> String  

-- And can have many instances
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]

Map k v

data (Ord k) => Map k v = ...
-- So we just need
toList :: Map k a -> [(k, a)]
-- instead of
toList :: (Ord k) => Map k a -> [(k, a)]

Example: vector

data Vector a = Vector a a a deriving (Show)  
  
vplus :: (Num t) => Vector t -> Vector t -> Vector t  
(Vector i j k) `vplus` (Vector l m n) = Vector (i+l) (j+m) (k+n)  
  
vectMult :: (Num t) => Vector t -> t -> Vector t  
(Vector i j k) `vectMult` m = Vector (i*m) (j*m) (k*m)  
  
scalarMult :: (Num t) => Vector t -> Vector t -> t  
(Vector i j k) `scalarMult` (Vector l m n) = i*l + j*m + k*n

ghci> Vector 3 5 8 `vplus` Vector 9 2 8  
Vector 12 7 16  
ghci> Vector 3 5 8 `vplus` Vector 9 2 8 `vplus` Vector 0 2 3  
Vector 12 9 19  
ghci> Vector 3 9 7 `vectMult` 10  
Vector 30 90 70  
ghci> Vector 4 9 5 `scalarMult` Vector 9.0 2.0 4.0  
74.0  
ghci> Vector 2 9 3 `vectMult` (Vector 4 9 5 `scalarMult` Vector 9 2 4)  
Vector 148 666 222

Derived instances

data Person = Person { firstName :: String  
                     , lastName :: String  
                     , age :: Int  
                     } deriving (Eq)
ghci> let mikeD = Person {firstName = "Michael", lastName = "Diamond", age = 43}  
ghci> let adRock = Person {firstName = "Adam", lastName = "Horovitz", age = 41}  
ghci> mca == adRock  
False  
ghci> mikeD == Person {firstName = "Michael", lastName = "Diamond", age = 43}  
True 
ghci> let beastieBoys = [mca, adRock, mikeD]  
ghci> mikeD `elem` beastieBoys  
True

Show & Read

data Person = Person { firstName :: String  
                     , lastName :: String  
                     , age :: Int  
                     } deriving (Eq, Show, Read)
ghci> let mikeD = Person {firstName = "Michael", lastName = "Diamond", age = 43}  
ghci> mikeD  
Person {firstName = "Michael", lastName = "Diamond", age = 43}  
ghci> "mikeD is: " ++ show mikeD  
"mikeD is: Person {firstName = \"Michael\", lastName = \"Diamond\", age = 43}"
ghci> read "Person {firstName =\"Michael\", lastName =\"Diamond\", age = 43}" :: Person  
Person {firstName = "Michael", lastName = "Diamond", age = 43}
ghci> read "Person {firstName =\"Michael\", lastName =\"Diamond\", age = 43}" == mikeD  
True

Ord

data Bool = False | True deriving (Ord)
ghci> True `compare` False  
GT  
ghci> True > False  
True
ghci> Nothing < Just 100  
True  
ghci> Nothing > Just (-49999)  
False  
ghci> Just 3 `compare` Just 2  
GT  
ghci> Just 100 > Just 50  
True

Enum & Bounded

Value constructors are nullary (take no parameters, i.e. fields).
Enum typeclass is for things that have predecessors and successors.
Bounded typeclass is for things that have a lowest possible value and highest possible value.

data Day = Monday | Tuesday | Wednesday | Thursday | Friday | Saturday | Sunday

Let our enum to show/read

ghci> Wednesday  
Wednesday  
ghci> show Wednesday  
"Wednesday"  
ghci> read "Saturday" :: Day  
Saturday

Let our enum to eq/ord

ghci> Saturday == Sunday  
False  
ghci> Saturday == Saturday  
True  
ghci> Saturday > Friday  
True  
ghci> Monday `compare` Wednesday  
LT

Let our enum to enum/bounded

ghci> minBound :: Day  
Monday  
ghci> maxBound :: Day  
Sunday
ghci> succ Monday  
Tuesday  
ghci> pred Saturday  
Friday  
ghci> [Thursday .. Sunday]  
[Thursday,Friday,Saturday,Sunday]  
ghci> [minBound .. maxBound] :: [Day]  
[Monday,Tuesday,Wednesday,Thursday,Friday,Saturday,Sunday]

Type synonyms

type String = [Char]

type PhoneNumber = String  
type Name = String  
type PhoneBook = [(Name,PhoneNumber)]

inPhoneBook :: Name -> PhoneNumber -> PhoneBook -> Bool  
inPhoneBook name pnumber pbook = (name,pnumber) `elem` pbook

parameterized

So we can produces a concrete type, like AssocList Int String
Concrete type means fully applied types

type AssocList k v = [(k,v)]

partially apply type parameters

type IntMap v = Map Int v
-- or
type IntMap = Map Int

Either a b

Like result in rust

data Either a b = Left a | Right b deriving (Eq, Ord, Read, Show)
ghci> Right 20  
Right 20  
ghci> Left "w00t"  
Left "w00t"  
ghci> :t Right 'a'  
Right 'a' :: Either a Char  
ghci> :t Left True  
Left True :: Either Bool b

Example: lockers

import qualified Data.Map as Map  
data LockerState = Taken | Free deriving (Show, Eq)  
type Code = String  
type LockerMap = Map.Map Int (LockerState, Code)

lockerLookup :: Int -> LockerMap -> Either String Code  
lockerLookup lockerNumber map =   
    case Map.lookup lockerNumber map of   
        Nothing -> Left $ "Locker number " ++ show lockerNumber ++ " doesn't exist!"  
        Just (state, code) -> if state /= Taken   
                                then Right code  
                                else Left $ "Locker " ++ show lockerNumber ++ " is already taken!"

Example: lockers

lockers :: LockerMap  
lockers = Map.fromList   
    [(100,(Taken,"ZD39I"))  
    ,(101,(Free,"JAH3I"))  
    ,(103,(Free,"IQSA9"))  
    ,(105,(Free,"QOTSA"))  
    ,(109,(Taken,"893JJ"))  
    ,(110,(Taken,"99292"))  
    ]
ghci> lockerLookup 101 lockers  
Right "JAH3I"  
ghci> lockerLookup 100 lockers  
Left "Locker 100 is already taken!"  
ghci> lockerLookup 102 lockers  
Left "Locker number 102 doesn't exist!"  
ghci> lockerLookup 110 lockers  
Left "Locker 110 is already taken!"  
ghci> lockerLookup 105 lockers  
Right "QOTSA"

Recursive data structures

Algebraic data type only allows concrete types.
Cons means : in list

data List a = Empty | Cons a (List a) deriving (Show, Read, Eq, Ord)
ghci> Empty  
Empty  
ghci> 5 `Cons` Empty  
Cons 5 Empty  
ghci> 4 `Cons` (5 `Cons` Empty)  
Cons 4 (Cons 5 Empty)  
ghci> 3 `Cons` (4 `Cons` (5 `Cons` Empty))  
Cons 3 (Cons 4 (Cons 5 Empty))

fixity declarations

infixr 5 :-:  
data List a = Empty | a :-: (List a) deriving (Show, Read, Eq, Ord)

ghci> 3 :-: 4 :-: 5 :-: Empty  
(:-:) 3 ((:-:) 4 ((:-:) 5 Empty))  
ghci> let a = 3 :-: 4 :-: 5 :-: Empty  
ghci> 100 :-: a  
(:-:) 100 ((:-:) 3 ((:-:) 4 ((:-:) 5 Empty)))

* and +

infixl 7 *: so 4 * 3 * 2 is (4 * 3) * 2
infixl 6: so so 5 * 4 + 3 is (5 * 4) + 3

++

infixr 5  ++ 
(++) :: [a] -> [a] -> [a]  
[]     ++ ys = ys  
(x:xs) ++ ys = x : (xs ++ ys)

infixr 5  .++  
(.++) :: List a -> List a -> List a   
Empty .++ ys = ys  
(x :-: xs) .++ ys = x :-: (xs .++ ys)  
-- Notice the pattern matching
ghci> let a = 3 :-: 4 :-: 5 :-: Empty  
ghci> let b = 6 :-: 7 :-: Empty  
ghci> a .++ b  
(:-:) 3 ((:-:) 4 ((:-:) 5 ((:-:) 6 ((:-:) 7 Empty))))

Example: binary search tree

data Tree a = EmptyTree | Node a (Tree a) (Tree a) deriving (Show, Read, Eq)

singleton :: a -> Tree a  
singleton x = Node x EmptyTree EmptyTree  
  
treeInsert :: (Ord a) => a -> Tree a -> Tree a  
treeInsert x EmptyTree = singleton x  
treeInsert x (Node a left right)   
    | x == a = Node x left right  
    | x < a  = Node a (treeInsert x left) right  
    | x > a  = Node a left (treeInsert x right)

Example: binary search tree

treeElem :: (Ord a) => a -> Tree a -> Bool  
treeElem x EmptyTree = False  
treeElem x (Node a left right)  
    | x == a = True  
    | x < a  = treeElem x left  
    | x > a  = treeElem x right

Example: binary search tree

ghci> let nums = [8,6,4,1,7,3,5]  
ghci> let numsTree = foldr treeInsert EmptyTree nums  
ghci> numsTree  
Node 5 (Node 3 (Node 1 EmptyTree EmptyTree) (Node 4 EmptyTree EmptyTree)) (Node 7 (Node 6 EmptyTree EmptyTree) (Node 8 EmptyTree EmptyTree))  

ghci> 8 `treeElem` numsTree  
True  
ghci> 100 `treeElem` numsTree  
False  
ghci> 1 `treeElem` numsTree  
True  
ghci> 10 `treeElem` numsTree  
False

Typeclasses 102

Class declaration:

class Eq a where  
    (==) :: a -> a -> Bool  
    (/=) :: a -> a -> Bool  
    x == y = not (x /= y)  
    x /= y = not (x == y)

Making types instances of that typeclass

Minimal complete definition for the typeclass:

data TrafficLight = Red | Yellow | Green

instance Eq TrafficLight where  
    Red == Red = True  
    Green == Green = True  
    Yellow == Yellow = True  
    _ == _ = False

Making types instances of that typeclass

ghci> Red == Red  
True  
ghci> Red == Yellow  
False  
ghci> Red `elem` [Red, Yellow, Green]  
True  
ghci> [Red, Yellow, Green]  
[Red light,Yellow light,Green light]

typeclass of typeclass

class (Eq a) => Num a where  
   ...

How about Maybe or list type

This is wrong even Maybe m is concrete type

instance Eq (Maybe m) where  
    Just x == Just y = x == y  
    Nothing == Nothing = True  
    _ == _ = False

Class constraint

instance (Eq m) => Eq (Maybe m) where  
    Just x == Just y = x == y  
    Nothing == Nothing = True  
    _ == _ = False

:info

:info Num
:info Maybe

A yes-no typeclass

class YesNo a where  
    yesno :: a -> Bool

instance YesNo Int where  
    yesno 0 = False  
    yesno _ = True
instance YesNo [a] where  
    yesno [] = False  
    yesno _ = True
instance YesNo Bool where  
    yesno = id
instance YesNo (Maybe a) where  
    yesno (Just _) = True  
    yesno Nothing = False
instance YesNo (Tree a) where  
    yesno EmptyTree = False  
    yesno _ = True
instance YesNo TrafficLight where  
    yesno Red = False  
    yesno _ = True

The results

ghci> yesno $ length []  
False  
ghci> yesno "haha"  
True  
ghci> yesno ""  
False  
ghci> yesno $ Just 0  
True  
ghci> yesno True  
True  
ghci> yesno EmptyTree  
False  
ghci> yesno []  
False  
ghci> yesno [0,0,0]  
True  
ghci> :t yesno  
yesno :: (YesNo a) => a -> Bool

Create function for it

yesnoIf :: (YesNo y) => y -> a -> a -> a  
yesnoIf yesnoVal yesResult noResult = if yesno yesnoVal then yesResult else noResult

ghci> yesnoIf [] "YEAH!" "NO!"  
"NO!"  
ghci> yesnoIf [2,3,4] "YEAH!" "NO!"  
"YEAH!"  
ghci> yesnoIf True "YEAH!" "NO!"  
"YEAH!"  
ghci> yesnoIf (Just 500) "YEAH!" "NO!"  
"YEAH!"  
ghci> yesnoIf Nothing "YEAH!" "NO!"  
"NO!"

The Functor typeclass

f is not a concrete type. It has to be the type that take one type
list type is part of Functor
map :: (a -> b) -> [a] -> [b]

class Functor f where  
    fmap :: (a -> b) -> f a -> f b

map

Map is just a fmap that works only on lists.

instance Functor [] where  
    fmap = map

map :: (a -> b) -> [a] -> [b]  
ghci> fmap (*2) [1..3]  
[2,4,6]  
ghci> map (*2) [1..3]  
[2,4,6]

Maybe

instance Functor Maybe where  
    fmap f (Just x) = Just (f x)  
    fmap f Nothing = Nothing
ghci> fmap (++ " HEY GUYS IM INSIDE THE JUST") (Just "Something serious.")  
Just "Something serious. HEY GUYS IM INSIDE THE JUST"  
ghci> fmap (++ " HEY GUYS IM INSIDE THE JUST") Nothing  
Nothing  
ghci> fmap (*2) (Just 200)  
Just 400  
ghci> fmap (*2) Nothing  
Nothing

Tree

instance Functor Tree where  
    fmap f EmptyTree = EmptyTree  
    fmap f (Node x leftsub rightsub) = Node (f x) (fmap f leftsub) (fmap f rightsub)
ghci> fmap (*2) EmptyTree  
EmptyTree  
ghci> fmap (*4) (foldr treeInsert EmptyTree [5,7,3,2,1,7])  
Node 28 (Node 4 EmptyTree (Node 8 EmptyTree (Node 12 EmptyTree (Node 20 EmptyTree EmptyTree)))) EmptyTree

Either

Notice it take Either a
Left can hence be used for error type

instance Functor (Either a) where  
    fmap f (Right x) = Right (f x)  
    fmap f (Left x) = Left x

Data.Map

fmap will map a function v -> v' over a map of type Map k v and return a map of type Map k v'.

Kinds and some type-foo

Type constructors take other types as parameters to eventually produce concrete types. Just like how functions work.
Types are like are little labels that values carry. These labels are called Kinds.
Kind are type of a type.
- means concrete type

ghci> :k Int  
Int :: *

Maybe

ghci> :k Maybe  
Maybe :: * -> *

ghci> :k Maybe Int  
Maybe Int :: *

Either

ghci> :k Either  
Either :: * -> * -> *

ghci> :k Either String  
Either String :: * -> *  
ghci> :k Either String Int  
Either String Int :: *

Functor

So functor wants a partially apply type that takes one parameter.

class Functor f where   
    fmap :: (a -> b) -> f a -> f b

type-foo

a is *
j is * -> *
t is * -> (* -> *) -> *

class Tofu t where  
    tofu :: j a -> t a j

make a type with a kind of * -> (* -> ) ->

field in ADT must be type
a is *
b is * -> *
Frank is * -> (* -> *) -> *

data Frank a b  = Frank {frankField :: b a} deriving (Show)

ghci> :t Frank {frankField = Just "HAHA"}  
Frank {frankField = Just "HAHA"} :: Frank [Char] Maybe  
ghci> :t Frank {frankField = Node 'a' EmptyTree EmptyTree}  
Frank {frankField = Node 'a' EmptyTree EmptyTree} :: Frank Char Tree  
ghci> :t Frank {frankField = "YES"}  
Frank {frankField = "YES"} :: Frank Char []

Making instance

instance Tofu Frank where  
    tofu x = Frank x

ghci> tofu (Just 'a') :: Frank Char Maybe  
Frank {frankField = Just 'a'}  
ghci> tofu ["HELLO"] :: Frank [Char] []  
Frank {frankField = ["HELLO"]}

type-bar

data Barry t k p = Barry { yabba :: p, dabba :: t k }

ghci> :k Barry  
Barry :: (* -> *) -> * -> * -> *

instance Functor (Barry a b) where  
    fmap f (Barry {yabba = x, dabba = y}) = Barry {yabba = f x, dabba = y}

Making Our Own Types and Typeclasses

Making Our Own Types and Typeclasses

@wusyong, 吳昱緯

Algebraic data types intro

value constructor with fields

Usage in functions

make Shape type part of the Show typeclass

partially applied functions

more idiomatic way

More utilities

Export module

Record syntax

record syntax

Comparison

Type parameters

The variable is part of the typeclass the type derives

Map k v

Example: vector

Derived instances

Show & Read

Ord

Enum & Bounded

Let our enum to show/read

Let our enum to eq/ord

Let our enum to enum/bounded

Type synonyms

parameterized

partially apply type parameters

Either a b

Example: lockers

Example: lockers

Recursive data structures

fixity declarations

* and +

++

Example: binary search tree

Example: binary search tree

Example: binary search tree

Typeclasses 102

Making types instances of that typeclass

Making types instances of that typeclass

typeclass of typeclass

How about Maybe or list type

Class constraint

:info

A yes-no typeclass

The results

Create function for it

The Functor typeclass

map

Maybe

Tree

Either

Data.Map

Kinds and some type-foo

Maybe

Either

Functor

type-foo

make a type with a kind of * -> (* -> *) -> *

Making instance

type-bar

make a type with a kind of * -> (* -> ) ->