can`t bind[SttpBackend[Try, Nothing]]

Question

I want to use sttp library with guice(with scalaguice wrapper) in my app. But seems it is not so easy to correctly bind things like SttpBackend[Try, Nothing]

SttpBackend.scala

Try[_] and Try[AnyRef] show some other errors, but still have no idea how it should be done correctly

the error I got:

kinds of the type arguments (scala.util.Try) do not conform to the expected kinds of the type parameters (type T).
[error] scala.util.Try's type parameters do not match type T's expected parameters:
[error] class Try has one type parameter, but type T has none
[error]         bind[SttpBackend[Try, Nothing]].toProvider[SttpBackendProvider]
[error]    `         ^

SttpBackendProvider looks like:

def get: SttpBackend[Try, Nothing] = TryHttpURLConnectionBackend(opts)

complete example in scastie interesting that version scalaguice 4.1.0 show this error, but latest 4.2.2 shows error inside it with converting Nothing to JavaType

Answer 1

I believe you hit two different bugs in the Scala-Guice one of which is not fixed yet (and probably even not submitted yet).

To describe those issues I need a fast intro into how Guice and Scala-Guice work. Essentially what Guice do is have a mapping from type onto the factory method for an object of that type. To support some advanced features types are mapped onto some internal "keys" representation and then for each "key" Guice builds a way to construct a corresponding object. Also it is important that generics in Java are implemented using type erasure. That's why when you write something like:

bind(classOf[SttpBackend[Try, Nothing]]).toProvider(classOf[SttpBackendProvider])

in raw-Guice, the "key" actually becomes something like "com.softwaremill.sttp.SttpBackend". Luckily Guice developers have thought about this issue with generics and introduced TypeLiteral[T] so you can convey the information about generics.

Scala type system is more reach than in Java and it has some better reflection support from the compiler. Scala-Guice exploits it to map Scala-types on those more detailed keys automatically. Unfortunately it doesn't always work perfectly.

The first issue is the result of the facts that the type SttpBackend is defined as

trait SttpBackend[R[_], -S]

so it uses it expects its first parameter to be a type constructor; and that originally Scala-Guice used the scala.reflect.Manifest infrastructure. AFAIU such higher-kind types are not representable as Manifest and this is what the error in your question really says.

Luckily Scala has added a new scala.reflect.runtime.universe.TypeTag infrastructure to tackle this issue in a better and more consistent way and the Scala-Guice migrated to its usage. That's why with the newer version of Scala-Guice the compiler error goes away. Unfortunately there is another bug in the Scala-Guice that makes the code fail in runtime and it is a lack of handling of the Nothing Scala type. You see, the Nothing type is a kind of fake one on the JVM. It is one of the things where the Scala type system is more reach than the Java one. There is no direct mapping for Nothing in the JVM world. Luckily there is no way to create any value of the type Nothing. Unfortunately you still can create a classOf[Nothing]. The Scala-to-JVM compiler handles it by using an artificial scala.runtime.Nothing$. It is not a part of the public API, it is implementation details of specifically Scala over JVM. Anyway this means that the Nothing type needs additional handling when converting into the Guice TypeLiteral and there is none. There is for Any the cousin of Nothing but not for Nothing (see the usage of the anyType in TypeConversions.scala).

So there are really two workarounds:

1. Use raw Java-based syntax for Guice instead of the nice Scala-Guice one:

bind(new TypeLiteral[SttpBackend[Try, Nothing]]() {})
    .toInstance(sttpBackend) // or to whatever

See online demo based on your example.

2. Patch the TypeConversions.scala in the Scala-Guice as in:

private[scalaguice] object TypeConversions {
  private val mirror = runtimeMirror(getClass.getClassLoader)
  private val anyType = typeOf[Any]
  private val nothingType = typeOf[Nothing] // added

  ...

  def scalaTypeToJavaType(scalaType: ScalaType): JavaType = {
    scalaType.dealias match {
      case `anyType` => classOf[java.lang.Object]
      case `nothingType` => classOf[scala.runtime.Nothing$] //added
      ...

I tried it locally and it seems to fix your example. I didn't do any extensive tests so it might have broken something else.