- Concepts of Programming Languages

Collections Processing: Fold

Instructor:

Learning Objectives

How to combine collection elements into an aggregate result?

• Express result aggregation using fold
• Identify the difference between foldLeft and foldRight

Exercise: Sum the Elements of a List

Express by iterating through the list

int sum (List<Int> xs) {
  int result = 0;
  for (x : xs) result += x;
  return result;
}

def sum (xs:List[Int]) : Int = {
  var result = 0
  for x <- xs do result += x
  result
} ensuring { case result => ??? }

Exercise: Sum the Elements of a List

Express with a recursive function

def sum (xs:List[Int])            : Int =  xs match 
  case Nil     => 0
  case x::rest => x + sum (rest)
val xs = List(11,21,31)
sum (xs)

Exercise: Sum the Elements of a List

With a different zero element

def sum (xs:List[Int], z:Int = 0) : Int =  xs match 
  case Nil     => z
  case x::rest => x + sum (rest, z)
val xs = List(11,21,31)
sum (xs)

Exercise: Sum the Elements of a List

Sum of elements in a list computing forward

def sum (xs:List[Int], z:Int = 0) : Int =  xs match 
  case Nil     => z
  case x::rest => sum (rest, z + x)
val xs = List(11,21,31)
sum (xs)

Folds

generalize the + operation

def sum       (xs:List[Int], z:Int)                     : Int =  
  xs match 
    case Nil     => z
    case x::rest => sum       (rest, z + x)
val xs = List(11,21,31)
sum       (xs, 0)

res1: Int = 63

Folds

generalize the + operation

def foldLeft  (xs:List[Int], z:Int, f:((Int,Int)=>Int)) : Int = 
  xs match 
    case Nil     => z
    case x::rest => foldLeft  (rest, f(z,x), f)
val xs = List(11,21,31)
foldLeft  (xs, 0, _+_)

res1: Int = 63

Folds

Change the return type

def foldLeft  (xs:List[Int], z:String, f:(String,Int)=>String) : String = 
  xs match 
    case Nil     => z
    case x::rest => foldLeft  (rest, f(z, x), f)
val xs = List(11,21,31)
foldLeft  (xs, "[ ", _ + " " + _) + " ]"

res1: String = "[ 11 21 31 ]"

Folds

Changing the parameter type

def foldLeft  (xs:List[List[Int]], z:String, f:(String,List[Int])=>String) : String = 
  xs match 
    case Nil     => z
    case x::rest => foldLeft  (rest, f(z, x), f)
val xss = List( List(11,21,31), List(), List(41,51) )
foldLeft  (xss, "[", _ + " " + _.length) + " ]"

res1: Int = "[ 3 0 2 ]"

Folds

Abstracting the type

def foldLeft  [Z,X] (xs:List[X], z:Z, f:((Z,X)=>Z)) : Z =
  xs match 
    case Nil     => z
    case x::rest => foldLeft  (rest, f(z,x), f)
val xs = List(11,21,31)
foldLeft  (xs, "!", (z:String,x:Int) => z + " " + x)

res1: String = "! 11 21 31"

Fold Left vs. Fold Right

def foldLeft  [Z,X] (xs:List[X], z:Z, f:((Z,X)=>Z)) : Z =
  xs match 
    case Nil     => z
    case x::rest => foldLeft  (rest, f(z,x), f)
val xs = List(11,21,31)
foldLeft  (xs, "!", (z:String,x:Int) => z + " " + x)

res1: String = "! 11 21 31"

def foldRight [X,Z] (xs:List[X], z:Z, f:((X,Z)=>Z)) : Z =
  xs match 
    case Nil     => z
    case x::rest => f (x, foldRight (rest, z, f))
val xs = List(11,21,31)
foldRight (xs, "!", (x:Int,z:String) => x + " " + z)

res1: String = "11 21 31 !"

Folds Builtin in Lists

• Scala List class has fold methods (curried!)

  xss.foldLeft (0) ((z,xs) => z + xs.length)
  

Fold Left vs. Fold Right

def foldLeft [Z,X] (xs:List[X], z:Z, f:((Z,X)=>Z)) : Z =  xs match 
  case Nil     => z
  case x::rest => foldLeft (rest, f(z,x), f)

def foldRight [X,Z] (xs:List[X], z:Z, f:((X,Z)=>Z)) : Z =  xs match 
  case Nil     => z
  case x::rest => f (x, foldRight (rest, z, f))

val xs = List(a, b, c)
foldLeft (xs, z, f) === f( f( f(z,a),b),c)
foldRight(xs, z, f) === f(a, f(b, f(c,z)))

               xs.foldLeft(z)(f)       xs.foldRight(z)(f)
                      f                       f
                     / \                     / \
                    f   c                   a   f
                   / \                         / \
                  f   b                       b   f
                 / \                             / \
                z   a                           c   z

Folds are Universal

def sum         (xs: List[Int])             
def prod        (xs: List[Int])             
def or          (xs: List[Boolean])         
def and         (xs: List[Boolean])         
def append  [X] (xs: List[X])(ys: List[X])  
def flatten [X] (xs: List[List[X]])         
def length  [X] (xs: List[X])               
def reverse [X] (xs: List[X])               
def map   [X,Y] (xs: List[X], f: X=>Y)      
def filter  [X] (xs: List[X], f: X=>Boolean)

Summary

• Folds are universal functions to combine list elements into an aggregate result

xs.foldLeft(z)(f)
       f         
      / \        
     f   c       
    / \          
   f   b         
  / \            
 z   a           

xs.foldRight(z)(f)
       f
      / \
     a   f
        / \
       b   f
          / \
         c   z

Lots of examples, tutorial on universality of folds

Folds are Universal

def sum         (xs: List[Int])              = xs.foldLeft(0)(_+_)
def prod        (xs: List[Int])              = xs.foldLeft(1)(_*_)
def or          (xs: List[Boolean])          = xs.foldLeft(false)(_||_)
def and         (xs: List[Boolean])          = xs.foldLeft(true)(_&&_)
def append  [X] (xs: List[X])(ys: List[X])   = xs.foldRight(ys)(_::_)
def flatten [X] (xs: List[List[X]])          = xs.foldLeft(Nil:List[X])(_:::_)
def length  [X] (xs: List[X])                = xs.foldLeft(0)((z,x)=>z+1)
def reverse [X] (xs: List[X])                = xs.foldRight(Nil:List[X])((x,zs)=>zs:::List(x))
def map   [X,Y] (xs: List[X], f: X=>Y)       = xs.foldRight(Nil:List[Y])(f(_)::_)
def filter  [X] (xs: List[X], f: X=>Boolean) = xs.foldRight(Nil:List[X])((x,zs)=>if f(x) then x::zs else zs)