CSC447

Concepts of Programming Languages

Functions over Lists

Instructor: James Riely

Print Every Element

How to print every element of a list? 

def printList (xs:List[Int]) : Unit = 







val xs = List(11,21,31)
printList (xs)

Print Every Element

How to print every element of a list? 

def printList (xs:List[Int]) : Unit = xs match 
  case Nil   => ()
  case x::xt => 

    printList (xt)

val xs = List(11,21,31)
printList (xs)

Print Every Element

How to print every element of a list? 

def printList (xs:List[Int]) : Unit = xs match 
  case Nil   => ()
  case x::xt => 
    println (x)
    printList (xt)

val xs = List(11,21,31)
printList (xs)
          

11
21
31

Format Every Element

Do something different? 

def printListFormat (xs:List[Int]) : Unit = xs match 
  case Nil   => ()
  case x::xt => 
    println ("0x%02x".format(x))
    printListFormat (xt)

val xs = List(11,21,31)
printListFormat (xs)
          

0x0b
0x15
0x1f

Format Every Element

Different type of list? 

def printListLengths (xs:List[List[Int]]) : Unit = xs match 
  case Nil   => ()
  case x::xt => 
    println (x.length)
    printListLengths (xt)

val xss = List(List(11,21,31),List(),List(41,51))
printListLengths (xss)
          

3
0
2

Foreach

Abstract the idea of processing every element 

def foreach (xs:List[Int], f:Int=>Unit) : Unit = xs match 
  case Nil   => ()
  case x::xt => 
    f (x)
    foreach (xt, f)

val xs = List(11,21,31)
foreach (xs, println)
            

11
21
31

Foreach

Easy to make variations 

def foreach (xs:List[Int], f:Int=>Unit) : Unit = xs match 
  case Nil   => ()
  case x::xt => 
    f (x)
    foreach (xt, f)
def printHex (x:Int) = println("0x%02x".format(x))
val xs = List(11,21,31)
foreach (xs, printHex)
            

0x0b
0x15
0x1f

Foreach

Abstract the type 

def foreach [X] (xs:List[X], f:X=>Unit) : Unit = xs match 
  case Nil   => ()
  case x::xt =>  
    f (x)
    foreach (xt, f)
def printLength (xs:List[Int]) = println (xs.length)
val xss = List(List(11,21,31),List(),List(41,51))
foreach (xss, printLength)
          

3
0
2

Foreach

Anonymous function, AKA lambda expression 

def foreach [X] (xs:List[X], f:X=>Unit) : Unit = xs match 
  case Nil   => ()
  case x::xt => 
    f (x)
    foreach (xt, f)

val xss = List(List(11,21,31),List(),List(41,51))
foreach (xss, (xs:List[Int]) => println (xs.length))
          

3
0
2

Foreach

Anonymous function, AKA lambda expression 

foreach (xss, (xs:List[Int]) => println (xs.length))
Versus 

def printLength (xs:List[Int]) = println (xs.length)
foreach (xss, printLength)
Also possible 

val printLength = (xs:List[Int]) => println (xs.length)
foreach (xss, printLength)

Function Parameters

f is a function parameter 

def foreach [X] (xs:List[X], f:X=>Unit) : Unit = ...
          

foreach: [X](xs: List[X], f: X => Unit)Unit
f has type X=>Unit
  • takes an argument of type X
  • returns a result of type Unit

Builtin foreach

Scala List class has foreach method 

xs.foreach ((x:Int) => println ("0x%02x".format(x)))
          

0x0b
0x15
0x1f
vs our own foreach function 

