Scala Language Type Inference Preventing inferring Nothing


Based on this blog post.

Assume you have a method like this:

  def get[T]: Option[T] = ???

When you try to call it without specifying the generic parameter, Nothing gets inferred, which is not very useful for an actual implementation (and its result is not useful). With the following solution the NotNothing context bound can prevent using the method without specifying the expected type (in this example RuntimeClass is also excluded as for ClassTags not Nothing, but RuntimeClass is inferred):

@implicitNotFound("Nothing was inferred")
sealed trait NotNothing[-T]

object NotNothing {
  implicit object notNothing extends NotNothing[Any]
  //We do not want Nothing to be inferred, so make an ambigous implicit
  implicit object `\n The error is because the type parameter was resolved to Nothing` extends NotNothing[Nothing]
  //For classtags, RuntimeClass can also be inferred, so making that ambigous too
  implicit object `\n The error is because the type parameter was resolved to RuntimeClass` extends NotNothing[RuntimeClass]

object ObjectStore {
  //Using context bounds
  def get[T: NotNothing]: Option[T] = {
  def newArray[T](length: Int = 10)(implicit ct: ClassTag[T], evNotNothing: NotNothing[T]): Option[Array[T]] = ???

Example usage:

object X {
  //Fails to compile
  //val nothingInferred = ObjectStore.get
  val anOption = ObjectStore.get[String]
  val optionalArray = ObjectStore.newArray[AnyRef]()
  //Fails to compile
  //val runtimeClassInferred = ObjectStore.newArray()