haskell - types and typeclasses - typeclasses

 we've learned about some of the standard Haskell typeclasses and we've seen which types are in them. We've also learned how to automatically make our own types instances of the standard typeclasses by asking Haskell to derive the instances for us. 

 

You can think typeclasses are like interfaces in other languages. 

 

in this post we will see how to make our own typeclases and then make instances of the typeclases that we created. 

 

what we will cover in this post include the following. 

• recap of the common typeclasses such as Eq
• implements our own data tyoe TrafficLight and make it part of Eq, Show, and etc...
• typeclasses constraint - such as one typeclasses are subclasses of another tyepclasses
• typeclasses with type parameter, such as "instance Eq (Maybe  m) where", and other type of constraint such as "instance (Eq m) => Eq (Maybe m) where "
• a customized typeclasses "yesno" 
• recap on the functor typeclasses. 

Let's get a feel of typeclass "Eq" such as such .

 

 

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

 

 

then we will make a trafficLight typeclass and we will make it part of Eq and Show. 

 

--file 
-- type_synonyms.hs
-- description:
--  type synonyms 102, where we will examine more on the Type classes


-- below is how the Eq type class is implemented in Prelude

-- check on this page on the information about
--  "Haskell - Redefining (hiding) arithmetic operators"
-- http://stackoverflow.com/questions/2388604/haskell-redefining-hiding-arithmetic-operators
import Prelude hiding (Eq, ShowS, (==), (/=))

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

data TrafficLight = Red | Yellow | Green


-- unlike the used case where we will define some classes where 
--   deriving from some types 
-- but we 
--   define an instance of the Eq typeclasses
instance Eq TrafficLight where  
    Red == Red = True  
    Green == Green = True  
    Yellow == Yellow = True  
    _ == _ = False

-- actually we only need to fullfill the minimalist of the Eq classes like this:
-- class Eq a where  
--     (==) :: a -> a -> Bool  
--     (/=) :: a -> a -> Bool  

-- and you can also define the instance of Show typeclasses 
-- like this: 
instance Show TrafficLight where 
  show Red = "Red Light" 
  show Yellow = "Yellow light"
  show Green = "Green light"


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


-- makes types that are sub-types of others. 
--
-- class (Eq a ) => Num a where
--    ... 

-- it is like a writing of "class Num a where"o
-- only we state that our type a must be an instance of Eq
-- we are essentially saying that we have to make a type an instance of Eq before we can make it an instance of Num

-- in the code above, the a has to be a concrete type but Maybe  is not a concrete type, 
-- suppose that you are writing an instance of Eq on Maybe m
-- here is how you might have written it 
-- instance Eq (Maybe m) where
--    Just x == Just y = x == y 
--    Nothing == Nothing = True
--    _ == _ = False 


-- see the problems within?
-- you can compare the Maybe types, but you have no assurance that what the Maybe contains can be used with Eq!. 
-- that is why we have to modify our instance declaration like this :
instance (Eq m) => Eq (Maybe m) where 
    Just x == Just y = x == y  
    Nothing == Nothing = True  
    _ == _ = False 

-- we are saying 
-- QUOTE: we want all types of the form Maybe m to be part of the Eq typeclass, but only those types where the m (so what's contained inside the Maybe) is also a part of Eq. 


-- When making instances, if you see that a type is used as a concrete type in the type declarations (like the a in a -> a -> Bool)

-- NOTE:
-- you can 
-- info YourTypeClass
-- :info Maybe

 

 

About thte type constraint and one typeclasses being a sub-type of another typeclasses. we have seen from the example above that 

 

 

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

 

 

for a number type a, it first has to be a Eq type.  this is the one of the simple form of constraint, we can have other constraint as well, consider that for a Maybe type to be equable, we frist need to make sure that the types that Maybe contains is equable, so you can do like this: 

 

 

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

 

 

 

As I said before, we will make a typecalsses called Yes-no typeclasses. here it is 

 

-- file
--  type_classes_yesno_typeclasses.hs
-- description:
--  type classes exaple : an yesno type classes

class YesNo a where 
  yesno :: a -> Bool


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

data TrafficLight = Red | Yellow | Green

instance YesNo Int where  
    yesno 0 = False  
    yesno _ = True 

instance YesNo [a] where  
    yesno [] = False  
    yesno _ = True

instance YesNo Bool where  
    yesno = id    

-- NOTE::
--   Joe's Note
-- We didn't need a class constraint because we made no assumptions about the contents of the Maybe
-- however, I can think of one , where you don't want  a Maybe a,
-- but the a is yet another Maybe, and the value is Nothing...
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  


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


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!"  

 As we can see, that we basically tell if a type which is part of the yesno typeclasses such as List, Tree, and Traffice light we made before. 

 

 

 

Now, as promised, we will present the Functor typeclass, which is basically for things that can be mapped over.  another thing about the Functor is that it does not want  you to provide a concrete type, because it expect one type , the function f expect to take one type construcor, we will see that for the [] type and the maybe types., 

Below is the Functor declaration. 

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

 

 and below is the instance declaration for the functor of type [] 

 

 

instance Functor [] where  
    fmap = map  

 

and below is how  you make some of the types parts of the Functor typeclasses. 

-- file 
--   type_classes_functor_class.hs
-- description:
--   defien a Functor type classes

-- QUOTE 
--  But now, the f is not a concrete type (a type that a value can hold, like Int, Bool or Maybe String), but a type constructor that takes one type parameter.
--  we see that fmap takes a function from one type to another and a functor applied with one type and returns a functor applied with another type.
-- 

import Prelude hiding (Functor, fmap, mapM, Left, Right, Either)

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


instance Functor [] where 
  fmap = map 

-- that's is!
--   instance Functor [a] where
-- notice how we didn't wirte instance Functor [a] where
--  because from fmap :: (a -> b) -> f a -> f b, we see that the f has to be a type constructor that takes one type. [a] is already a concrete type (of a list with any type inside it), while [] is a type constructor that takes one type and can produce types such as [Int], [String] or even [[String]].


-- Since for lists, fmap is just map, we get the same resutls when using htem on lists. 
-- map :: (a -> b) -> [a] -> [b]  
-- ghci> fmap (*2) [1..3]  
-- [2,4,6]  
-- ghci> map (*2) [1..3]  
-- [2,4,6] 


instance Functor Maybe where  
    fmap f (Just x) = Just (f x)  
    fmap f Nothing = Nothing  

-- and we can write the following . 
-- 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  

-- a Functor which is our Tree a
--  it can be thought of as a box in a way 
-- (holds several or no values) 
-- and the "Tree" type constructor takes exactly one type parameter
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)


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




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  

data Either a b = Left a | Right b deriving (Eq, Ord, Read, Show)

-- Well, if we wanted to map one function over both of them, a and b would have to be the same type.
-- 
instance Functor (Either a) where  
    fmap f (Right x) = Right (f x)  
    fmap f (Left x) = Left x