Rename result to sealed result

Migrate remaining use cases

Author: Lucas Sales

app/src/main/java/com/monstarlab/arch/extensions/Result.kt renamed to app/src/main/java/com/monstarlab/arch/extensions/SealedResult.kt

@@ -12,13 +12,13 @@ import kotlin.contracts.contract
  * A discriminated union that encapsulates a successful outcome with a value of type [T]
  * or a failure with an arbitrary [Throwable] exception.
  */
-sealed class Result<out T> : Serializable {
+sealed class SealedResult<out T> : Serializable {
 
     @PublishedApi
-    internal data class Failure<out T>(val exception: Throwable) : Result<T>()
+    internal data class Failure<out T>(val exception: Throwable) : SealedResult<T>()
 
     @PublishedApi
-    internal data class Success<out T>(val value: T) : Result<T>()
+    internal data class Success<out T>(val value: T) : SealedResult<T>()
 
     /**
      * Returns `true` if this instance represents a failed outcome.
@@ -35,8 +35,8 @@ sealed class Result<out T> : Serializable {
         get() = this is Success
 
     /**
-     * Returns the encapsulated value if this instance represents [success][Result.isSuccess] or `null`
-     * if it is [failure][Result.isFailure].
+     * Returns the encapsulated value if this instance represents [success][SealedResult.isSuccess] or `null`
+     * if it is [failure][SealedResult.isFailure].
      *
      * This function is a shorthand for `getOrElse { null }` (see [getOrElse]) or
      * `fold(onSuccess = { it }, onFailure = { null })` (see [fold]).
@@ -58,7 +58,7 @@ sealed class Result<out T> : Serializable {
     }
 
     /**
-     * Returns a string `Success(v)` if this instance represents [success][Result.isSuccess]
+     * Returns a string `Success(v)` if this instance represents [success][SealedResult.isSuccess]
      * where `v` is a string representation of the value or a string `Failure(x)` if
      * it is [failure][isFailure] where `x` is a string representation of the exception.
      */
@@ -68,20 +68,20 @@ sealed class Result<out T> : Serializable {
     }
 
     /**
-     * Companion object for [Result] class that contains its constructor functions
+     * Companion object for [SealedResult] class that contains its constructor functions
      * [success] and [failure].
      */
     public companion object {
 
         /**
          * Returns an instance that encapsulates the given [value] as successful value.
          */
-        public fun <T> success(value: T): Result<T> = Success(value)
+        public fun <T> success(value: T): SealedResult<T> = Success(value)
 
         /**
          * Returns an instance that encapsulates the given [Throwable] [exception] as failure.
          */
-        public fun <T> failure(exception: Throwable): Result<T> = Failure(exception)
+        public fun <T> failure(exception: Throwable): SealedResult<T> = Failure(exception)
     }
 }
 
@@ -90,67 +90,67 @@ sealed class Result<out T> : Serializable {
  * catching any [Throwable] exception that was thrown from the [block] function execution and encapsulating it as a failure.
  */
 @Suppress("FunctionName", "TooGenericExceptionCaught")
-public inline fun <T> Result(block: () -> T): Result<T> {
+public inline fun <T> SealedResult(block: () -> T): SealedResult<T> {
     return try {
-        Result.success(block())
+        SealedResult.success(block())
     } catch (exception: Throwable) {
-        Result.failure(exception)
+        SealedResult.failure(exception)
     }
 }
 
 /**
- * Returns the encapsulated value if this instance represents [success][Result.isSuccess] or throws the encapsulated [Throwable] exception
- * if it is [failure][Result.isFailure].
+ * Returns the encapsulated value if this instance represents [success][SealedResult.isSuccess] or throws the encapsulated [Throwable] exception
+ * if it is [failure][SealedResult.isFailure].
  *
  * This function is a shorthand for `getOrElse { throw it }` (see [getOrElse]).
  */
-public fun <T> Result<T>.getOrThrow(): T {
+public fun <T> SealedResult<T>.getOrThrow(): T {
     return when (this) {
-        is Result.Failure -> throw exception
-        is Result.Success -> value
+        is SealedResult.Failure -> throw exception
+        is SealedResult.Success -> value
     }
 }
 
 /**
- * Returns the encapsulated value if this instance represents [success][Result.isSuccess] or the
- * result of [onFailure] function for the encapsulated [Throwable] exception if it is [failure][Result.isFailure].
+ * Returns the encapsulated value if this instance represents [success][SealedResult.isSuccess] or the
+ * result of [onFailure] function for the encapsulated [Throwable] exception if it is [failure][SealedResult.isFailure].
  *
  * Note, that this function rethrows any [Throwable] exception thrown by [onFailure] function.
  *
  * This function is a shorthand for `fold(onSuccess = { it }, onFailure = onFailure)` (see [fold]).
  */
 @OptIn(ExperimentalContracts::class)
-public inline fun <R, T : R> Result<T>.getOrElse(onFailure: (exception: Throwable) -> R): R {
+public inline fun <R, T : R> SealedResult<T>.getOrElse(onFailure: (exception: Throwable) -> R): R {
     contract {
         callsInPlace(onFailure, InvocationKind.AT_MOST_ONCE)
     }
     return when (this) {
-        is Result.Failure -> onFailure(exception)
-        is Result.Success -> value
+        is SealedResult.Failure -> onFailure(exception)
+        is SealedResult.Success -> value
     }
 }
 
 /**
- * Returns the encapsulated value if this instance represents [success][Result.isSuccess] or the
- * [defaultValue] if it is [failure][Result.isFailure].
+ * Returns the encapsulated value if this instance represents [success][SealedResult.isSuccess] or the
+ * [defaultValue] if it is [failure][SealedResult.isFailure].
  *
  * This function is a shorthand for `getOrElse { defaultValue }` (see [getOrElse]).
  */
-public fun <R, T : R> Result<T>.getOrDefault(defaultValue: R): R {
+public fun <R, T : R> SealedResult<T>.getOrDefault(defaultValue: R): R {
     return when (this) {
-        is Result.Failure -> defaultValue
-        is Result.Success -> value
+        is SealedResult.Failure -> defaultValue
+        is SealedResult.Success -> value
     }
 }
 
 /**
- * Returns the result of [onSuccess] for the encapsulated value if this instance represents [success][Result.isSuccess]
- * or the result of [onFailure] function for the encapsulated [Throwable] exception if it is [failure][Result.isFailure].
+ * Returns the result of [onSuccess] for the encapsulated value if this instance represents [success][SealedResult.isSuccess]
+ * or the result of [onFailure] function for the encapsulated [Throwable] exception if it is [failure][SealedResult.isFailure].
  *
  * Note, that this function rethrows any [Throwable] exception thrown by [onSuccess] or by [onFailure] function.
  */
 @OptIn(ExperimentalContracts::class)
-public inline fun <R, T> Result<T>.fold(
+public inline fun <R, T> SealedResult<T>.fold(
     onFailure: (exception: Throwable) -> R,
     onSuccess: (value: T) -> R
 ): R {
@@ -159,148 +159,148 @@ public inline fun <R, T> Result<T>.fold(
         callsInPlace(onSuccess, InvocationKind.AT_MOST_ONCE)
     }
     return when (this) {
-        is Result.Failure -> onFailure(exception)
-        is Result.Success -> onSuccess(value)
+        is SealedResult.Failure -> onFailure(exception)
+        is SealedResult.Success -> onSuccess(value)
     }
 }
 
 /**
  * Returns the encapsulated result of the given [transform] function applied to the encapsulated value
- * if this instance represents [success][Result.isSuccess] or the
- * original encapsulated [Throwable] exception if it is [failure][Result.isFailure].
+ * if this instance represents [success][SealedResult.isSuccess] or the
+ * original encapsulated [Throwable] exception if it is [failure][SealedResult.isFailure].
  *
  * Note, that this function rethrows any [Throwable] exception thrown by [transform] function.
  * See [mapCatching] for an alternative that encapsulates exceptions.
  */
 @OptIn(ExperimentalContracts::class)
-public inline fun <R, T> Result<T>.map(transform: (value: T) -> R): Result<R> {
+public inline fun <R, T> SealedResult<T>.map(transform: (value: T) -> R): SealedResult<R> {
     contract {
         callsInPlace(transform, InvocationKind.AT_MOST_ONCE)
     }
     return when (this) {
-        is Result.Failure -> Result.failure(exception)
-        is Result.Success -> Result.success(transform(value))
+        is SealedResult.Failure -> SealedResult.failure(exception)
+        is SealedResult.Success -> SealedResult.success(transform(value))
     }
 }
 
 /**
  * Returns the encapsulated result of the given [transform] function applied to the encapsulated value
- * if this instance represents [success][Result.isSuccess] or the
- * original encapsulated [Throwable] exception if it is [failure][Result.isFailure].
+ * if this instance represents [success][SealedResult.isSuccess] or the
+ * original encapsulated [Throwable] exception if it is [failure][SealedResult.isFailure].
  *
  * This function catches any [Throwable] exception thrown by [transform] function and encapsulates it as a failure.
  * See [map] for an alternative that rethrows exceptions from `transform` function.
  */
-public inline fun <R, T> Result<T>.mapCatching(transform: (value: T) -> R): Result<R> {
+public inline fun <R, T> SealedResult<T>.mapCatching(transform: (value: T) -> R): SealedResult<R> {
     return when (this) {
-        is Result.Failure -> Result.failure(exception)
-        is Result.Success -> Result { transform(value) }
+        is SealedResult.Failure -> SealedResult.failure(exception)
+        is SealedResult.Success -> SealedResult { transform(value) }
     }
 }
 
 /**
- * Returns a [Result] of the given [transform] function applied to the encapsulated value
- * if this instance represents [success][Result.isSuccess] or the
- * original encapsulated [Throwable] exception if it is [failure][Result.isFailure].
+ * Returns a [SealedResult] of the given [transform] function applied to the encapsulated value
+ * if this instance represents [success][SealedResult.isSuccess] or the
+ * original encapsulated [Throwable] exception if it is [failure][SealedResult.isFailure].
  *
  * Note, that this function rethrows any [Throwable] exception thrown by [transform] function.
  * See [flatMapCatching] for an alternative that encapsulates exceptions.
  */
 @OptIn(ExperimentalContracts::class)
-public inline fun <R, T> Result<T>.flatMap(transform: (value: T) -> Result<R>): Result<R> {
+public inline fun <R, T> SealedResult<T>.flatMap(transform: (value: T) -> SealedResult<R>): SealedResult<R> {
     contract {
         callsInPlace(transform, InvocationKind.AT_MOST_ONCE)
     }
     return when (this) {
-        is Result.Failure -> Result.failure(exception)
-        is Result.Success -> transform(value)
+        is SealedResult.Failure -> SealedResult.failure(exception)
+        is SealedResult.Success -> transform(value)
     }
 }
 
 /**
- * Returns a [Result] of the given [transform] function applied to the encapsulated value
- * if this instance represents [success][Result.isSuccess] or the
- * original encapsulated [Throwable] exception if it is [failure][Result.isFailure].
+ * Returns a [SealedResult] of the given [transform] function applied to the encapsulated value
+ * if this instance represents [success][SealedResult.isSuccess] or the
+ * original encapsulated [Throwable] exception if it is [failure][SealedResult.isFailure].
  *
  * This function catches any [Throwable] exception thrown by [transform] function and encapsulates it as a failure.
  * See [map] for an alternative that rethrows exceptions from `transform` function.
  */
-public inline fun <R, T> Result<T>.flatMapCatching(transform: (value: T) -> Result<R>): Result<R> {
+public inline fun <R, T> SealedResult<T>.flatMapCatching(transform: (value: T) -> SealedResult<R>): SealedResult<R> {
     return when (this) {
-        is Result.Failure -> Result.failure(exception)
-        is Result.Success -> Result { transform(value).getOrThrow() }
+        is SealedResult.Failure -> SealedResult.failure(exception)
+        is SealedResult.Success -> SealedResult { transform(value).getOrThrow() }
     }
 }
 
 /**
  * Returns the encapsulated result of the given [transform] function applied to the encapsulated [Throwable] exception
- * if this instance represents [failure][Result.isFailure] or the
- * original encapsulated value if it is [success][Result.isSuccess].
+ * if this instance represents [failure][SealedResult.isFailure] or the
+ * original encapsulated value if it is [success][SealedResult.isSuccess].
  *
  * Note, that this function rethrows any [Throwable] exception thrown by [transform] function.
  * See [recoverCatching] for an alternative that encapsulates exceptions.
  */
 @OptIn(ExperimentalContracts::class)
-public inline fun <R, T : R> Result<T>.recover(transform: (exception: Throwable) -> R): Result<R> {
+public inline fun <R, T : R> SealedResult<T>.recover(transform: (exception: Throwable) -> R): SealedResult<R> {
     contract {
         callsInPlace(transform, InvocationKind.AT_MOST_ONCE)
     }
     return when (this) {
-        is Result.Failure -> Result.success(transform(exception))
-        is Result.Success -> this
+        is SealedResult.Failure -> SealedResult.success(transform(exception))
+        is SealedResult.Success -> this
     }
 }
 
 /**
  * Returns the encapsulated result of the given [transform] function applied to the encapsulated [Throwable] exception
- * if this instance represents [failure][Result.isFailure] or the
- * original encapsulated value if it is [success][Result.isSuccess].
+ * if this instance represents [failure][SealedResult.isFailure] or the
+ * original encapsulated value if it is [success][SealedResult.isSuccess].
  *
  * This function catches any [Throwable] exception thrown by [transform] function and encapsulates it as a failure.
  * See [recover] for an alternative that rethrows exceptions.
  */
-public inline fun <R, T : R> Result<T>.recoverCatching(transform: (exception: Throwable) -> R): Result<R> {
+public inline fun <R, T : R> SealedResult<T>.recoverCatching(transform: (exception: Throwable) -> R): SealedResult<R> {
     return when (this) {
-        is Result.Failure -> Result { transform(exception) }
-        is Result.Success -> this
+        is SealedResult.Failure -> SealedResult { transform(exception) }
+        is SealedResult.Success -> this
     }
 }
 
 /**
- * Performs the given [action] on the encapsulated [Throwable] exception if this instance represents [failure][Result.isFailure].
+ * Performs the given [action] on the encapsulated [Throwable] exception if this instance represents [failure][SealedResult.isFailure].
  * Returns the original `Result` unchanged.
  */
 @OptIn(ExperimentalContracts::class)
-public inline fun <T> Result<T>.onFailure(action: (exception: Throwable) -> Unit): Result<T> {
+public inline fun <T> SealedResult<T>.onFailure(action: (exception: Throwable) -> Unit): SealedResult<T> {
     contract {
         callsInPlace(action, InvocationKind.AT_MOST_ONCE)
     }
-    if (this is Result.Failure) action(exception)
+    if (this is SealedResult.Failure) action(exception)
     return this
 }
 
 /**
- * Performs the given [action] on the encapsulated value if this instance represents [success][Result.isSuccess].
+ * Performs the given [action] on the encapsulated value if this instance represents [success][SealedResult.isSuccess].
  * Returns the original `Result` unchanged.
  */
 @OptIn(ExperimentalContracts::class)
-public inline fun <T> Result<T>.onSuccess(action: (value: T) -> Unit): Result<T> {
+public inline fun <T> SealedResult<T>.onSuccess(action: (value: T) -> Unit): SealedResult<T> {
     contract {
         callsInPlace(action, InvocationKind.AT_MOST_ONCE)
     }
-    if (this is Result.Success) action(value)
+    if (this is SealedResult.Success) action(value)
     return this
 }
 
 @OptIn(ExperimentalContracts::class)
-fun <T> Flow<Result<T>>.onResult(
+fun <T> Flow<SealedResult<T>>.onResult(
     onFailure: suspend (exception: Throwable) -> Unit,
     onSuccess: suspend (value: T) -> Unit
-): Flow<Result<T>> {
+): Flow<SealedResult<T>> {
     return onEach { result ->
         when (result) {
-            is Result.Failure -> onFailure(result.exception)
-            is Result.Success -> onSuccess(result.value)
+            is SealedResult.Failure -> onFailure(result.exception)
+            is SealedResult.Success -> onSuccess(result.value)
         }
     }
 }

app/src/main/java/com/monstarlab/core/usecases/blog/GetPostsUseCase.kt

@@ -1,16 +1,16 @@
 package com.monstarlab.core.usecases.blog
 
-import com.monstarlab.arch.extensions.UseCaseResult
-import com.monstarlab.arch.extensions.safeFlow
+import com.monstarlab.arch.extensions.SealedResult
 import com.monstarlab.core.data.repositories.PostRepository
 import com.monstarlab.core.domain.model.Post
 import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.flow
 import javax.inject.Inject
 
 class GetPostsUseCase @Inject constructor(
     private val postRepository: PostRepository
-){
-    fun getPosts(): Flow<UseCaseResult<List<Post>>> = safeFlow {
-        postRepository.getPosts()
+) {
+    fun getPosts(): Flow<SealedResult<List<Post>>> = flow {
+        emit(SealedResult { postRepository.getPosts() })
     }
 }

app/src/main/java/com/monstarlab/core/usecases/resources/GetResourcesUseCase.kt

@@ -1,7 +1,6 @@
 package com.monstarlab.core.usecases.resources
 
-import com.monstarlab.arch.extensions.Result
-import com.monstarlab.arch.extensions.safeFlow
+import com.monstarlab.arch.extensions.SealedResult
 import com.monstarlab.core.data.repositories.ResourceRepository
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.flow
@@ -13,7 +12,7 @@ class GetResourcesUseCase @Inject constructor(
 
     fun getResources() = flow {
         delay(2000)
-        emit(Result { resourceRepository.getResources() })
+        emit(SealedResult { resourceRepository.getResources() })
     }
 
 }