foreach (xs, ((x:Int) => println ("0x%02x".format(x)))
            

0x0b
0x15
0x1f

Type inference

Types unnecessary if Scala can infer 

xs.foreach (x => println ("0x%02x".format(x)))
          

0x0b
0x15
0x1f

Builtin foreach

Special syntax 

for x <- xs do println ("0x%02x".format(x))
is compiled to 

xs.foreach (x => println ("0x%02x".format(x)))
for loops use foreach and more...

Anonymous functions

Using lambda notation 

val add = (x:Int, y:Int) => x+y
add(11,21)
Use underscore when parameters used exactly once 

val add = (_:Int) + (_:Int)
add(11,21)
Types may be inferred in some contexts 

var add : (Int,Int)=>Int = null  
add = (x,y) => x+y
add = _ + _
add(11,21)

Imperative loops

Using foreach and a variable in scope 

def sum (xs:List[Int]) : Int = 
  var result = 0
  xs.foreach ((x:Int) => result = result + x)
  result
(but folds are better! stay tuned...)

Debugging recursive functions

Use a compound expression 

def foreach [X] (xs:List[X], f:X=>Unit) : Unit = 
  println("call foreach(%s)".format(xs))
  xs match 
    case Nil   => ()
    case x::xt => 
      f (x)
      foreach (xt, f)
  println("rtrn foreach(%s)".format(xs))

val xs = List(21,31)
foreach (xs, (x:Int) => ())
          

call foreach(List(21, 31))
call foreach(List(31))
call foreach(List())
rtrn foreach(List())
rtrn foreach(List(31))
rtrn foreach(List(21, 31))

Equality

Return a reference to a list 

def reference (xs:List[Int]) : List[Int] = xs



xs eq reference(xs) /* reference equality */
xs == reference(xs) /* value equality */
          
res1: Boolean = true
res2: Boolean = true

Equality

Return a copy of a list 

def copy (xs:List[Int]) : List[Int] = xs match 
  case Nil   => Nil
  case x::xt => x::copy(xt)

xs eq copy(xs) /* reference equality */
xs == copy(xs) /* value equality */
          
res1: Boolean = false
res2: Boolean = true

Transformer

Return a transformed copy 

def transform (xs:List[Int]) : List[String] = xs match 
  case Nil   => Nil
  case x::xt => ("0x%02x".format (x)) :: transform (xt)

val xs = List(11,21,31)
transform(xs)
          
res1: List[String] = List(0x0b, 0x15, 0x1f)

Transformer

Return a transformed copy 

def transform (xs:List[List[Int]]) : List[Int] = xs match 
  case Nil   => Nil
  case x::xt => (x.length) :: transform (xt)

val xss = List(List(11,21,31),List(),List(41,51))
transform(xss)
          
res1: List[Int] = List(3, 0, 2)

Transformer

One cons cell in input => one cons cell in output 

def transform (xs:List[Int]) : List[String] = xs match 
  case Nil   => Nil
  case x::xt => ("0x%02x".format (x)) :: transform (xt)

val xs = List(11,21,31)
transform(xs)
          

transform (11::(21::(31::Nil)))
--> 0x0b::(transform (21::(31::Nil)))
--> 0x0b::(0x15::(transform (31::Nil)))
--> 0x0b::(0x15::(0x1f::(transform (Nil))))
--> 0x0b::(0x15::(0x1f::(Nil)))

Map

Abstracting f 

def map (xs:List[Int], f:Int=>String) : List[String] = xs match 
  case Nil   => Nil
  case x::xt => f(x) :: map (xt, f)

val xs = List(11,21,31)
map(xs, "0x%02x".format (_))
          

map (11::(21::(31::Nil)), f)
--> 0x0b::(map (21::(31::Nil), f))
--> 0x0b::(0x15::(map (31::Nil, f)))
--> 0x0b::(0x15::(0x1f::(map (Nil, f))))
--> 0x0b::(0x15::(0x1f::(Nil)))

Map

Showing f 

def map (xs:List[Int], f:Int=>String) : List[String] = xs match 
  case Nil   => Nil
  case x::xt => f(x) :: map (xt, f)

val xs = List(11,21,31)
map(xs, "0x%02x".format (_))
          

map (11::(21::(31::Nil)), f)
--> f(11)::(map (21::(31::Nil), f))
--> f(11)::(f(21)::(map (31::Nil, f)))
--> f(11)::(f(21)::(f(31)::(map (Nil, f))))
--> f(11)::(f(21)::(f(31)::(Nil)))

Map

Abstracting X and Y 

def map [X,Y] (xs:List[X], f:X=>Y) : List[Y] = xs match 
  case Nil   => Nil
  case x::xt => f(x) :: map (xt, f)

val xs = List(11,21,31)
map(xs, (x:Int) => "0x%02x".format (x))
          

map (11::(21::(31::Nil)), f)
--> f(11)::(map (21::(31::Nil), f))
--> f(11)::(f(21)::(map (31::Nil, f)))
--> f(11)::(f(21)::(f(31)::(map (Nil, f))))
--> f(11)::(f(21)::(f(31)::(Nil)))

Copy

Recall copy 

def copy [X] (xs:List[X]) : List[X] = xs match 
  case Nil   => Nil
  case x::xt => x :: copy (xt)

val xs = List(11,21,31)
copy(xs)
          

copy (11::(21::(31::Nil)))
--> 11::(copy (21::(31::Nil)))
--> 11::(21::(copy (31::Nil)))
--> 11::(21::(31::(copy (Nil))))
--> 11::(21::(31::(Nil)))

Map

copy(xs) same as map (xs, x=>x) 

def map [X,Y] (xs:List[X], f:X=>Y) : List[Y] = xs match 
  case Nil   => Nil
  case x::xt => f(x) :: map (xt, f)

val xs = List(11,21,31)
map(xs, (x:Int) => "0x%02x".format (x))
          

map (11::(21::(31::Nil)), f)
--> f(11)::(map (21::(31::Nil), f))
--> f(11)::(f(21)::(map (31::Nil, f)))
--> f(11)::(f(21)::(f(31)::(map (Nil, f))))
--> f(11)::(f(21)::(f(31)::(Nil)))

Foreach

Recall foreach 

def foe [X]   (xs:List[X], f:X=>Unit) : Unit = xs match 
  case Nil   => ()
  case x::xt =>{f(x) ;  foe (xt, f) }

val xs = List(11,21,31)
foe(xs, (x:Int) => println ("0x%02x".format(x)))
          

foe (11::(21::(31::Nil)))
--> foe (21::(31::Nil))
--> foe (31::Nil)
--> foe (Nil)
--> ()

Builtin map

Map method 

xs.map ("0x%02x".format (_))
          

res1: List[String] = List(0x0b, 0x15, 0x1f)
Same as our map function 

map (xs, "0x%02x".format (_))
            

res1: List[String] = List(0x0b, 0x15, 0x1f)

Builtin map

For expression 

for x <- xs yield "0x%02x".format(x)
          

for x <- xs do println ("0x%02x".format(x))
is compiled to 

xs.map (x => "0x%02x".format(x))
            

xs.foreach (x => println ("0x%02x".format(x)))
Difference is the yield

More map examples


val xss = List(List(11,21,31),List(),List(41,51))
xss.map (_.length)
            

res1: List[Int] = List(3, 0, 2)
            

val ys = List("hi", "mom", "it's", "me")
ys.map (_.length)
            

res1: List[Int] = List(2, 3, 4, 2)

Copy

Recall copy 

def copy    [X] (xs:List[List[X]]) : List[List[X]] = xs match 
  case Nil   => Nil
  case x::xt => x ::  copy    (xt)

val xss = List(List(11,21,31),List(),List(41,51))
          

    copy   (List(11,21,31) ::  List() ::  List(41,51) ::  Nil)
--> List(11,21,31) ::  copy   (List() ::  List(41,51) ::  Nil)
--> List(11,21,31) ::  List() ::  copy   (List(41,51) ::  Nil)
--> List(11,21,31) ::  List() ::  List(41,51) ::  copy   (Nil)
--> List(11,21,31) ::  List() ::  List(41,51) ::  Nil
=== List(List(11,21,31), List(), List(41,51))

Flatten

Replace :: with ::: 

def flatten [X] (xs:List[List[X]]) : List[X] = xs match 
  case Nil   => Nil
  case x::xt => x ::: flatten (xt)

val xss = List(List(11,21,31),List(),List(41,51))
          

    flatten(List(11,21,31) ::  List() ::  List(41,51) ::  Nil)
--> List(11,21,31) ::: flatten(List() ::  List(41,51) ::  Nil)
--> List(11,21,31) ::: List() ::: flatten(List(41,51) ::  Nil)
--> List(11,21,31) ::: List() ::: List(41,51) ::: flatten(Nil)
--> List(11,21,31) ::: List() ::: List(41,51) ::: Nil
=== List(11,21,31,41,51)

Map

Recall map 

def map     [X,Y] (xs:List[X], f:X=>List[Y]) : List[List[Y]] = xs match 
  case Nil   => Nil
  case x::xt => f(x) ::  map     (xt, f)

val as = List(3,0,2)
map    (as, (x:Int) => (11 to x*10+1 by 10).toList)
          

map     (3::0::2::Nil, f)
--> List(11,21,31):: map     (0::2::Nil, f)
--> List(11,21,31):: List():: map     (2::Nil, f)
--> List(11,21,31):: List():: List(11,21):: map     (Nil, f)
--> List(11,21,31):: List():: List(11,21):: Nil
=== List(List(11,21,31), List(), List(11,21))

FlatMap

Replace :: with ::: 

def flatMap [X,Y] (xs:List[X], f:X=>List[Y]) : List[Y] = xs match 
  case Nil   => Nil
  case x::xt => f(x) ::: flatMap (xt, f)

val as = List(3,0,2)
flatMap(as, (x:Int) => (11 to x*10+1 by 10).toList)
          

flatMap (3::0::2::Nil, f)
--> List(11,21,31):::flatMap (0::2::Nil, f)
--> List(11,21,31):::List():::flatMap (2::Nil, f)
--> List(11,21,31):::List():::List(11,21):::flatMap (Nil, f)
--> List(11,21,31):::List():::List(11,21):::Nil
=== List(11,21,31,11,21)

FlatMap

  • Map f:X=>List[Y]
    • Each element of result list is a List[Y]
    • Length of result = length of xs
  • FlatMap f:X=>List[Y]
    • Each element of result list is a Y
    • Length of result = sum of lengths of each List[Y]

Builtin flatMap


for xs <- xss; x <- xs yield x + 1
is compiled to 

xss.flatMap( xs => xs.map (x => x + 1) )
which is the same as 

xss.map( xs => xs.map (x => x + 1) ).flatten

Multiple iterators

For expressions are quite general 

val xss = List(List(11,21,31),List(),List(41,51))
for
  xs <- xss
  x <- xs
yield
  (x, xs.length)
          

res1: List[(Int, Int)] = List((11,3), (21,3), (31,3), (41,2), (51,2))
Equivalent to 

xss.flatMap (xs => xs.map (x => (x, xs.length)))

Multiple iterators

Compare 

val xss = List(List(11,21,31),List(),List(41,51))
for
  xs <- xss
yield 
  for
    x <- xs
  yield
    (x, xs.length)
          

res1: List[List[(Int, Int)]] = List(List((11,3), (21,3), (31,3)), List(), List((41,2), (51,2)))
Equivalent to 

xss.map (xs => xs.map (x => (x, xs.length)))

Multiple iterators

Cross product of independent iterators 

val xs = List(100,200,300)
val ys = List(50,70)
val zs = List(3,6,9)
for
  x <- xs
  y <- ys
  z <- zs
yield
  x + y + z
            

res1: List[Int] = List(153, 156, 159, 173, 176, 179, 253, 256, 259, 273, 276, 279, 353, 356, 359, 373, 376, 379)
Equivalent to 

xs.flatMap (x => ys.flatMap (y => zs.map (z => x + y z)))

Multiple iterators

Length is the product 

(for x <- (10 to 70 by 10); y <- (1 to 9) yield x+y).length
            

res1: Int = 63
Equivalent to 

(10 to 70 by 10).flatMap (x => (1 to 9).map (y => x+y)).length

Types in for expressions


val xs = List(11,21,31)
val ys = List("a","b")
for x <- xs; y <- ys yield (x, y)
          

xs : List[Int]
ys : List[String]
res1: List[(Int, String)] = List((11,a), (11,b), (21,a), (21,b), (31,a), (31,b))
Scala infers types for iterator variables 

x : Int
y : String
yield provides the type for the for expression 

(x, y) : (Int, String)
for ... yield (x, y) : List[(Int, String)]

Copy

Recall copy 

def copy   [X] (xs:List[X])               : List[X] = xs match 
  case Nil            => Nil
  case x::xt          => x :: copy   (xt)


val zs = (0 to 7).toList
copy(zs)
          

zs: List[Int] = List(0, 1, 2, 3, 4, 5, 6, 7)
res1: List[Int] = List(0, 1, 2, 3, 4, 5, 6, 7)

Filter

Only copy elements satisfying predicate f 

def filter [X] (xs:List[X], f:X=>Boolean) : List[X] = xs match 
  case Nil            => Nil
  case x::xt if f (x) => x :: filter (xt, f)
  case _::xt          =>      filter (xt, f)

val zs = (0 to 7).toList
filter(zs, (_ % 3 != 0))
          

zs: List[Int] = List(0, 1, 2, 3, 4, 5, 6, 7)
res1: List[Int] = List(1, 2, 4, 5, 7)

Builtin filter


for z <- zs; if z % 3 != 0 yield z
zs.filter (z => z % 3 != 0)
          

for z <- zs; if z % 3 != 0 yield "0x%02x".format(z)
zs.filter (z => z % 3 != 0).map (z => "0x%02x".format(z))
          

for z <- zs; if z % 3 != 0 do println ("0x%02x".format(z))
zs.filter (z => z % 3 != 0).foreach (z => println ("0x%02x".format(z)))