Why type inference failed in Scala when using implicit conversion on return value of Option.getOrElse?

Question

For example I have a class Value and a implicit function convert string to Value:

case class Value(v: String)

implicit def strToValue(s: String): Value = Value(s)

And here is a trait which has a method returns Value:

trait ReturnValue {
  def f: Value
}

Because the implicit conversion exists, I can implement method f by just return a String literal:

object Obj1 extends ReturnValue {
  override def f: Value = "123"
}

And of course return a variable of type String just works fine:

object Obj2 extends ReturnValue {
  override def f: Value = {
    val v = Some("123").getOrElse("234")
    v
  }
}

But when I trying to use the result of Option.getOrElse directly as the return value:

object Obj3 extends ReturnValue {
  override def f: Value = Some("123").getOrElse("234")  // Compilation error: type mismatch
}

A compilation error occurred:

Error:(23, 50) type mismatch;
 found   : java.io.Serializable
 required: Entry.Value
   override def f: Value = Some("123").getOrElse("234") // Compilation error: type mismatch

It seems that type inference here is failed. Type String is not inferred, and then the implicit conversion cannot be matched. (Full file is here)

I have tried other functions which have type parameter, such as "map", they all works perfectly.

Why is the Option.getOrElse so special that type inference failed here?

Interesting. These variants do work: override def f: Value = Some("123": Value).getOrElse("234") and override def f: Value = None.getOrElse("234") and even override def f: Value = Some("123").get . — Suma
I don't know the answer, but I usually solve this problem by type-casting the method def f: Value = Some("123").getOrElse[String]("234"), to ensure that the conversion is done at the last possible moment. I believe the issue is related to the fact that getOrElse as a call-by-name argument, which must interact wierdly with the type inference and the implicit conversion resolution. — Cyrille Corpet

Suma Suma · Accepted Answer · 2017-03-24T07:54:52

This variants leads to the same compile error, and probably shows how compiler deconstructs the expression:

object Obj3 extends ReturnValue {
  override def f: Value = {
    val v = Some("123") // is of type Some(String)
    v.getOrElse("234": Value)  // Compilation error: type mismatch
  }
}

Same error can also be achieved without any traits, with following simple repro:

case class Value(v: String)

implicit def strToValue(s: String): Value = Value(s)

val vs  = Some("123")

val v: Value = vs.getOrElse("234")

It seems the compiler applies the conversion to Value on the argument of getOrElse, instead of on its result. The fact is does can be confirmed with output with enabled scalacOptions in Compile ++= Seq("-Xprint-types", "-Xprint:typer") (cleaned a bit - deleted obviously unrelated annotations):

private[this] val v: Value =

vs.getOrElse{[B >: String](default: => B)B}[java.io.Serializable]{(default: => java.io.Serializable)java.io.Serializable}( strToValue{(s: String)Value}("234"{String("234")}){Value} ){

I think the inference works as follows:

vs type is known as Some[String]
getOrElse declaration is def getOrElse[B >: A](default: => B): B (A is String here)
compilers infers the B as Value, as this is the expected result type of the expression.
the most specific supertype of Value and String is Serializable

You can also note how it behaves when you remove the implicit conversion completely. The error for val v: Value = vs.getOrElse("234") is then: type mismatch; found : String("234") required: Value

Why type inference failed in Scala when using implicit conversion on return value of Option.getOrElse?

2 Answers