Scala and Java Options do if present if not do something else construct

Question

Options in scala and java are something that I am struggling to understand and work with. I understand its there in order to eliminate 'null' handling hell. Frankly, I think its introducing another kind of hell!

The way I deal with nulls in java is to do something like:

String test = null;
if(test==null) // do something
else  // do something else

This sort of decision is what I am seeking to do when I switch to Options.

But there is no method in the Option class in both scala and java to say, if null do something, else do something else.

There is a way to default the value in case of subject being null, such as

//in scala
test.getOrElse("defaulted")

I was wondering why there cant be methods such as the implicit class I have written to 'pimp up' a Scala option

object Definitions{
  implicit class OptionExtensions[$Data](option: Option[$Data]){
    def perform (found: ($Data)=>Any, notFound: ()=>Any): Any={
      option match{
        case Some(data)=> found(data)
        case None=> notFound()
      }
    }
  }
}

Please ignore the badly named method. But with this now written, I could supposedly use an option like this:

import Definitions._

val test : Option[String] = None

var builder =new StringBuilder


test.perform(builder ++= _, ()=>addError("not found"))
//or
println(test.perform(_.reverse, ()=>{"something else"}))

def addError(error:String)={
  println(error)
}

Instead I am forced to write match and case for handling anything to do with Options. I must be doing something wrong. Most likely, my understanding of how to use Options is flawed. The above way of handling is not in the Option class by default because of a reason. Now what could that reason be?

Answer 1

In scala there are several ways to achieve that:

• optValue.map(successFunction).getOrElse(errorFunction)
• optValue.fold(errorFunction)(successFunction)

probably what you want is the second, fold.

In java there's a .map, not sure if there's a .fold, you need to have a look at the docs

EDIT: As you asked to have newlines in fold, try with brackets:

Some(2).fold
  {
    println("error")
  }
  {
    value =>
      println(s"Success: $value")
  }

Answer 2

I think what you're missing is the reason why you need Options.

The idea behind Options (and Optionals in Java), is that you (the developer) can now state that a value may or may not be present, on the type level.

Take a second to think about that. How would you do that with a variable that could just be null?

...

It's a problem, right?

• you don't know if it would ever be null when you get to read the value
• you must always check if it is null with such a variable, if you want your code to be safe.

But, now, with Options / Optionals, you and some other developers who work with your code are now told by the compiler that they must check the possibility that this variable will be null (or not!).

If we now take this a step further, imagine if you write all your code in a way that any variable that might be null is an Option. Any variable that will never be null (will always have a value), is not! You get my point now, right?

If you write all your code like this, you will end up never accidentally relying on the presence of value that are not there, nor making unnecessary checks about whether the value was there, when it always is! ; )