Kotlin - 推断两个通用参数之一的类型

Question

我正在尝试创建一个具有两种泛型类型的 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
    }

这个想法是调用 function 只是提到具体类型，例如：

a.bypassLeft<NoResultException> { "" }

其中“a”是类型为 Either<Throwable,String> 的 object

但是编译器不让我 go 离开它，并要求我指定两种泛型类型，而不是从调用 function 的 object 派生第二种类型。 这似乎是一件很合理的事情，但也许我错了......

这有可能实现吗？ 如果是这样，我做错了什么？

Answer 1

目前不可能使用 function 来赋予单个类型参数并保留另一个类型参数。 如果您键入 lambda arguments 通过将您的实现更改为不使用接收器类型，您可以实现您想要的。

我在那里添加了一个额外的 impl，它显示了类型 args 如何也可以部分应用于 class 或其他周围的 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)

}

Answer 2

从Kotlin v1.7.0 开始，可以使用下划线运算符。

下划线运算符 _ 可用于 arguments 类型。 当显式指定其他类型时，使用它自动推断参数的类型：

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

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

在您的示例中，可能是这样的：

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