Could/should an implicit conversion from T to Option[T] be added/created in Scala?

Question

Is this an opportunity to make things a bit more efficient (for the prorammer): I find it gets a bit tiresome having to wrap things in Some, e.g. Some(5). What about something like this:

implicit def T2OptionT( x : T) : Option[T] = if ( x == null ) None else Some(x) 

Answer 1

You would lose some type safety and possibly cause confusion. For example:

  val iThinkThisIsAList = 2    for (i <- iThinkThisIsAList) yield { i + 1 } 

I (for whatever reason) thought I had a list, and it didn't get caught by the compiler when I iterated over it because it was auto-converted to an Option[Int].

I should add that I think this is a great implicit to have explicitly imported, just probably not a global default.

Answer 2

Note that you could use the explicit implicit pattern which would avoid confusion and keep code terse at the same time.

What I mean by explicit implicit is rather than have a direct conversion from T to Option[T] you could have a conversion to a wrapper object which provides the means to do the conversion from T to Option[T].

class Optionable[T <: AnyRef](value: T) {   def toOption: Option[T] = if ( value == null ) None else Some(value) }  implicit def anyRefToOptionable[T <: AnyRef](value: T) = new Optionable(value) 

... I might find a better name for it than Optionable, but now you can write code like:

val x: String = "foo" x.toOption // Some("foo")  val y: String = null x.toOption // None 

I believe that this way is fully transparent and aids in the understanding of the written code - eliminating all checks for null in a nice way.

Note the T <: AnyRef - you should only do this implicit conversion for types that allow null values, which by definition are reference types.