Data Types

We have worked with built-in Haskell data types, such as Int, Integer, Bool, and Float, as well as lists and tuples. It is also possible to define your own data types. All data types must begin with a capital letter.

Type Synonyms

A type synonym (using the type syntax) does not create a new data type. Instead, it creates a new name an existing data type. An example of this is String, which can be used interchangeably with [Char].

Examples:

type String = [Char]

type Complex = (Double, Double)

Exercise:
Define type Year with a synonym.

Exercise:
Define positions on the chessboard as pairs of characters and integers.

Parametrized Synonyms

Of course functions can have parameters. Data types can also have parameters. Parameter names must start with a lower-case letter.

Example:

type Two a = (a, a)

Usage:

Newtype Definition

newtype does create a new data type. newtype introduces a new type whose representation is the same as an existing type.

newtype Name = N String

• Type name: Name
• Constructor name: N
• Already existing type: String

Note that:

• Unlike type synonyms, it may be used to define recursive types.
• N coerces a value from type String to type Name without execution overhead.
• N ⊥ = ⊥

Notice the type of the constructor:

One can convert between Name and String with constructor N. Constructors can be used in pattern-matching.

x :: Name
x = N "table"

properName :: Name -> Bool
properName (N s) = isUpper (head s)

A newtype is not just a type synonym. The new type is not equivalent to the underlying type. This will not compile:

y :: Name
y = "void"

Some useful type classes

Type classes are not like classes in Java or C++.

Please look up these type classes in Haskell documentation or using :info command in ghci to learn about their functions and instances.

• Eq - Instances of this class can be compared for equality.
• Ord - Instances of this class can be compared for order.
• Show - Instances this class can be converted to a string.
• Data - Instances of this class can be introspected for value.
• Typeable - Instances of this class can be introspected for type.

Please note that if your data type is not an instance of the given type class, you can’t use the given operation on it. For example, given this declaration:

newtype AlmostString = AS String

then Haskell doesn’t know how to compare for equality:

<interactive>:1:1: error:
    • No instance for (Eq AlmostString) arising from a use of ‘==’
    • In the expression: AS "Hello" == AS "Goodbye"

This error message says, basically, “I can’t use the function == because AlmostString is not an instance of Eq.”

deriving Construct

Some type class instances can be derived automatically:

newtype Name = N String
   deriving (Eq, Ord, Show, Data, Typeable)

Name does not have the same limitation as AlmostString above:

The reason is that we have asked Haskell to make Name an instance of Eq. Haskell can do this automatically, because String is also an instance of Eq.

Exercise

Redefine Square as Square' with newtype! Let the constructor be S.

Define a smart constructor s, which is a function which checks proper construction of chess board positions. Use the error function to report an invalid parameter. Note that chess boards are 8x8 grids.

s :: (Char, Int) -> Square'

⊥₁: wrong
CallStack (from HasCallStack):
  error, called at ./FL_ADT_en.lhs:188:20 in main:FL_ADT_en

⊥₁: wrong
CallStack (from HasCallStack):
  error, called at ./FL_ADT_en.lhs:188:20 in main:FL_ADT_en

vectorEq :: Vector -> Vector -> Bool

vectorAdd :: Vector -> Vector -> Vector

Algebraic Data Types with One Constructor

Algebraic data type (variant type, ADT for short) is a data type each of whose values are derived from other data types, expressed by one of its constructors.

ADTs can be defined like that:

data IPoint = P Int Int
  deriving (Eq, Ord, Show, Data, Typeable)

• data keyword
• IPoint type constructor (type name)
• P constructor,
• which may have more than one parameter!

Note that P ⊥ ⊥ ≠ ⊥.

Usage:

mirrorO :: IPoint -> IPoint
mirrorO (P x y) = P (-x) (-y)

This also illustrates a way of how algebraic data types may be obtained, it is called a product of types. There is a special type, called “unit”, which is the product of no types. It is defined in Haskell as follows:

data () = ()

Exercise

Define translation on plane.

translate :: (Int, Int) -> IPoint -> IPoint

Records

Product types can also be given as records, for which the components of the tuples can be accessed by labels.

