Functional programming in Scala

The following set of sections represent the exercises contained in the book "Functional Programming in Scala", written by Paul Chiusano and Rúnar Bjarnason and published by Manning. This content library is meant to be used in tandem with the book. We use the same numeration for the exercises for you to follow them.

For more information about "Functional Programming in Scala" please visit its official website.

Singly linked lists

Assume the following functions are available for your reference:

sealed trait List[+A]
case object Nil extends List[Nothing]
case class Cons[+A](head: A, tail: List[A]) extends List[A]

Exercise 3.1:

Examine the next complex match expression. What will be the result?

Exercise 3.15:

foldRight can also be useful to write a function concat that concatenates a list of lists into a single list. Take a look at its implementation:

def concat[A](l: List[List[A]]): List[A] =
  foldRight(l, Nil:List[A])(append)

Since append takes time proportional to its first argument, and this first argument never grows because of the right-associativity of foldRight, this function is linear in the total length of all lists.

More functions for working with lists

Exercise 3.16:

Let's keep digging into the uses of foldLeft and foldRight, by implementing a function that transforms a list of integers by adding 1 to each element:

Exercise 3.12:

As we saw above, we can write the previous functions we implemented using foldRight with foldLeft. Let's continue with reverse:

def reverse[A](l: List[A]): List[A] = foldLeft(l, List[A]())((acc, h) => Cons(h, acc))

Exercise 3.13:

In fact, we can write foldLeft in terms of foldRight, and the other way around:

 
  def foldRightViaFoldLeft[A,B](l: List[A], z: B)(f: (A,B) => B): B =
    foldLeft(reverse(l), z)((b,a) => f(a,b))

  def foldLeftViaFoldRight[A,B](l: List[A], z: B)(f: (B,A) => B): B =
    foldRight(l, (b:B) => b)((a,g) => b => g(f(b,a)))(z)

Exercise 3.14:

Another function we can implement by using foldRight is append:

def appendViaFoldRight[A](l: List[A], r: List[A]): List[A] =
  foldRight(l, r)(Cons(_,_))

Take a look at its implementation and check how it works:

Exercise 3.4:

We can generalize take to the function drop:

Exercise 3.5:

dropWhile extends the behaviour of drop, removing elements from the List prefix as long as they match a predicate. Study its implementation and check how it works with the following examples:

Exercise 3.20:

We're going to implement a new function that works like map except that the function given will return a list instead of a single result, and that list should be inserted into the final resulting list:

def flatMap[A,B](l: List[A])(f: A => List[B]): List[B] =
  concat(map(l)(f))

Let's try it out:

Exercise 3.10:

Let's write another general tail-recursive list-recursion function, foldLeft, using the techniques we discussed in the previous chapter:

def foldLeft[A,B](l: List[A], z: B)(f: (B, A) => B): B =
  l match {
    case Nil => z
    case Cons(h,t) => foldLeft(t, f(z,h))(f)
  }

Exercise 3.11:

Let's write functions sum, product and length of a list using foldLeft:

Exercise 3.8:

Now that we know how foldRight works, try to think about what happens when you pass Nil and Cons themselves to foldRight.

Recursion over lists and generalizing to higher-order functions

Exercise 3.x:

Let's run through the steps that foldRight will follow in our new implementation of sum2:

Exercise 3.24:

As a final example for working with lists, let's implement a hasSubsequence function for checking whether a List contains another List as a subsequence. For instance, List(1, 2, 3, 4) would have List(1, 2), List(2, 3) and List(4) as subsequences, among others:

@annotation.tailrec
  def startsWith[A](l: List[A], prefix: List[A]): Boolean = (l,prefix) match {
    case (_,Nil) => true
    case (Cons(h,t),Cons(h2,t2)) if h == h2 => startsWith(t, t2)
    case _ => false
  }

@annotation.tailrec
def hasSubsequence[A](sup: List[A], sub: List[A]): Boolean = sup match {
  case Nil => sub == Nil
  case _ if startsWith(sup, sub) => true
  case Cons(h,t) => hasSubsequence(t, sub)
}

Take a thorough look at the implementation of this function, and then try it out in the next exercise:

Exercise 3.6:

init can be implemented in the same fashion, but cannot be implemented in constant time like tail:

Exercise 3.9:

Let's try to use foldRight to calculate the length of a list. Try to fill the gaps in our implementation:

Exercise 3.17:

We can do something similar to turn each value in a List[Double] into a String:

def doubleToString(l: List[Double]): List[String] =
  foldRight(l, Nil:List[String])((h,t) => Cons(h.toString,t))

Exercise 3.18:

Both add1 and doubleToString modify each element in a list while maintaining its structure. We can generalize it in the following way:

def map[A,B](l: List[A])(f: A => B): List[B] =
  foldRight(l, Nil:List[B])((h,t) => Cons(f(h),t))

Exercise 3.19:

Let's apply the same principle as we use in map to remove elements from a list, starting with a function to remove all odd numbers from a List[Int]:

Exercise 3.3:

setHead follows a similar principle. Let's take a look at how it works:

Exercise 3.2:

Take a look at the implementation of List's tail function, and check its behaviour on the following cases:

Exercise 3.22:

Now we're going to write a function that accepts two lists of integers and constructs a new list by adding corresponding elements. i.e.: List(1, 2, 3) and List(4, 5, 6) become List(5, 7, 9):

def addPairwise(a: List[Int], b: List[Int]): List[Int] = (a,b) match {
  case (Nil, _) => Nil
  case (_, Nil) => Nil
  case (Cons(h1,t1), Cons(h2,t2)) => Cons(h1+h2, addPairwise(t1,t2))
}

Exercise 3.23:

We can generalize the function above so that it's not specific to integers or addition, zipWith:

def zipWith[A,B,C](a: List[A], b: List[B])(f: (A,B) => C): List[C] = (a,b) match {
  case (Nil, _) => Nil
  case (_, Nil) => Nil
  case (Cons(h1,t1), Cons(h2,t2)) => Cons(f(h1,h2), zipWith(t1,t2)(f))
}

Let's try out zipWith in the following exercise:

Exercise 3.26:

Following a similar implementation, we can write a function maximum that returns the maximum element in a Tree[Int]:

def maximum(t: Tree[Int]): Int = t match {
  case Leaf(n) => n
  case Branch(l,r) => maximum(l) max maximum(r)
}

Exercise 3.27:

In the same fashion, let's implement a function depth that returns the maximum path length from the root of a tree to any leaf.

Exercise 3.29:

To wrap this section up, let's generalize size, maximum, depth and map, writing a new function fold that abstracts over their similarities:

def fold[A,B](t: Tree[A])(f: A => B)(g: (B,B) => B): B = t match {
  case Leaf(a) => f(a)
  case Branch(l,r) => g(fold(l)(f)(g), fold(r)(f)(g))
}

Let's try to reimplement size, maximum, depth, and map in terms of this more general function:

Exercise 3.28:

We can also write a function map, analogous to the method of the same name on List, that modifies each element in a tree with a given function. Let's try it out in the following exercise:

Trees

Exercise 3.25:

Let's try to implement a function size to count the number of nodes (leaves and branches) in a tree: