Haskell Types (Continued...)

Defining New Types

Chapter 8 in Learn You a Haskell ... (Algebraic data types intro).

• type: Does not really define a new type, just provides a new name for an existing type (type synonym)

  type Name = Existing_type

• Constructing types: use the data function and define value constructors (constructor functions for the new type)
  • Value constructors can take zero, one, or multiple parameters, e.g.,

        data Bool = False | True
        data DayOfWeek = Sunday | Monday | Tuesday | Wednesday | Thursday | Friday | Saturday
    
        data Point = Point Float Float deriving (Show)
        data Shape = Circle Point Float | Rectangle Point Point
            deriving (Show)
        area :: Shape -> Float
        area (Circle (Point x y) r) = pi * r^2
        area (Rectangle (Point ulX ulY) (Point lrX lrY)) = (lrX - ulX) * (lrY - ulY)
    
        data IntBinTree Int = Leaf Int | Branch Int (IntBinTree Int) (IntBinTree Int)
            deriving (Show)
        data BinTree aType = Leaf aType | Branch aType (BinTree aType) (BinTree aType)
            deriving (Show)
        fringe :: BinTree aType -> [aType]
        fringe (Leaf x) = [x]
        fringe (Branch x left right) = fringe left ++ fringe right
    

    Expression that builds a tree:

        Branch "Lauren" (Branch "Alyce" (Leaf "John") (Leaf "Jan"))
                        (Branch "JB" (Leaf "Jack") (Leaf "Mary"))
    

Typeclasses

Also in Chapter 8 in Learn You a Haskell ... (Typeclasses 102).

• A typeclass is like an interface.

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

• A type is an instance of a type class.

          instance Eq Bool where  (x == y) = (x && y) || (not x && not y)
                                  (x /= y) = not (x == y)
  

• Typeclasses can be used as constraints in signatures:

          deleteFirstMatching:: (Eq a) => [a] -> a -> [a]
          deleteFirstMatching [ ] _ = [ ]
          deleteFirstMatching (h : rest) item
              | h == item = rest
              | otherwise = h : (deleteFirstMatching rest item)
  

  Since we're using == in a guard, the type variable (a) must represent a type that is an instance of Eq.