gistfile1.txt

sealed class Result<out T> {
  class Ok<out T>(val value: T) : Result<T>()
  class Err(val input: Any?, val exception: Exception) : Result<Nothing>()
}

typealias ResultSequence<T> = Sequence<Result<T>>

fun <T> Sequence<T>.toSortedList(comparator: Comparator<in T>): List<T> =
    toMutableList().apply { sortWith(comparator) }

fun <T, R> Sequence<T>.mapCatching(transform: (T) -> R): ResultSequence<R> =
    map { item ->
      try {
        Result.Ok(transform(item))
      } catch (e: Exception) {
        Result.Err(item, e)
      }
    }

fun <T, R> ResultSequence<T>.mapOk(transform: (T) -> R): ResultSequence<R> =
    map { result ->
      when (result) {
        is Result.Ok ->
          try {
            Result.Ok(transform(result.value))
          } catch (e: Exception) {
            Result.Err(result.value, e)
          }
        is Result.Err -> result
      }
    }

fun <T, R> ResultSequence<T>.flatMapOk(transform: (T) -> Sequence<R>): ResultSequence<R> =
    flatMap { result ->
      when (result) {
        is Result.Ok ->
          try {
            transform(result.value).map { Result.Ok(it) }
          } catch (e: Exception) {
            sequenceOf(Result.Err(result.value, e))
          }
        is Result.Err -> sequenceOf(result)
      }
    }

fun <T> ResultSequence<T>.onEachOk(action: (T) -> Unit): ResultSequence<T> =
    map { result ->
      when (result) {
        is Result.Ok ->
          try {
            action(result.value)
            result
          } catch (e: Exception) {
            Result.Err(result.value, e)
          }
        is Result.Err -> result
      }
    }

fun <T> ResultSequence<T>.onEachErr(action: (input: Any?, exception: Exception) -> Unit): ResultSequence<T> =
    map { result ->
      if (result is Result.Err) {
        try {
          action(result.input, result.exception)
        } catch (e: Exception) {
          result.exception.addSuppressed(e)
        }
      }
      result
    }