Acknowledgements: These slides accompany Chapter 4 “List Programming” from “Introduction to Functional Programming Using Haskell”.

Advisory: The HTML version of this document may require use of a browser that supports the display of MathML. A good choice as of September 2017 is a recent version of Firefox from Mozilla.

Lecture Goals

• Introduce Haskell immutable lists and data sharing

• Discuss polymorphism

• Introduce first-order polymorphic list programming

• Introduce infix operations and properties

• Reinforce concepts: recursive programming strategies, preconditions, postconditions, termination, time and space complexity

Haskell Data Structures

Immutable:

not subject to change as program executes

• Primitives: Int, Integer, Float, Double, Char, Bool

• Functions – chapter 5

• Tuples – chapter 2

• Lists (and String) – this chapter

• User-defined (algebraic) data types – chapter 8

Lists

• Type [t] sequence of zero or more values of type t – algebraic data type supported by syntactic sugar

• Hierarchical structure – either empty or pair of head element and tail list

• Empty list [] – pronounced “nil”

• “Cons” operator : constructs list from head/tail such as 3:[]

List Syntactic Sugar

Syntactic sugar:

notation that simplifies expression, but adds no new functionality

• Equivalent expressions

  5:(3:(2:[]))

  5:3:2:[] – “cons” binds from the right

  [5,3,2] – comma separated list literal

List Operations

• Constructor :

• Selector head (h:t) $\Longrightarrow$ h

• Selector tail (h:t) $\Longrightarrow$ t

• Prelude library functions: e.g., length, sum, product, take, drop, ++, reverse

String

• String type synonym for [Char]

      type String = [Char]

• Syntactic sugar: "oxford" same as [’o’,’x’,’f’,’o’,’r’,’d’]

• "Hello\nworld!\n" string with two newline characters

• "\12\&3" same as['\12','3']

• Example function to compute length of string

  len :: String -> Int
  len s  =  if s == [] then 0 else 1 + len (tail s)

Polymorphic Lists

Polymorphism:

property of having “many shapes”

• General length function for more types: use type variable

  len :: [a] -> Int

• Polymorphic type – think Java generic

  head :: [a] -> a
  tail :: [a] -> [a]
  (:)  :: a -> [a] -> [a]

Kinds of Polymorphism (1)

1. Ad hoc polymorphism, same function name denotes different implementations depending on use

   • Overloading, compiler determines which to invoke, early binding

     E.g., + in Java, Haskell type classes

   • Subtyping, runtime searches hierarchy of types, late binding

     Called just polymorphism in Java, does not exist in Haskell

Kinds of Polymorphism (2)

2. Parametric polymorphism, same implementation used for different types

   Called generics in Java, Haskell just polymorphism

Programming with List Patterns

• Use pattern matching on lists

• Follow the types to implementations

• Let form of the data guide form of the algorithm

• Consider two basic cases: empty and nonempty lists

Add List of Int (1)

• Type signature: sum' :: [Int] -> Int

• Sum of an empty list? sum' [] = 0

  identity element $0 + x = x = x + 0$

• Sum of nonempty list? sum' (x:xs) = x + sum' xs

  sum' :: [Int] -> Int  -- sum in Prelude
  sum' []     = 0           -- nil list 
  sum' (x:xs) = x + sum' xs -- non-nil list 

• sum' [2,4,6,8] yields 2 + (4 + (6 + (8 + 0)))

Add List of Int (2)

    sum' :: [Int] -> Int  -- sum in Prelude 
    sum' []     = 0           -- nil list 
    sum' (x:xs) = x + sum' xs -- non-nil list 

• Termination of sum' xs ? (What if xs infinite?)

• Precondition? Postcondition?

• Backward recursive? Tail recursive?

• Time complexity? Space complexity?

Add List of Int (3)

Exercise: Write a variant of sum' that uses a tail recursive auxiliary function.

Multiply List of Integer (1)

    product' :: [Integer] -> Integer  -- product in Prelude
    product' []     = 1               -- nil list
    product' (0:_)  = 0               -- 0 at head
    product' (x:xs) = x * product' xs -- non-nil, non-zero

• Identity element $1 + x = x = x + 0$

• Zero element $0 * x = x * 0 = 0$

• product' [2,4,6,8] yields 2 * (4 * (6 * (8 * 1)))

Multiply List of Integer (2)

    product' :: [Integer] -> Integer  -- product in Prelude
    product' []     = 1               -- nil list
    product' (0:_)  = 0               -- 0 head, don't care
    product' (x:xs) = x * product' xs -- non-nil, non-zero

• Termination of product' xs ?

• Precondition? Postcondition?

