How should I throw an exception if Some(null) is called? - scala

Question

I've done Some(Option(null).get) but it looks a little strange.
Updated with sample. I can't compile check that the text is not null.
object Code {
def main(args: Array[String]): Unit = {
println(computeSomething("good"))
println(computeSomething(null))
def computeSomething(text: String): Option[String] =
Some(Option(text).get).map("not null text was [" + _ + "]")
}
}
//System.out:
//
//Some(not null text was [good])
//Exception in thread "main" java.util.NoSuchElementException: None.get
// at scala.None$.get(Option.scala:347)
// at scala.None$.get(Option.scala:345)
// at Code$.computeSomething$1(ZipInputLocation.scala:13)
// at Code$.main(ZipInputLocation.scala:11)
// at Code.main(ZipInputLocation.scala)
Updated with a second sample.
object Code {
def main(args: Array[String]): Unit = {
println(computeSomething("good"))
println(computeSomething(null))
def computeSomething(text: String): String = {
require text != null
//or
//if(text == null)
// throw new RuntimeException("You broke the contract")
"not null text was [" + text + "]"
}
}
}
//System.out:
//
//not null text was [good]
//Exception in thread "main" RuntimeException:
// at Code$.computeSomething$1(ZipInputLocation.scala:13)
// at Code$.main(ZipInputLocation.scala:11)
// at Code.main(ZipInputLocation.scala)

Answer 1

Don't use Option.get. Instead, use the Option.apply and map on that, since it will return None for null values:
def computeSomething(text: String): Option[String] =
Option(text).map("not null text was [" + _ + "]")
Even better, if you want to disallow someone to compile code explicitly passing Some(null) at compile time, use a tool like WartMover, which has a specific rule for it that generates a compile time warning.

Answer 2

If I understand you correctly, you want Some(null) to throw an exception, instead of storing null as a value, correct?
Unfortunately, that's not going to happen. The only option you have is to put the creation of the Some instance inside a function and check for null explicitly. For example:
def wrapSome(s: String): Some[String] = {
if(s eq null) throw new NullPointerException("Can't have null string!")
Some(s)
}
Probably not what you wanted to hear, and not particularly useful either...
Alternatively, you could wrap the value in an Option (resulting in None, if the value is null), instead of in Some (which results in Some(null) if the value is null), and then call .get: None.get throws a NoSuchElementException. Indeed, this is exactly what you're doing in your example. (Is there a reason why you want to wrap the value explicitly with Some when that will happen automatically to non-null values wrapped in Option?)
One of the primary objectives of Option is to protect against null values. Clearly, it would depend upon what you're trying to achieve, but functional programing discourages both null values and throwing of exceptions. If you're coming from Java, this can seem very strange, at first.
A more functional approach would be something like this:
// Return None if s is null; otherwise, Some(s). Both are Option[String] values.
def computeSomething(s: String): Option[String] = Option(s)
// Use this function to create an optional string.
val os = computeSomething(x) // x is some string. Could be null.
// Provide a default value if wrapped value is null (i.e. if os is None).
val a = os.getOrElse("some default value") // a is a string, never null.
// Do something with the value if it's not null; do nothing otherwise.
os.foreach(doSomething) // Calls doSomething(x), but only if x wasn't null/os isn't None.
// Process the string to something else. If os is None, result is None too.
val len = os.map(_.length) // Returns an Option[Int], None or Some(length of x)
// etc.
There's a whole host of idioms for using Option values like this, none of which involve throwing exceptions. If you could tell us more about what you're trying to do, I'll show you the Scala/functional way of doing it.
In the meantime, here's a reworked version of your program using this idiom with the fold method:
object Code
extends App { // No need for main function! ;-)
println(computeSomething("good"))
println(computeSomething(null))
def computeSomething(text: String): String =
Option(text).fold("text was null")(t => s"not null text was [$t]")
}
// System.out:
// not null text was [good]
// text was null