data RIPoint = RIP { rip_x :: Int, rip_y :: Int }
  deriving (Data, Typeable)

Literals for that type may be defined using the regular way.

origo :: RIPoint
origo = RIP 0 0

Or using the respective labels. Note that the labels in the definition below may be enumerated in any order.

origo' :: RIPoint
origo' = RIP { rip_y = 0, rip_x = 0 }

In Haskell, functions with the same name are generated automatically for the labels. That is why they have to be unique per module (independently of the nesting record definition) and cannot have the name of an existing function in the module.

Similar functions could be easily defined for the previous definitions as well. For example:

ip_x :: IPoint -> Int
ip_x (P x _) = x

And the following works too.

In addition to this, records feature a so-called record update syntax which makes it possible to change only certain fields of an existing record value.

The record syntax may work for pattern matching.

isOrigo :: RIPoint -> Bool
isOrigo (RIP { rip_y = y, rip_x = x }) = (x == 0) && (y == 0)

type, newtype and data

type    IPoint   = (Int, Int)
newtype IPoint   = P (Int, Int)
data    IPoint   = P Int Int
data    IPoint   = P (Int, Int)

2nd and 3rd are isomorphic, but syntax and usage is different.

More than One Constructor

Algebraic data types may be added up:

• The type is expressed as sum of other types.
• Values of the type could take several different, but fixed types.
• Only one of those types can be in use at a time.

data Direction
     = L
     | R
        deriving (Eq, Ord, Show, Data, Typeable)

• Direction type constructor
• L :: Direction constructor
• R :: Direction constructor

This is called an enumerated type.

numOfLs :: [Direction] -> Int

Differences between type, newtype, and data

Bool, Char, Int

Definition of Bool:

data Bool 
     = False 
     | True
         deriving (Eq, Ord, Show, Read, Enum)

Theoretical definition of Char:

