Блог

Я ищу наиболее «чистый» способ реализации следующей логики:

• У меня есть N методов, каждый возвращает поток<Результат<SOME_TYPE>> (тип отличается)
• Я хочу связать эти методы, поэтому, если 1 возвращает результат.Успех, затем вызовите 2nd и так далее.

Наиболее очевидный способ сделать это:

 methodA().map { methodAResult ->
  when (methodAResult) {
    is Result.Success -> {
      methodB(methodAResult).map { methodBResult ->
        when (methodBResult) {
          is Result.Success -> {
            methodC(methodAResult).map { methodCResult ->
              when (methodCResult) {
                is Result.Success -> TODO()
                is Result.Failure -> TODO()
              }
            }
          }
          is Result.Failure -> TODO()
        }
      }
     }
     is Result.Failure -> TODO()
   }
 }
  

Но это похоже на хорошо известный «ад обратного вызова». Есть ли у вас какие-либо идеи, как этого избежать?

Я считаю, что это можно было бы сгладить с помощью оператора преобразования:

 methodA().transform { methodAResult ->
    when (methodAResult) {
        is Success -> methodB(methodAResult).collect { emit(it) }
        is Failure -> TODO()
    }
}.transform { methodBResult ->
    when (methodBResult) {
        is Success -> methodC(methodBResult).collect { emit(it) }
        is Failure -> TODO()
    }
}.transform { methodCResult ->
    when (methodCResult) {
        is Success -> TODO()
        is Failure -> TODO()
    }
}
  

Небольшая модификация решения, предоставленного Михаил Нафталь

     methodA()
        .flatMapMerge {
            when (it) {
                is Result.Success -> methodB(it)
                is Result.Failure -> emptyFlow()
            }
        }.flatMapMerge {
            when (it) {
                is Result.Success -> methodC(it)
                is Result.Failure -> emptyFlow()
            }
        }.collect {
            when (it) {
                is Result.Success -> TODO()
                is Result.Failure -> TODO()
            }
        }

  

Целью flatMap является объединение выходных данных одного потока с другим потоком, поэтому использование flatMap кажется немного более чистым.

Если этот класс результатов имеет map fold getOrNull метод типа , , или, это можно было бы еще немного очистить, а блоки when можно было бы удалить.

Также, если вам нужно распространить сбой для сбора, вы можете заменить вызовы emptyFlow потоком, который просто выводит нужный вам сбой.

Плохо flatMap , что метод все еще не существует.

Но вы можете использовать mapCatching :

 methodA
    .mapCatching { a -> methodB(a).getOrThrow() }
    .mapCatching { b -> methodC(b).getOrThrow() }
  

Или создайте свою собственную flatMap функцию расширения :

 fun <T, R> Result<T>.flatMap(block: (T) -> (Result<R>)): Result<R> {
    return this.mapCatching {
        block(it).getOrThrow()
    }
}

methodA
    .flatMap { a -> methodB(a) }
    .flatMap { b -> methodC(b) }
  

Я считаю, что в этом случае вам, вероятно, следует использовать suspend функции и составлять их с помощью await() . Ошибки должны передаваться через исключения, как описано здесь .