Flow.concatWith

[PaulWoitaschek]

I often times need to concat two flows. In RxJava this is called concatWith.

A implementation could look like:

fun <T> Flow<T>.concatWith(other: Flow<T>): Flow<T> {
  return flow {
    collect { emit(it) }
    other.collect { emit(it) }
  }
}

[qwwdfsad]

Could you please provide a use-case for this operator similarly to how you did in #437?
Just a small sample of a domain-specific problem will be enough

[jcaiqueoliveira]

I think that an use case can be something like that:

Processing a document where for each page its emitted a non-terminal state like "InfoNotFound".
If the entire document is processed and the info is not found its necessary to emit more one state to indicate that you have reached the end of the document.

I did something like that to process a pdf with 10 pages until find a barcode or process the entire pdf.

listOfPdfPageFlow()
     .flatMapConcat { page -> processPage(page) }
     .takeUntil {  it !is DocumentState.FoundInfo } //terminal state, no need to process more one page
     .startWith(DocumentState.Processing) // some loading to the user
     .concatWith(DocumentState.Done) // navigate, give some feedback, etc
     .onErrorReturn(DocumentState.Failed) // navigate, give some feedback, etc
     .collect {
          when(it){
                is DocumentState.Done, is DocumentState.FoundIt -> navigateToAnotherScreen()
                is DocumentState.Failed -> giveFeedbackAndNavigate()
          }
   }

where

sealed class DocumentState {
   object Processing : DocumentState() //non-terminal
   object InfoNotFound : DocumentState()//non-terminal
   data class FoundIt(val result: String) : DocumentState()//terminal
   data class Failed(val e: Throwable) : DocumentState()//terminal
   object Done : DocumentState() //terminal
}

fun <T> Flow<T>.startWith(start: T) = flow {
    collect { value ->
        emit(start)
        emit(value)
    }
}

[elizarov]

If the one is startWith then the other should be completeWith for consistency with our terminology (coroutines are started and complete) and then both shall be added. Actually, there we already have onCompletion and if we add (currently missing) onStart operator, then both startWith and completeWith will have quite a trivial implementation:

startWith(value) = onStart { emit(value) }
completeWith(value) = onCompletion { emit(value) }

[elizarov]

In a similar vein to catch operator we strive to minimalism in operators. We don't have onErrorReturn(value), but you can use catch { emit(value) }, etc.