Scala: How to use higher-order functions with Option (instead of match expressions)

I originally wrote a long introduction to this article about Scala Options, but I decided to keep that introduction for a future second article in this series. For this article I’ll just say:

  • idiomatic Scala code involves never using null values
  • because you never use nulls, it’s important for you to become an expert at using Option, Some, and None
  • initially you may want to use match expressions to handle Option values
  • as you become more proficient with Scala and Options, you’ll find that match expressions tend to be verbose
  • becoming proficient with higher-order functions (HOFs) like map, filter, fold, and many others are the cure for that verbosity

Given that background, the purpose of this article is to show how to use HOFs rather than match expressions when working with Option values.

Back to top

Sample data

Here are some simple functions and values that will be used in the table that follows:

def p(i: Int): Boolean = i == 0            // A => Boolean
def f(i: Int): Int = i * 2                 // A => A
def fo(i: Int): Option[Int] = Some(i * 2)  // A => Option[A]
val option: Option[Int] = Some(1)
val none: Option[Int] = None
val default = 1
val defaultSome = Some(1)
val stringOption = Option("foo")

In that code, p is a predicate (of type Int => Boolean), f is a simple function of type Int => Int (or more generally, A => A), fo is a function that returns an Option (A => Option[A]), and hopefully the rest of the code makes sense.

Notes about the following examples:

  • Because you know what result type you need when working with an Option in a specific situation, the table is sorted by the expression return type, which is shown in the first column
  • While my code uses Int values, in all but one example you can think of the expressions as using a generic type A
Back to top

From match expressions to higher-order functions

Here are the examples, grouped by the type the expressions return:

Result
Type
Match Expression HOF
Unit option match {
  case Some(i) => println(i)
  case None => ()
}
option.foreach(println)
for (o <- option) println(o)
A option match {
  case Some(i) => i
  case None => default
}
option.getOrElse(default)
A option match {
  case Some(i) => f(i)
  case None => default
}
option.map(f).getOrElse(default)
option.fold(default)(f)
Option[A] option match {
  case Some(i) => fo(i)
  case None => None
}
option.map(f)
option.flatMap(i => fo(i))
for (i <- option) yield f(i)
Option[A] option match {
  case Some(x) => Some(x)
  case None => defaultSome
}
option.orElse(defaultSome)
Option[A] option match {
  case Some(x) if p(x) =>
    Some(x)
  case _ => None
}
option.filter(p)
option.find(p)
Option[A] option match {
  case Some(x) if !p(x) =>
    Some(x)
  case None => None
}
option.filterNot(p)
Boolean option match {
  case Some(x) => p(x)
  case None => true
}
option.forall(p)
Boolean option match {
  case Some(x) => p(x)
  case None => false
}
option.exists(p)
Boolean option match {
  case Some(a) => false
  case None => true
}
option.isEmpty
Boolean option match {
  case Some(x) => true
  case None => false
}
option.isDefined
option.nonEmpty
Boolean option match {
  case Some(x) => x == 1
  case None => false
}
option.contains(1)

(the example uses `x == 1`
because i use Option[Int])
Int option match {
  case Some(x) => 1
  case None => 0
}
option.size
Int option match {
  case Some(x) if p(x) => 1
  case _ => 0
}
option.count(p)
Seq, List, etc. option match {
  case Some(x) => Seq(x)
  case None => Nil
}
option.toSeq
option.toList

(also toVector, toArray,
toSet, etc.)
Either[Int,Int]
  = Right
option match {
  case Some(x) => Right(x)
  case None => Left(default)
}
option.toRight(default)
Either[Int,Int]
  = Left
option match {
  case Some(x) => Left(x)
  case None => Right(default)
}
option.toLeft(default)
A or null stringOption match {
  case Some(x) => x
  case None => null
}
stringOption.orNull

(only use this for Java APIs that
need it)
Back to top

Notes

A few notes:

  • Note that in the fold example its use is fairly consistent with sequences, where a fold takes an initial seed value and a folding function (see my Scala fold and reduce tutorial for more details on those functions)
  • I put the null example in the last row because you should never use that, unless you’re interacting with a Java API that needs it
  • In the future I’ll include a companion article that explains and organizes these examples in a different way
Back to top

Resources

I initially started writing this article based on my own experience, and then was further propelled to investigate it after I saw this tweet by Jon Pretty about using fold instead of match. That led me to this Tony Morris article about HOFs and Option, and most recently I found this video by Marconi Lanna, which helped to round out the last few examples in the table.

Back to top

Comments

If you know of more (or better) examples I should show, feel free to leave a comment in the Comments section below.

Back to top

Add new comment

Anonymous format

  • Allowed HTML tags: <em> <strong> <cite> <code> <ul type> <ol start type> <li> <pre>
  • Lines and paragraphs break automatically.