• Backward recursive? Tail recursive?

• Time complexity? Space complexity?

Comparison of sum' and product'

• sum' and product'

  • similar computational patterns – note!

  • different base types, but both numbers

  • both return identity element for nil

  • zero handled differently by product'

Length of List

    length' :: [a] -> Int  -- length in Prelude
    length' []     = 0              -- nil list
    length' (_:xs) = 1 + length' xs -- non-nil list

• Polymorphic list type

• Don’t care about actual value – use _

• Same correctness and complexity characteristics as sum'

Adjacent Duplicates (1)

• Problem: Replace group of adjacent duplicate integers by one occurrence

• What does adjacency mean?

  • fewer then two elements? $\longrightarrow$ keep everything

  • first two elements duplicates? $\longrightarrow$ remove one

  • first two elements not duplicates? $\longrightarrow$ keep both

  • more than two adjacent duplicates? $\longrightarrow$ step one element at time

Adjacent Duplicates (2)

• Function examines first two elements

  remdups :: [Int] -> [Int]
  remdups (x:y:xs)  -- note order of equations
    | x == y = remdups (y:xs) 
    | x /= y = x : remdups (y:xs) 
  remdups xs = xs 

• Termination of remdups xs ?

• Time complexity? Space complexity?

Adjacent Duplicates (3)

How can we make work for polymorphic list?

• [a] -> [a]?

• Cannot compare everything for equality (e.g., functions)

• Constrain to class Eq, which support == and /=

  remdups :: Eq a => [a] -> [a]
  remdups (x:y:xs) 
      | x == y = remdups (y:xs) 
      | x /= y = x : remdups (y:xs) 
  remdups xs = xs 

• Class Ord also useful, extend Eq with ordered comparisons <, <=, > >=

More List Patterns (1)

More List Patterns (2)

Data Sharing

    xs = [1,2,3]
    ys = 0:xs 
    zs = tail xs 

Data Sharing in Linked Lists

• For immutable xs, neither ys nor zs require copying

• Efficient immutable structures via data sharing – persistent

• But head xs and remdups xs require copying

Drop Elements from List (1)

• Generalize tail to drop' that removes first n elements

  drop' :: Int -> [a] -> [a]  -- drop in Prelude
  drop' n xs | n <= 0 = xs 
  drop' _ []          = []
  drop' n (_:xs)      = drop' (n-1) xs 

• drop 2 "oxford" $\Longrightarrow \cdots$ "ford"

• Different approach than tail to nil list – seems logical to return nil

• Data sharing between argument and result

Drop Elements from List (2)

    drop' :: Int -> [a] -> [a]  -- drop in Prelude
    drop' n xs | n <= 0 = xs 
    drop' _ []          = []
    drop' n (_:xs)      = drop' (n-1) xs 

• Termination of drop' n xs ? (note two base cases)

• Tail recursive?

• Time complexity? Space complexity?

Take Elements from List (1)

• Generalize head to take' that returns first n elements

  take' :: Int -> [a] -> [a] -- take in Prelude
  take' n _ | n <= 0 = []
  take' _ []         = []
  take' n (x:xs)     = x : take' (n-1) xs

• take 2 "oxford" $\Longrightarrow \cdots$ "ox"

• What returned when list nil?

Take Elements from List (2)

• Generalize head to take that returns first n elements

  take' :: Int -> [a] -> [a] -- take in Prelude
  take' n _ | n <= 0 = []
  take' _ []         = []
  take' n (x:xs)     = x : take' (n-1) xs

• Termination of take' n xs ?

• Data sharing?

• Tail recursive?

• Time complexity? Space complexity?

Infix Operations (1)

Binary operation:

function of type t1 -> t2 -> t3

• Often prefer infix syntax, e.g., x + y

• Use parentheses to specify order ((y * (z+2)) + x))

• Use precedence to avoid parentheses for different operators

  x + y * z same as (x + (y * z))

Infix Operations (2)

• Use binding or association order to avoid parentheses for similar operators

  • left binding x + y - z same as ((x + y) - z)

  • right binding x^y^z same as (x^(y^z))

  • free binding means no default binding order

• Haskell declarations for left, right, free binding with precedence 0-9, where higher number binds more tightly

  infixl n op
  infixr n op
  infix  n op

Common Infix Operations

    infixr 8 ^                     -- exponentiation
    infixl 7 *                     -- multiplication
    infix  7 /                     -- division
    infixl 6 +, -                  -- addition, subtraction
    infixr 5 :                     -- cons
    infix  4 ==, /=, <, <=, >=, >  -- relational comparisons
    infixr 3 &&                    -- Boolean AND
    infixr 2 ||                    -- Boolean OR 

