Mix Scala Option and regular variable in a statement - scala

Question

I would like to write conditional statements mixing transparently Scala Options and regular variables.
For example:
var o1 = Some(1)
var o2: Option[Int] = None
var x = 2
val test1 = x < 3 && o1<5 //=> should be true or Some(true)
val test2 = x < 3 && o2<5 //=> should be false or None
val test3 = x < 3 || o2<5 //=> should be true (o2 not evaluated)
of course I could write
test1 = x < 3 && o1.exists (_<5)
but I would prefer a cleaner syntax.
Any hint? Should I expand 'Option' with operators, or use implicits, or category theory or else?

Answer 1

What about mapping from Option[Int] to Option[Boolean]?
x < 3 && (o1 map {_ < 5} getOrElse false)
x < 3 && (o2 map {_ < 5} getOrElse false)
x < 3 || (o2 map {_ < 5} getOrElse false)

Answer 2

Using implicits is certainly easy:
implicit def enrichOptionInt(self: Option[Int]) = new {
def <(i: Int) = self.exists(_ < i)
}
val test1 = x < 3 && o1 < 5 // True
Or if you want it to work for any kind of Numeric:
class EnrichedOptionNumeric[N: Numeric](self: Option[N]) {
def <(n: N) = self.exists(v => implicitly[Numeric[N]].lt(v, n))
}
implicit def enrichOptionNumeric[N: Numeric](self: Option[N]) = new EnrichedOptionNumeric(self)
val oD = Some(2.0)
val test1 = x < 3 && o1 < 5 // true
val testD = x < 3 && oD < 5.0 // true
EDIT to answer question in comment:
If you want to support equality, you, unfortunately, cannot use == since that operator is already defined for Option. If a method (or operator) is already defined for a class, then the implicit will never be triggered since Scala only looks for implicits when it doesn't recognize the method being called.
You can however, simply define a different symbol to mean "option equals". For example, you could use ===. To do so, you'd just add the following line to the definition of EnrichedOptionNumeric above:
def ===(n: N) = self.exists(v => implicitly[Numeric[N]].equiv(v, n))
Then you can do:
val testE = x < 3 && o1 === 1 // true

Answer 3

Think about whether there's a more natural way to express the "missing" value in the context of this problem than using an Option. Maybe to say there's no limit, a Double with a value of Infinity would work, or an Int with Integer.MAX_VALUE. Then remove the Option from the problem completely. If you can't then you can use
var o1 = Some (1)
var o2 = Option[Int] = None
var x = 2
val test1 = x < 3 && o1.getOrElse(Integer.MAX_VALUE)<5 //=> should be true or Some(true)
val test2 = x < 3 && o2.getOrElse(Integer.MAX_VALUE)<5 //=> should be false or None
val test3 = x < 3 || o2.getOrElse(Integer.MAX_VALUE)<5 //=> should be true (o2 not evaluated)

Answer 4

Tomasz Nurkiewicz's answer can be made more succinct with some Scalaz sugar, and by employing the Monoid instance for Boolean.
The "zero" value for the monoid is false, so o getOrElse false becomes ~o, using a unary operator ~ defined in scalaz. (Here I am using scalaz 6.0.4)
def p: Int => Boolean = _ < 3
def q: Int => Boolean = _ < 5
import scalaz._, Scalaz._
scala> val test1 = p(x) && ~(o1 map q)
test1: Boolean = true
scala> val test2 = p(x) && ~(o2 map q)
test2: Boolean = false
scala> val test3 = p(x) || ~(o2 map q)
test3: Boolean = true

Answer 5

Scala can actually make an Ordering for Option[A] if you have an Ordering[A] but the semantics are different (None is the smallest value) from what you wanted.
Also, for the comparison to work, both values need to be of the same type, so you need a way to lift the Ints into an Option. I added an opt method for that purpose.
This is an example with the internal ordering:
import scala.math.Ordering.Implicits.infixOrderingOps
//This allows you to use method/operator syntax on anything with an Ordering
implicit def mkOption[A](a: A) = new { def opt: Option[A] = Some(a) }
var o1 = Some(1)
var o2: Option[Int] = None
var x = 2
val test1 = x < 3 && o1<5.opt //=> true
val test2 = x < 3 && o2<5.opt //=> true
val test3 = x < 3 || o2<5.opt //=> true
None > 0.opt //=> false
None < 0.opt //=> true
To get closer to your semantics, we can define a new ordering
implicit def mkOptionOrdering[A: Ordering] = new Ordering[Option[A]] {
def compare(a: Option[A], b: Option[A]): Int = {
if (a.isEmpty || b.isEmpty) 0
else implicitly[Ordering[A]].compare(a.get, b.get)
}
}
Now your tests will do what you expected and the 2 extra tests will also be false but those semantics are rather odd, compare returns 0 for things that aren't equal.