1. Overview
Collections in Scala provide various built-in functions for creating, transforming and validating them. f**orall() is a built-in function that helps us validate data within a collection.
In this tutorial, we’ll explore its usage through some examples. We’ll be using the Scala REPL to run all the examples.
2. Using f**orall() With Collections
We can use the forall() function to validate that all the elements of a collection satisfy a predicate. This means that in order to return true, all the elements must fulfil the predicate.
Let’s see this with an example:
scala> val seq = Seq(1,2,3,4,5)
seq: Seq[Int] = List(1, 2, 3, 4, 5)
scala> seq.forall(_ < 10)
res0: Boolean = true
Here, we use forall() to see if all the elements of the sequence are less than 10. Since this is true for all the elements, the function returns true.
Now, let’s see the exact opposite, by checking if the elements of the sequence are all less than 5:
scala> seq.forall(_ < 5)
res1: Boolean = false
The elements cannot satisfy the predicate, since number 5 is not less than 5, and the function returns false.
Although forall() is pretty straightforward, there’s one tricky case. What will it return if we use it in an empty collection? Since there is no element to satisfy the predicate would it return false? Let’s find out with another example:
scala> val emptySeq = Seq.empty[Int]
emptySeq: Seq[Int] = List()
scala> emptySeq.forall(_ > 10)
res2: Boolean = true
As mentioned in the function’s documentation, forall() returns true if the collection is empty or the given predicate holds for all the elements, otherwise it returns false.
By checking the function’s implementation, we can see the reason:
def forall(p: A => Boolean): Boolean = {
var res = true
val it = iterator
while (res && it.hasNext) res = p(it.next())
res
}
The function starts by assuming that the predicate is satisfied and it will become false when it finds an element that doesn’t satisfy it.
3. Using f**orall() With Map
We can also use forall() with Map, allowing us to validate both keys and values:
scala> val map = Map(1 -> 1, 2 -> 2, 3 -> 3, 4 -> 4, 5 -> 5)
map: scala.collection.immutable.Map[Int,Int] = Map(5 -> 5, 1 -> 1, 2 -> 2, 3 -> 3, 4 -> 4)
scala> map.forall { case (key, value) => key < 10 }
res3: Boolean = true
scala> map.forall { case (key, value) => value < 10 }
res4: Boolean = true
scala> map.forall { case (key, value) => key + value < 20 }
res5: Boolean = true
We created a Map with the same number of Int keys and values for simplicity. First, we performed validation on the keys. All the keys satisfy the predicate and the function returns true. Then, we performed the same validation on the values. Again, all the values satisfy the predicate and the function returns true. From the last example, we can see that we can even perform validations on both the keys and their values.
Using the same Map, let’s see some examples where forall() returns false because we don’t satisfy the predicate condition:
scala> map.forall { case (key, value) => key < 5 }
res6: Boolean = false
scala> map.forall { case (key, value) => value < 5 }
res7: Boolean = false
scala> map.forall { case (key, value) => key + value < 10 }
res8: Boolean = false
In the examples above, we don’t satisfy the predicate for all the elements, keys, values, or their combination and the function returns false.
Finally, let’s see what happens if we use forall() on an empty Map:
scala> val emptyMap: Map[Int, Int] = Map.empty
emptyMap: Map[Int,Int] = Map()
scala> emptyMap.forall { case (key, value) => key > 10 }
res9: Boolean = true
scala> emptyMap.forall { case (key, value) => value > 10 }
res10: Boolean = true
scala> emptyMap.forall { case (key, value) => key + value > 10 }
res11: Boolean = true
As we can see, the function again returns true for an empty Map.
4. Using f**orall() With Option
Like most of the functions that we can use with collections*,* we can also use forall() with Option:
scala> val optionalInt = Some(5)
optionalInt: Some[Int] = Some(5)
scala> optionalInt.forall(_ < 10)
res12: Boolean = true
The function returns true, since the value of the Option satisfies the predicate*.*
If our value doesn’t satisfy the predicate, we notice the exact same behavior as we did with collections:
scala> optionalInt.forall(_ < 5)
res13: Boolean = false
And finally, let’s see what happens with an empty Option:
scala> val emptyOption: Option[Int] = None
emptyOption: Option[Int] = None
scala> emptyOption.forall(_ < 5)
res14: Boolean = true
So, as with collections, if we use forall() function with an empty Option, it returns true.
5. Using f**orall() vs. Using e**xists()
Another built-in function for collections, Option and Map worth noticing is the exists() function*.* exists() has the exact same interface as forall(). It takes a predicate and returns a Boolean, but its functionality is different.
While forall() validates the predicate for all the elements of a collection, exists() only needs to find one:
scala> val newSeq = Seq(1, 2, 3, 4, 5, 6)
newSeq: Seq[Int] = List(1, 2, 3, 4, 5, 6)
scala> newSeq.exists(_ > 5)
res15: Boolean = true
scala> newSeq.exists(_ > 10)
res16: Boolean = false
newSeq has exactly 1 element that’s greater than 5, the number 6, so we satisfy the predicate for at least 1 element and the function returns true. On the other hand, since there’s no element that’s greater than 10, the predicate is not satisfied and the function returns false for the second case.
Now, let’s see what happens if we use the exists() function on an empty collection:
scala> val newEmptySeq: Seq[Int] = Seq.empty
newEmptySeq: Seq[Int] = List()
scala> newEmptySeq.exists(_ > 5)
res17: Boolean = false
We don’t satisfy the predicate, so the function returns false. By comparing its implementation with forall(), we can see that exists() assumes that the predicate isn’t satisfied and stops iterating when it finds an element that satisfies it:
def exists(p: A => Boolean): Boolean = {
var res = false
val it = iterator
while (!res && it.hasNext) res = p(it.next())
res
}
6. Conclusion
In this article, we saw how we can use the forall() function with collections, Option and Map and its practical difference with the exists() function*.*