How to normalise a Union Type (T | Option[T])?

user_2750966 0
Viewed 132

I have the following case class:

case class Example[T](
    obj: Option[T] | T = None,
)

This allows me to construct it like Example(myObject) instead of Example(Some(myObject)).

To work with obj I need to normalise it to Option[T]:

  lazy val maybeIn = obj match
    case o: Option[T] => o
    case o: T => Some(o)

the type test for Option[T] cannot be checked at runtime

I tried with TypeTest but I got also warnings - or the solutions I found look really complicated - see https://stackoverflow.com/a/69608091/2750966

Is there a better way to achieve this pattern in Scala 3?

scala-3 scala
3 Answers

I don't know about Scala3. But you could simply do this:

case class Example[T](v: Option[T] = None)

object Example {
 def apply[T](t: T): Example[T] = Example(Some(t))
}

One could also go for implicit conversion, regarding the specific use case of the OP:

import scala.language.implicitConversions

case class Optable[Out](value: Option[Out])

object Optable {
  implicit def fromOpt[T](o: Option[T]): Optable[T] = Optable(o)
  implicit def fromValue[T](v: T): Optable[T] = Optable(Some(v))
}

case class SomeOpts(i: Option[Int], s: Option[String])

object SomeOpts {
  def apply(i: Optable[Int], s: Optable[String]): SomeOpts = SomeOpts(i.value, s.value)
}

println(SomeOpts(15, Some("foo")))
user_1089150

We have a specialized Option-like type for this purpose: OptArg (in Scala 2 but should be easily portable to 3)

import com.avsystem.commons._

def gimmeLotsOfParams(
  intParam: OptArg[Int] = OptArg.Empty,
  strParam: OptArg[String] = OptArg.Empty
): Unit = ???

gimmeLotsOfParams(42)
gimmeLotsOfParams(strParam = "foo")

It relies on an implicit conversion so you have to be a little careful with it, i.e. don't use it as a drop-in replacement for Option.

The implementation of OptArg is simple enough that if you don't want external dependencies then you can probably just copy it into your project or some kind of "commons" library.

user_9313230

EDIT: the following answer is incorrect. As of Scala 3.1, flow analysis is only able to check for nullability. More information is available on the Scala book.

I think that the already given answer is probably better suited for the use case you proposed (exposing an API can can take a simple value and normalize it to an Option).

However, the question in the title is still interesting and I think it makes sense to address it.

What you are observing is a consequence of type parameters being erased at runtime, i.e. they only exist during compilation, while matching happens at runtime, once those have been erased.

However, the Scala compiler is able to perform flow analysis for union types. Intuitively I'd say there's probably a way to make it work in pattern matching (as you did), but you can make it work for sure using an if and isInstanceOf (not as clean, I agree):

case class Example[T](
    obj: Option[T] | T = None
) {
  lazy val maybeIn =
    if (obj.isInstanceOf[Option[_]]) {
      obj
    } else {
      Some(obj)
    }
}

You can play around with this code here on Scastie.

Here is the announcement from 2019 when flow analysis was added to the compiler.

user_33141070
Related