Extracting a value from an option inside an option in Scala - scala

Question

Given the following:
val x = Some(Some(1))
What would be the cleanest way to get the 1 (or -1 if the one did not exist)?
I'm creating an object instance from a tuple returned from a database query. One of the values in the tuple looks like this, so I would like a nice short 'one liner' to just get the value or set a parameter to -1.

Answer 1

x.flatten is what you are looking for. Here it will give you Some(1).
If you really want to get -1 for the case where "the one did not exist", just do x.flatten.getOrElse(-1):
scala> Some(Some(1)).flatten.getOrElse(-1)
res1: Int = 1
scala> Some(None).flatten.getOrElse(-1)
res2: Int = -1
scala> None.flatten.getOrElse(-1)
res3: Int = -1

Answer 2

for-comprehensions are often a very readable way to use these kinds of nested structures:
val x = Some(Some(1))
val result = for {
firstLevel <- x
secondLevel <- firstLevel
} yield {
// We've got an int, now transform it!
(secondLevel * 100).toString
}
The result is an Option[String], and the transformation only happens when you have two Some(s).
You can also use pattern matching:
val result2 = for {
Some(v) <- x
} yield {
// We've got a int, now transform it!
(v * 100).toString
}

Answer 3

Although not a "one-liner" you could make a function to extract the value. If you make it generic and pass in the default value it might be pretty handy.
scala> def fetchFromOptions[A](default: A)(x: Option[Option[A]]) = x match {
| case Some(Some(a)) => a
| case _ => default
| }
fetchFromOptions: [A](default: A)(x: Option[Option[A]])A
scala> fetchFromOptions(-1)(Some(Some(1)))
res0: Int = 1
scala> fetchFromOptions(-1)(Some(None))
res1: Int = -1

Answer 4

This is what I've come up with:
scala> val x = Some(Some(1))
x: Some[Some[Int]] = Some(Some(1))
scala> val y = x.map(_.getOrElse(-1)).get
y: Int = 1
scala> val x = Some(None)
x: Some[None.type] = Some(None)
scala> val y = x.map(_.getOrElse(-1)).get
y: Int = -1
This only works when your first-level Some is not None

Answer 5

If you actually know that its Some(Some(1)), then you can use the irrefutable pattern match notation:
scala> val ssi1 = Some(Some(1))
ssi1: Some[Some[Int]] = Some(Some(1))
scala> val Some(Some(i1)) = ssi1
i1: Int = 1
If there may be any of the possible None in the mix, then you have to use the more cautious and verbose forms suggested by others.
For those that find this a bizarre notation, think of it as what you'd write in a case in a match construct or PartialFunction literal to match against a scrutinee that is Some(Some(1)).