Java Kotlin-无法推断泛型类型

我在Kotlin使用Akka的

ask

模式，遇到了一个关于协方差的问题。情况如下：

interface Token {
  // arbitrary stuff
}

class SpecificToken(override val underlying: TokenFound) : Token, ArbitraryInterface<TokenFound> {
  // arbitrary stuff
}

interface TokenRepository {
  fun find(): CompletionStage<Token?>
}

class SpecificTokenRepository : TokenRepository {

  val actor1 = getActor1()
  val actor2 = getActor2()
  val message1 = getMessage1()
  val message2 = getMessage2()
  val timeout = getTimeout()

  fun find(): CompletionStage<Token?> = 
    inquire().thenCompose {
      when (it) {
        is Inquiry -> Patterns.ask(actor, message, timeout)
          .handle { response, t -> 
            handleExceptions(t)
            if (response is TokenFound) SpecificToken(response) else null
          }
        else -> CompletableFuture.completedFuture(null)
      }

   fun inquire(): CompletionStage<Inquiry?> = 
     Patterns.ask(actor, message, timeout)
       .handle { response, t ->
         handleExceptions(t)
         if (response is Inquiry) response else null
       }
}

这里需要改变什么，如果可能的话，你能解释一下原因吗？谢谢

显然（显然），

null

值需要转换为

Token？

类型，因此将函数更改为

fun find(): CompletionStage<Token?> = 
  inquire().thenCompose {
    when (it) {
      is Inquiry -> Patterns.ask(actor, message, timeout)
        .handle { response, t -> 
          handleExceptions(t)
          if (response is TokenFound) SpecificToken(response) else null as Token?
        }
      else -> CompletableFuture.completedFuture<Token?>(null)
    }

fun find（）：CompletionStage=
查询（），然后编写{
什么时候{
是查询->模式。询问（参与者、消息、超时）
.handle{响应，t->
handleExceptions（t）
如果（response is TokenFound）SpecificToken（response）else作为令牌为空？
}
else->CompletableFuture.completedFuture（空）
}

---

解决了问题。

虽然您已经找到了解决方案，但我认为值得解释一下为什么需要它

if（response is TokenFound）SpecificToken（response）else null

是

SpecificToken？

，因此

模式.ask（actor，message，timeout）.handle{…}

分支的类型为

CompletableFuture

null

本身被推断为具有类型

Nothing？

，因此

CompletableFuture.completedFuture（null）

是

CompletableFuture

---

由于您的两个分支以不同的类型结束，因此整个

when（it）{…}

表达式都有其共同的超类型，即

CompletableFuture

您使用旧类型推断还是新类型推断？

fun find(): CompletionStage<Token?> = 
  inquire().thenCompose {
    when (it) {
      is Inquiry -> Patterns.ask(actor, message, timeout)
        .handle { response, t -> 
          handleExceptions(t)
          if (response is TokenFound) SpecificToken(response) else null as Token?
        }
      else -> CompletableFuture.completedFuture<Token?>(null)
    }