如何在不使用异常的情况下为流程提供“接近的原因”？

如何解决如何在不使用异常的情况下为流程提供“接近的原因”？

说我正在生成有限的消息流，例如Flow<Message>。我遍历了某些消息源，当没有更多消息时，请跳出循环以正常完成流程。

val messages = flow {
    while (source.hasNext()) {
        emit(source.next())
    }
    println("Finished sending all the messages")
}

使用者只需调用collect依次接收每个消息，直到流程结束。

messages.collect { doSomethingWith(it) }
println("All the messages have been processed")

但是当我需要告诉呼叫者为什么流量停止时会发生什么？例如，假设消息生产者需要身份验证，而我必须处理令牌到期。现在，有两个原因可能会终止流程，所以我的生产者看起来像这样：

val messages = flow {
    while(source.hasNext()) {
        if (authentication.isExpired) {
            break
        }
        emit(source.next())
    }
    println("Finished sending all the messages")
}

问题是消费者不知道流程为什么结束。消息只是用完了吗，还是需要重新认证并继续提取消息？现在，我可以想到两种可能的处理方式，我都不喜欢。

例外

一个简单的解决方案是用异常信号通知“异常”流终止：

val messages = flow {
    while (source.hasNext()) {
        if (authentication.isExpired) {
            throw AuthenticationExpiredException()
        }
        emit(source.next())
    }
    println("Finished sending all the messages")
}

那太好了，因为现在消费者可以使用try / catch来确定终止流的原因：

try {
    messages.collect { doSomethingWith(it) }
    println("There are no more messages")
} catch (e: AuthenticationExpiredException) {
    println("The auth token expired")
}

但是使用这样的异常绝对不是我想要做的。 Kotlin图书馆的负责人Roman Elizarov在他的Kotlin and Exceptions文章中明确告诉我们：

不要使用异常返回结果值，[并且]避免在常规应用程序代码中使用try / catch。

这是一篇很棒的文章，有很多我同意的原因，但是不想使用异常的一个重要原因是它引入了未经类型检查的行为。如果我使用我的AuthenticationExpiredException，则在不阅读代码的情况下，流的调用者不知道他们必须捕获并处理它。如果没有try / catch，代码将可以正常编译，并且在运行时将失败。在Kotlin中，这是一种故意的语言设计选择：异常不会在编译时检查，因为它们根本不打算以这种方式使用。

密封类

在Kotlin的其他地方返回不同类型结果的一种好方法是使用密封类。所以我可能会这样写：

sealed class FlowResult<out T> {
    data class Value<T>(val value: T): FlowResult<T>
    object: NoMoreMessages: FlowResult<Nothing>()
    object: AuthenticationExpired: FlowResult<Nothing>()
}

val messages = flow {
    while(source.hasNext()) {
        if (authentication.isExpired) {
            emit(AuthenticationExpired)
            break
        }
        emit(Value(source.next()))
    }
    emit(NoMoreMessages)
}

这好得多，因为现在两个可能的关闭原因都得到同等对待。使用者可以使用when块来处理不同的结果，如果他们不包含处理AuthenticationExpired的分支，则会收到编译错误。

这种方法的问题是我无法执行以下规则：“失败”结果必须始终是流程中的最后一项。例如，假设我犯了一个错误，无意中错过了循环中的break。

val messages = flow {
    while(source.hasNext()) {
        if (authentication.isExpired) {
            emit(AuthenticationExpired)
        }
        emit(Value(source.next()))
    }
    emit(NoMoreMessages)
}

现在，我将最终发出AuthenticationExpired值，而没有实际终止流。它只会继续发出消息。这可能会导致各种错误和安全问题，但可以正常编译。

---

感觉上，我真正要寻找的是一种机制，collect可以返回一个值，如下所示：

val closeReason = messages.collect { doSomethingWith(it) }
when (closeReason) {
    ...
}

有没有办法可以实现这样的目标？还是有另一种方法可以解决我描述的问题？

解决方法

没有内置的方法可以实现所需的功能，但是可以在现有API的基础上构建并将其与密封类组合在一起：

// Essentially a functional Either type
sealed class Signal<out V,out T> {
    data class Value<V>(val value: V): Signal<V,Nothing>
    data class Terminal<T>(val value: T): Signal<Nothing,T>
}

然后构建一组扩展方法来执行所需的处理

inline suspend fun <reified V,T> Flow<Signal<V,T>>.collect(
    valueCollector: suspend (V) -> Unit
): T = onEach {
    if (it is Signal.Value) {
        valueCollector(it.value)
    }
}.filterIsInstance<Signal.Terminal<T>>().first().value

此操作使用提供的收集器处理了value个项目，并返回了它视为返回值的第一个Terminal实例的值。