How to use Option[T] to handle null value well in scala? - scala

Question

Java code:
public static Connection connection = null;
public static void main(String[] args) {
if(connection == null){
connection = ConnectionFactory.createConnection(conf);
}
//using connection object to do something
}
converting to Scala code:
someone tell me use Option[T] to handle null value, but I don't how to use Option[T] well, I think it very troublesome.
Scala code:
var connOpt: Option[Connection] = None
def main(args: Array[String]) {
//check `connOpt` Option
connOpt match {
case Some(connection) => { /* using `connection` to do something-----code1 */ }
case _ => {
val connection = ConnectionFactory.createConnection()
connOpt = Option(connection)
// using `connection` to do something------code2
}
}
}
you can see scala code.
I need check connOpt always when I need use connOpt.
code1 and code2 is the same code, I need write two times, I know I can use function to package code1 or code2, but it's very troublesome.
How to handle this case?

Answer 1

I think you can use the 'fold' method to do what you want like this
var connOpt:Option[Connection] = None
def main(args: Array[String]) {
val connection = connOpt.fold(ConnectionFactory.createConnection()){conn => conn}
//using connection object to do something
}
The logic of code mentioned above is the same as your java code that does not write the 'code1' and 'code2' two times.
Using the following example to explain the usage of 'fold'
obj.fold{/*the obj is null, you can return the value you want*/}{a => a
/*if the obj is Some(value), the 'a' is just the 'value'*/
}
Good luck with you

Answer 2

It depends on your business logic; not so much on the programming language.
Does it make sense to keep your component alive if the connection attempt is unsuccessful?
You might want to "fail early": if you can't connect, either throw an Exception or stop your component. In this case, using Option is an unnecessary abstraction.
If your component should survive if it fails to connect, you could do this:
val maybeConn: Option[Connection] = Option(ConnectionFactory.createConnection(conf))
maybeConn foreach doConnRelatedOperation
doOtherOperationThatDoesNotRequireConn
def doConnRelatedOperation(conn: Connection) = println(conn)
def doOtherOperationThatDoesNotRequireConn = "hello!"
In this code example:
Option(ConnectionFactory.createConnection(conf)) will return either Some(conn) or None (I'm assuming createConnection doesn't throw; if it could then maybe you want to use the Try functor instead)
maybeConn foreach doConnRelatedOperation will either do nothing if maybeConn is None or invoke the side-effecting function doConnRelatedOperation that takes a Connection as an argument if maybeConn is Some(conn).
Note that, in this example, doOtherOperationThatDoesNotRequireConn will execute even if there is no connection.
Finally
Let's say your createConnection function might throw an Exception. In that case, Option is the wrong abstraction. In that case, you may want to do lazy val maybeConn: Try[Connection] = Try(ConnectionFactory.createConnection(conf)) instead (basically Try instead of Option).
Note the beautifulness in that the rest of the code doesn't need to be modified! The doConnRelatedOperation function will only be executed if the connection was created, and the doOtherOperationThatDoesNotRequireConn will be executed after, irrespective of having the connection or not. The exception will not affect your code flow!
Welcome to Scala's Good Parts :)

Answer 3

Using Option instead of null is only one of the things "they say" about scala. Your problem is that you chose to use that one (fairly random) piece of advice, and ignore all the others.
The other piece of advice, more relevant in this case is: avoid using state and mutable vars. You can safely throw out both "code 1" and "code 2", and just do this:
lazy val = ConnectionFactory.createConnection(conf)

Answer 4

val connOpt: Option[Connection] = None
def main(args: Array[String]) {
//check `connOpt` Option
connOpt.orElse(Some(ConnectionFactory.createConnection()).map {
connection =>
// code 1
}
}