Kotlin - Infer type for one of two generic parameters-CodePudding

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?

CodePudding user response：

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)

}