Function application has precdence of 10

Appending Lists: ++

    infixr 5 ++
    
    (++) :: [a] -> [a] -> [a]   -- in Prelude 
    [] ++ xs     = xs           -- nil left operand 
    (x:xs) ++ ys = x:(xs ++ ys) -- non-nil left operand 

• Termination of xs ++ ys ?

• Precondition? Postcondition?

• Time complexity? Space complexity?

• Data sharing?

Properties of ++ (1)

Associativity if ++:

For any finite lists xs, ys, and zs, xs ++ (ys ++ zs) == (xs ++ ys) ++ zs

Identity for ++:

For any finite list xs, [] ++ xs = xs = xs ++ []

Properties of ++ (2)

• For all finite lists xs:

      sum (xs ++ ys)     = sum xs + sum ys 
      product (xs ++ ys) = product xs * product ys 
      length (xs ++ ys)  = length xs + length ys 

• For all natural numbers n and finite lists xs:

      take n xs ++ drop n xs = xs

Element Selection: !!

    infixl 9 !!

    (!!) :: [a] -> Int -> a 
    xs     !! n | n < 0 = error "!! negative index"
    []     !! _         = error "!! index too large"
    (x:_)  !! 0         = x 
    (_:xs) !! n         = xs !! (n-1) 

• Termination of xs !! n ?

• Precondition? Postcondition?

• Time complexity? Space complexity?

• Tail recursive? Data sharing?

Reversing a List: rev (1)

    rev :: [a] -> [a]
    rev []     = []            -- nil argument
    rev (x:xs) = rev xs ++ [x] -- non-nil argument

• Termination of rev xs ? (note ++)

• Precondition? Postcondition?

• Tail recursive?

• Time complexity? (careful!) Space complexity?

• Data sharing?

Reversing a List: rev (2)

Distribution:

For any finite lists xs and ys, rev (xs ++ ys) = rev ys ++ rev xs

Inverse:

For any finite list xs, rev (rev xs) = xs

For any finite lists xs and ys and natural numbers n,

    take n (rev xs)  = rev (drop (length xs - n) xs)

Tail recursive reverse

    reverse' :: [a] -> [a]n -- reverse in Prelude 
    reverse' xs = rev xs []
                  where rev []     ys = ys 
                        rev (x:xs) ys = rev xs (x:ys) 

• Termination of rev xs ys ?

• Precondition? Postcondition?

• Time complexity? Space complexity?

• Compare ++ versus :

Other Useful List Functions

    splitAt' :: Int -> [a] -> ([a],[a]) -- splitAt in Prelude
    splitAt' n xs =  (take' n xs, drop' n xs) 

    zip' :: [a] -> [b] -> [(a,b)]   -- zip in Prelude
    zip' (x:xs) (y:ys) = (x,y) : zip' xs ys -- zip.1
    zip' _      _      = []                 -- zip.1

    unzip' :: [(a,b)] -> ([a],[b])  -- unzip in Prelude
    unzip' []         = ([],[])
    unzip' ((x,y):ps) = (x:xs, y:ys)
                        where (xs,ys) = unzip' ps

Insertion Sort

Ascending:

Every element is <= all of its successors

• similar for descending, increasing, decreasing

Idea:

To sort x:xs, sort tail xs, then insert x at correct position

Empty list is sorted

Insertion Sort of Int

    isort :: [Int] -> [Int]
    isort []     = []
    isort (x:xs) = insert x (isort xs)

    insert :: Int -> [Int] -> [Int]
    insert x []     = [x]
    insert x xs@(y:ys)     -- xs alias of (y:xs)
        | x <= y    = (x:xs)
        | otherwise = y : (insert x ys)

• Termination of insert x xs ? of isort xs ?

• Time complexity of insert x xs ? of isort xs ?

• Space complexity of insert x xs ? of isort xs ?

Polymorphic Insertion Sort

Polymorphic list, element constrained to class Ord

    isort' :: Ord a => [a] -> [a]
    isort' []     = []
    isort' (x:xs) = insert' x (isort' xs)

    insert' :: Ord a => a -> [a] -> [a]
    insert' x []    = [x]
    insert' x xs@(y:ys)     -- xs alias of (y:xs)
        | x <= y    = (x:xs)
        | otherwise = y : (insert' x ys)

Key Ideas

• Polymorphism – powerful generalization mechanism

• Immutable lists and data sharing

• Follow the types to implementations

• Let form of the data guide form of the algorithm

• Infix operations and properties

Code

The Haskell code for this section is in file Mod04Lists.hs.