- 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, _+_) //  // (z:Int,x:Int) => z + x

res1: Int = 63

Folds

Different element and aggregate 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, "!", _ + " " + _) // (z:String,x:Int) => z + " " + x

res1: String = "! 11 21 31 "

Folds

Abstracting the types

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

Fold vs. Reduce

List(1,2,3).fold(0)(_ + _)

List(1,2,3).reduce(_+_)

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)
def reduce  [X] (xs: List[X], f: (X,X)=>X)

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

Exceptions when Folding

• Example: turn list of tuples into sum of divisions

  List(4->2,9->3).foldLeft(0) { case (acc,(n,d)) => acc + n/d }
  

• Division by 0

  List(4->2,5->0,9->3).foldLeft(0) { case (acc,(n,d)) => acc + n/d }
  

• Collect first exception in Either

  List(4->2,5->0,9->3).foldLeft[Either[Throwable,Int]](Right(0)) {
     case (acc,(n,d)) => acc.flatMap {
        a => try
               Right(a + n/d)
             catch
               e => Left(e)
     }
  }
  

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,_)=>z+1)
def reverse [X] (xs: List[X])                = xs.foldLeft(Nil:List[X])((zs,x)=>x::zs)
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)
def reduce  [X] (xs: List[X], f: (X,X)=>X) = xs.tail.foldLeft(xs.head)(f)