Why can a Flow emit both Int and String value in Kotlin?-CodePudding

You know that Array and List only store the same data struction.

I run the Code A and get the Result A.

It seems that the Flow can emit both Int value and String value, why?

Code A

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

suspend fun performRequest(request: Int): Int {
    delay(1000) // imitate long-running asynchronous work
    return request
}

fun main() = runBlocking<Unit> {
    (1..3).asFlow() // a flow of requests
        .transform { request ->
            emit("Making request $request")           
            if (request >1) {
                emit(performRequest(request)) 
            }           
          
        }
        .collect { response -> println(response) }
}

Result A

Making request 1
Making request 2
2
Making request 3
3

CodePudding user response：

This is not a question of Flow but Java/Kotling generics and type safety.

The type this flow returns is Comperable<*>

val flow: Flow<Comparable<*>> = (1..3).asFlow() // a flow of requests
    .transform { request ->
        emit("Making request $request")
        if (request > 1) {
            emit(performRequest(request))
        }

If you explicitly specify which value you want to return Flow you can restrict the types.

About generics you can refer here or check any document about generics in java/kotlin, type safety you can refer this question

Also when you are in doubt what your specified type is use alt enter with Android Studio to see avaialble options and select Specify type explicitly.

CodePudding user response：

Disregarding the nature of this request, you can have the functionality you want by making your flow emit instances of some algebraic data type that is basically a "sum" (from the type-theoretic POV) of your constituent types:

sealed interface Record
data class IntData(val get: Int) : Record
data class Metadata(val get: String) : Record

// somewhere later (flow is of type Flow<Record>)
fun main() = runBlocking<Unit> {
    (1..3).asFlow() // a flow of requests
        .transform { request ->
            emit(Metadata("Making request $request"))
            if (request > 1) {
                emit(IntData(performRequest(request)))
            }
            // probably want to handle the `else` case too
          
        }
        .collect { response -> println(response) }
}

This would be a good solution since it's extendable (i.e. you can add the other cases later on if you need to).

In your specific case though, since you just want to debug the flow, you might not want to actually emit the "metadata" and just go for the tests of your code directly.