data Char 
     = '\NUL' | '\SOH' | '\STX' | '\ETX' | '\EOT' | '\ENQ' | '\ACK' | '\a' 
     | '\b'   | '\t'   | '\n'   | '\v'   | '\f'   | '\r'   | '\SO'  | '\SI' 
     | '\DLE' | '\DC1' | '\DC2' | '\DC3' | '\DC4' | '\NAK' | '\SYN' | '\ETB' 
     | '\CAN' | '\EM'  | '\SUB' | '\ESC' | '\FS'  | '\GS'  | '\RS'  | '\US' 
     | ' '    | '!'    | '\"'   | '#'    | '$'    | '%'    | '&'    | '''    
     | '('    | ')'    | '*'    | '+'    | ','    | '-'    | '.'    | '/'    
     | '0'    | '1'    | '2'    | '3'    | '4'    | '5'    | '6'    | '7'    
     | '8'    | '9'    | ':'    | ';'    | '<'    | '='    | '>'    | '?'    
     | '@'    | 'A'    | 'B'    | 'C'    | 'D'    | 'E'    | 'F'    | 'G'    
     | 'H'    | 'I'    | 'J'    | 'K'    | 'L'    | 'M'    | 'N'    | 'O'    
     | 'P'    | 'Q'    | 'R'    | 'S'    | 'T'    | 'U'    | 'V'    | 'W'    
     | 'X'    | 'Y'    | 'Z'    | '['    | '\\'   | ']'    | '^'    | '_'    
     | '`'    | 'a'    | 'b'    | 'c'    | 'd'    | 'e'    | 'f'    | 'g'    
     | 'h'    | 'i'    | 'j'    | 'k'    | 'l'    | 'm'    | 'n'    | 'o'    
     | 'p'    | 'q'    | 'r'    | 's'    | 't'    | 'u'    | 'v'    | 'w'    
     | 'x'    | 'y'    | 'z'    | '{'    | '|'    | '}'    | '~'    | '\DEL' 
     | ...     -- 1114112 constructor
         deriving (Eq, Ord, Show, Read, Enum)

Theoretical definition of Int:

data Int = -2147483648 | -2147483647 | ... | 2147483647

Constructors with Parameters

data Colour
    = Named String
    | RGB Int Int Int
    | HSV Float Float Float
        deriving (Show)

Redundant, do not derive Eq!

toRGB :: Colour -> Colour
toRGB (Named "black") = RGB 0   0   0
toRGB (Named "white") = RGB 255 255 255
toRGB (Named "red")   = RGB 255 0   0
-- ...
toRGB color@(RGB r g b) = color
-- toRGB (HSV h s v) = ... -- conversion

Parametric Data

Useful:

data MaybeInt
    = NoInt
    | JustInt Int

Generalized form:

data Maybe a 
    = Nothing 
    | Just a
      deriving (Eq, Ord, Show, Typeable, Data)

In Java or C++, the absence of value is expressed with a special null value, and each program must check for null values. In Haskell, there is no null value. If you want to express the possibility of no value, use Maybe.

firstItem :: [a] -> Maybe a
firstItem [] = Nothing
firstItem (x:_) = Just x

safeHead :: [a] -> Maybe a

Prelude.Either

Definition of disjoint union:

data Either a b
   = Left a
   | Right b
      deriving (Typeable, Data)

Usage:

We can use Either (and other algebraic data types) to implement heterogeneous lists. Here is a list containing Chars and Bools. What is its type?

More parameterized types

data Param2 a b   =  Param2 a b

data Param3 a b c =  Param3 a b c

Imaginary definition (syntax is not correct):

data (a,b)    =  (a,b)
data (a,b,c)  =  (a,b,c)

Kind of Types

All the Maybe, Either, Param2, Param3 types are type constructors or higher-order types, they are similar to higher-order functions. However, it has to ensured that types are applied correctly in those cases. Hence the kind of types are introduced.

The kind of a type expresses the number of type arguments the given type can have. It is denoted by *, the star symbol. Some examples:

• Kind *: first-order type, without further parameters.
• Kind * -> *: type that can be applied to a first-order type, which then yields another first-order type.

GHCi supports querying the kind of a type, since version 7.4:

Note that types are also curried, so they may be applied partially, similarly to functions.

Peano Numbers

We can express natural numbers in Haskell’s type system. This is a recursive definition.

data Nat
    = Zero
    | Succ Nat      -- successor
        deriving (Eq, Show, Data, Typeable)

one :: Nat
two :: Nat

add :: Nat -> Nat -> Nat

Lists

We can define our own list type, equivalent to the built-in list type.

data List a           -- [a]
   = Nil              -- []
   | Cons a (List a)  -- a : [a]
     deriving (Data, Typeable)

Note that this structure implements a linked-list. Each non-empty node contains a value, and a reference to another node. In Java:

class List<E>
{
  public E value;
  public List<E> next; // may be null implicitly
}

An example value and its in-memory representation:

Define the length' function, equivalent to length.

length' :: List a -> Int

Binary Trees

Similar to the List type above.

data Tree a
   = Leaf
   | Node (Tree a) a (Tree a)
      deriving (Eq, Ord, Show, Data, Typeable)

Notice the types of the constructors:

For example:

mirror :: Tree a -> Tree a

foldTree :: (a -> b -> b -> b) -> b -> Tree a -> b

treeSize :: Tree a -> Int

true :: LExpr
false :: LExpr

var :: String -> LExpr

⊥₁: var: invalid variable name
CallStack (from HasCallStack):
  error, called at ./FL_ADT_en.lhs:762:12 in main:FL_ADT_en

infixr 3 `land`
land :: LExpr -> LExpr -> LExpr

infixr 2 `lor`
lor :: LExpr -> LExpr -> LExpr

lnot :: LExpr -> LExpr

implies :: LExpr -> LExpr -> LExpr

iff :: LExpr -> LExpr -> LExpr

render :: LExpr -> String

vars :: LExpr -> [String]

compile :: String -> LExpr -> String

rank :: Heap a -> Int

mkF :: Ord a => a -> Heap a -> Heap a -> Heap a

empty :: Heap a

singleton :: Ord a => a -> Heap a

isEmpty :: Heap a -> Bool

findMin :: Heap a -> Maybe a

merge :: Ord a => Heap a -> Heap a -> Heap a

insert :: Ord a => a -> Heap a -> Heap a

deleteMin :: Ord a => Heap a -> Maybe (Heap a)