Kotlin - Infer type for one of two generic parameters

Question

I am trying to create a function that has two generic types: one reified, and another derived from the context of its usage (since it is an extension function):

inline fun <reified E, A> Either<Throwable, A>.bypassLeft(transformation: Throwable.() -> A): Either<Throwable, A> =
    when (this) {
        is Either.Left -> when (value) {
            is E -> value.transformation().right()
            else -> this
        }
        else -> this
    }

The idea would be to call the function just mentioning the reified type, something like:

a.bypassLeft<NoResultException> { "" }

In which "a" is an object of type Either<Throwable,String>

But the compiler is not letting me go away with it, and requires me to specify both generic types, instead of deriving the second one form the object calling the function. It seemed quite a reasonable thing to be possible, but maybe I am wrong...

Is this possible to achieve? If so, what am I doing wrong?

Unfortunately, as far as I know, this is currently not possible. I wait for a language improvement in that matter, because this problem annoys me from time to time. I would be happy if someone told me I'm actually wrong. — broot, Dec 14 '21 at 18:18

score 8 · Accepted Answer · answered Aug 30 '22 at 15:24

This is possible as of Kotlin v1.7.0 with the underscore operator.

The underscore operator _ can be used for type arguments. Use it to automatically infer a type of the argument when other types are explicitly specified:

interface Foo<T>
fun <T, F : Foo<T>> bar() {}

fun baz() {
    bar<_, Foo<String>>() // T = String is inferred
}

In your example, it would be possible like this:

a.bypassLeft<NoResultException, _> { "" }

score 4 · Answer 2 · answered Dec 14 '21 at 19:30

It's not currently possible with a function to ascribe a single type argument and leave the other inferred. You can achieve what you want if you type the lambda arguments by changing your implementation to not use a receiver type.

I threw in there an additional impl that shows how type args can also be partially applied with a class or other surrounding scope.

import arrow.core.Either
import arrow.core.right

inline fun <reified E : Throwable, A> Either<Throwable, A>.bypassLeft(
  transformation: (E) -> A //changed to regular arg not receiver
): Either<Throwable, A> =
  when (this) {
    is Either.Left -> when (val v = value) { //name locally for smart cast
      is E -> transformation(v).right()
      else -> this
    }
    else -> this
  }

class Catch<A>(val f: () -> A) { //alternative impl with partial type app
  inline fun <reified E : Throwable> recover(
    recover: (E) -> A
  ): Either<Throwable, A> =
    Either.catch(f).fold(
      {
        if (it is E) Either.Right(recover(it))
        else Either.Left(it)
      },
      {
        Either.Right(it)
      }
    )
}

suspend fun main() {

  val x: Either<Throwable, Int> = Either.Left(StackOverflowError())
  val recovered = x.bypassLeft { 
     s: StackOverflowError -> //here infers E
     0 // here infers A
  }

  println(recovered) // Either.Right(0)

  val notRecovered: Either<Throwable, Int> =
    Catch {
      throw NumberFormatException()
      1
    }.recover<StackOverflowError> { 0 }

  println(notRecovered) // Either.Left(java.lang.NumberFormatException)

}

Kotlin - Infer type for one of two generic parameters

2 Answers2