1. Haskell
Chapter 7

2. Topics Defining data types Not covered Exporting types Type parameters
Derived instances
Type synonyms
Either
Type classes
Not covered
record syntax
recursive data structures
subclassing
parameterized types as instances of type classes
Yes-No type class (emulate JavaScript-like behavior)
Functor type class

3. Example: Define a data type
data Bool = False | True
data keyword indicates a new data type
Bool is not new, just an example
False and True are value constructors
| is “or” – Bool can be False or True
Type name and value constructors must start with capital letter
Value constructors are actually functions that return a value of a data type

4. Shape example -- Circle parms coordinates and radius
-- Rectangle parms upper left and lower right coordinates
data Shape = Circle Float Float Float
| Rectangle Float Float Float Float
*Main> :t Circle
Circle :: Float -> Float -> Float -> Shape
*Main> :t Rectangle
Rectangle :: Float -> Float -> Float -> Float -> Shape

5. Shape continued Notice the pattern match against constructor
area :: Shape -> Float
area (Circle _ _ r) = pi * r ^2
area (Rectangle x1 y1 x2 y2) = (abs $ x2 - x1) * (abs y2 - y1)
Notice the pattern match against constructor
*Main> let c = Circle 3 4 5
*Main> area c
But we don’t know how to show a circle (yet)
*Main> c
<interactive>:15:1:
No instance for (Show Shape)
arising from a use of `print'
Possible fix: add an instance declaration for (Show Shape)
In a stmt of an interactive GHCi command: print it
remember $ is function application

6. Updating shape to be displayed
data Shape = Circle Float Float Float | Rectangle Float Float Float Float
deriving (Show)
*Main> let c = Circle 3 4 5
*Main> c
Circle

7. Improving Shape with a Point data type
data Point = Point Float Float deriving (Show)
data Shape = Circle Point Float | Rectangle Point Point deriving (Show)
area :: Shape -> Float
area (Circle _ r) = pi * r ^2
area (Rectangle (Point x1 y1) (Point x2 y2)) = (abs $ x2 - x1) * (abs y2 - y1)
*Main> area (Rectangle (Point 0 0) (Point ))

8. Another method for Shapes
nudge :: Shape -> Float -> Float -> Shape
nudge (Circle (Point x y) r) dx dy = Circle (Point (x+dx) (y+dy)) r
nudge (Rectangle (Point x1 y1) (Point x2 y2)) dx dy =
Rectangle (Point (x1+dx) (y1+dy)) (Point (x2+dx) (y2+dy))
*Main> nudge (Circle (Point 34 34) 10) 5 10
Circle (Point ) 10.0

9. Exporting shape module Shapes ( Point(..) , Shape(..) , area , nudge
) where
Shape(..) exports all value constructors (in this case Circle and Rectangle).
Makes it easy to add more shapes later (OCP)
If just export Shape, not Shape(..), can’t pattern match (Programming Languages: support for encapsulation)

10. Type Constructors
A value constructor takes some parameters, produces a new value
e.g., Circle takes 2 values (Point and Float), returns a circle value
A type constructor takes a type as a parameter, returns a new type*
Maybe type constructor defined as:
data Maybe a = Nothing | Just a
Can’t have just Maybe… needs to be Maybe something
*we’ve seen code that writes code… this is type code that creates a new type

11. Type Constructors and Strong Typing
Why is this useful? Strong typing.
In Java, null can match any Object type.
public Point fn() { return null; } // null is Point
public Rectangle fn() { return null; } // null is Rectangle
public Object fn() { return null; } // null is Object
In Haskell, must be more specific. If might be “null” then:
playerAt :: a -> Position -> Maybe Player
If definitely a Player returned then:
playerAt :: a -> Position -> Player
More on typing:

12. Usage
Due to type inference, often don’t pass parameters to type constructors explicitly
If a value is Just ‘a’, Haskell infers type as Maybe Char
Maybe Char = Nothing | Just ‘a’
*Main> Just 'a'
Just 'a'
*Main> :t Just 'a'
Just 'a' :: Maybe Char
*Main> :t 'a'
'a' :: Char
*Main> Just 1
Just 1
*Main> :t Just 1
Just 1 :: Num a => Maybe a
*Main> :t 1
1 :: Num a => a

13. Play with it *Main> Just "Haha" Just "Haha" *Main> Just 84
*Main> :t Just "Haha"
Just "Haha" :: Maybe [Char]
*Main> :t Just 84
Just 84 :: Num a => Maybe a
*Main> :t Nothing
Nothing :: Maybe a
*Main> Just 10 :: Maybe Double
Just 10.0

14. Type class \= Java class
In Java, we use a class as a blueprint to create objects
In Haskell, you use type classes to make a data type, then think about how it can act*
We do this with deriving
If types of all fields are part of a type class, then our new type can be part of that type class
String and Int are both Eq
String and Int are both Show
data Person = Person { name :: String, age :: Int }
deriving (Eq, Show)
* as stated in chapter 2, type class has some similarities to Java interfaces (not exact, of course)

15. Example
*Shapes> let frodo = Person {name = "Frodo Baggins", age = 43}
*Shapes> let bilbo = Person {name = "Bilbo Baggins", age = 100}
*Shapes> bilbo
Person {name = "Bilbo Baggins", age = 100}
*Shapes> bilbo == frodo
False
*Shapes> let imposter = Person {name = "Frodo Baggins", age = 43}
*Shapes> frodo == imposter
True

16. Enum example
data Day = Monday | Tuesday | Wednesday | Thursday | Friday | Saturday | Sunday
deriving (Eq, Show, Ord, Read, Bounded, Enum)
*Chap7> Wednesday
Wednesday
*Chap7> show Wednesday
"Wednesday"
*Chap7> read "Saturday" :: Day
Saturday
*Chap7> Saturday == Sunday
False
*Chap7> Monday `compare` Wednesday LT
*Chap7> Saturday > Friday
True
*Chap7> minBound :: Day
Monday
*Chap7> maxBound :: Day
Sunday
*Chap7> let weekend = [Friday .. Sunday]
(note space before ..)
*Chap7> weekend
[Friday,Saturday,Sunday]

17. Type Synonyms [Char] and String are type synonyms
type PhoneNumber = String
type Name = String
type PhoneBook = [(Name, PhoneNumber)]
inPhoneBook :: Name -> PhoneNumber -> PhoneBook -> Bool
inPhoneBook name pnumber pbook =
(name, pnumber) `elem` pbook
Not covered: parameterized type synonyms

18. Could be Either Use to encapsulate a value of one type or another
Is defined as:
data Either a b = Left a | Right b deriving (Eq, Ord, Read, Show)
*Chap7> Right 20
Right 20
*Chap7> Left "Whoa"
Left "Whoa"
*Chap7> :t Right 'a'
Right 'a' :: Either a Char
*Chap7> :t Left True
Left True :: Either Bool b

19. Either with try (not exam material)
The try functions
try :: Exception e => IO a -> IO (Either e a)Source
Similar to catch, but returns an Either result which is (Right a) if no exception of type e was raised, or (Left ex) if an exception of type e was raised and its value is ex. If any other type of exception is raised then it will be propagated up to the next enclosing exception handler.
try a = catch (Right `liftM` a) (return . Left)

20. Usage Maybe can be used if function might return a result or fail
Either can be used if there are multiple possible results
You’ll explore this more in the homework

21. Type Classes 102
Type classes are sort of like interfaces: they define behavior
Types that can behave that way are made instances (just means they can use the functions associated with that type class)
class Eq a where
(==) :: a -> a -> Bool
(/=) :: a -> a -> Bool
x == y = not (x /= y)
x /= y = not (x == y)
note the mutual recursion… only need to implement one!

22. Using a type class
data TrafficLight = Red | Yellow | Green instance Eq TrafficLight where Red == Red = True Green == Green = True Yellow == Yellow = True _ == _ = False instance Show TrafficLight where show Red = "Red Light" show Green = "Green Light" show Yellow = "Yellow Light"

23. Using the Traffic Light
*Chap7> Red
Red Light
*Chap7> Red == Red
True
*Chap7> Red == Green
False
*Chap7> Red `elem` [Red, Green, Yellow]