Provide mapIfInstance?

[nikclayton]

Here's an extension function that might be useful to include.

/**
 * Maps this [Result<V, E>][Result] to [Result<V, E>][Result] by either applying the [transform]
 * function to the [value][Ok.value] if this [Result] is [Ok&lt;T>][Ok], or returning the result
 * unchanged.
 */
public inline infix fun <V, E, reified T : V> Result<V, E>.mapIfInstance(transform: (T) -> V): Result<V, E> {
    contract {
        callsInPlace(transform, InvocationKind.AT_MOST_ONCE)
    }

    return when (this) {
        is Ok -> (value as? T)?.let { Ok(transform(it)) } ?: this
        is Err -> this
    }
}

(that's using the 1.2x library version)

The motivating example is if you have a flow of Result where the OK value is one of a sealed set of subclasses and you typically only want to transform one of them. For example, Data.Loaded in this snippet:

sealed interface Data {
    data object Loading : Data
    data class Loaded(val data: String) : Data
}

sealed interface AppError {
    data class NetworkError(...)
    data class JsonError(...)
    // etc
}

Suppose you're processing a flow of Result<Data, AppError>

At the moment, with map, you have to write something like:

theFlow.map {
    when (it) {
        is Data.Loading -> it
        is Data.Loaded -> { /* some transform here */ }
    }
}

[Filtering the flow to just Ok(Data.Loaded) is not necessarily appropriate, as code "downstream" of the flow might still need to distinguish between these cases]

This rapidly gets tedious if you have to do this on every Flow<Result<V, E>>.

With this extension this becomes:

theFlow.mapIfInstance<_, _, Data.Loaded> { /* some transform here */ }

or

theFlow.mapIfInstance { it: Data.Loaded -> /* do something */ }