diff --git a/state/src/commonMain/kotlin/outcome/Accessors.kt b/state/src/commonMain/kotlin/outcome/Accessors.kt
index 9617870..4b858d4 100644
--- a/state/src/commonMain/kotlin/outcome/Accessors.kt
+++ b/state/src/commonMain/kotlin/outcome/Accessors.kt
@@ -1,13 +1,37 @@
 package opensavvy.state.outcome
 
+import opensavvy.state.outcome.Outcome.Failure
+import opensavvy.state.outcome.Outcome.Success
+
+// region Get or null
+
 /**
- * Returns [Success.value][Outcome.Success.value], or `null` if this outcome is not successful.
+ * Returns [Success.value], or `null` if this outcome is not successful.
  */
 val <T : Any> Outcome<*, T>.valueOrNull: T?
-    get() = (this as? Outcome.Success<T>)?.value
+    get() = (this as? Success)?.value
 
 /**
- * Returns [Failure.failure][Outcome.Failure.failure], or `null` if this outcome is not a failure.
+ * Returns [Failure.failure], or `null` if this outcome is not a failure.
  */
 val <F : Any> Outcome<F, *>.failureOrNull: F?
-    get() = (this as? Outcome.Failure)?.failure
+    get() = (this as? Failure)?.failure
+
+// endregion
+// region Safe get via Nothing
+
+/**
+ * Returns [Success.value].
+ */
+val <T> Outcome<Nothing, T>.value: T
+    // This cast is safe, because a Failure of Nothing is impossible
+    get() = (this as Success).value
+
+/**
+ * Returns [Failure.failure].
+ */
+val <F> Outcome<F, Nothing>.failure: F
+    // This cast is safe, because a Success of Nothing is impossible
+    get() = (this as Failure).failure
+
+// endregion
diff --git a/state/src/commonTest/kotlin/outcome/AccessorsTest.kt b/state/src/commonTest/kotlin/outcome/AccessorsTest.kt
index cc24fda..fe5faf3 100644
--- a/state/src/commonTest/kotlin/outcome/AccessorsTest.kt
+++ b/state/src/commonTest/kotlin/outcome/AccessorsTest.kt
@@ -7,6 +7,8 @@ class AccessorsTest {
 
     private object Failed
 
+    // region variant orNull
+
     @Test
     fun valueOnSuccess() {
         assertEquals(
@@ -40,4 +42,25 @@ class AccessorsTest {
             Failed.failed().failureOrNull,
         )
     }
+
+    // endregion
+    // region variant Nothing
+
+    @Test
+    fun valueOnSuccessNothing() {
+        assertEquals(
+            5,
+            (5.success() as Outcome<Nothing, Int>).value,
+        )
+    }
+
+    @Test
+    fun failureOnFailureNothing() {
+        assertEquals(
+            Failed,
+            (Failed.failed() as Outcome<Failed, Nothing>).failure,
+        )
+    }
+
+    // endregion
 }
-- 
2.51.2


From 39ea5f9bcae17b18cdc04af9f2408fb966eb9bf1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ivan=20=E2=80=9CCLOVIS=E2=80=9D=20Canet?=
 <ivan.canet@gmail.com>
Date: Sat, 29 Apr 2023 19:40:28 +0200
Subject: [PATCH 2/2] feat(state): ProgressiveOutcome accessors for value and
 failure when the other component is Nothing

---
 .../kotlin/progressive/Accessors.kt           | 24 +++++++++++++++--
 .../kotlin/progressive/AccessorsTest.kt       | 26 +++++++++++++++++++
 2 files changed, 48 insertions(+), 2 deletions(-)

diff --git a/state/src/commonMain/kotlin/progressive/Accessors.kt b/state/src/commonMain/kotlin/progressive/Accessors.kt
index 78c07ef..4949cff 100644
--- a/state/src/commonMain/kotlin/progressive/Accessors.kt
+++ b/state/src/commonMain/kotlin/progressive/Accessors.kt
@@ -3,13 +3,13 @@ package opensavvy.state.progressive
 import opensavvy.state.outcome.Outcome
 import opensavvy.state.progressive.ProgressiveOutcome.*
 
-//region Regular
+// region Get or null
 
 /**
  * Returns [Success.value], or `null` if this outcome is not successful.
  */
 val <T : Any> ProgressiveOutcome<*, T>.valueOrNull: T?
-	get() = (this as? Success<T>)?.value
+	get() = (this as? Success)?.value
 
 /**
  * Returns [Failure.failure], or `null` if this outcome is not a failure.
@@ -17,6 +17,26 @@ val <T : Any> ProgressiveOutcome<*, T>.valueOrNull: T?
 val <F> ProgressiveOutcome<F, *>.failureOrNull: F?
 	get() = (this as? Failure)?.failure
 
+// endregion
+// region Safe get via Nothing
+
+/**
+ * Returns [Success.value].
+ */
+val <T> ProgressiveOutcome<Nothing, T>.value: T
+	// This cast is safe, because a Success of Nothing is impossible
+	get() = (this as Success).value
+
+/**
+ * Returns [Failure.failure].
+ */
+val <F> ProgressiveOutcome<F, Nothing>.failure: F
+	// This cast is safe, because a Success of Nothing is impossible
+	get() = (this as Failure).failure
+
+// endregion
+// region Conversion
+
 /**
  * Converts this progressive outcome into a [regular outcome][Outcome].
  *
diff --git a/state/src/commonTest/kotlin/progressive/AccessorsTest.kt b/state/src/commonTest/kotlin/progressive/AccessorsTest.kt
index 0f428c9..7139aa3 100644
--- a/state/src/commonTest/kotlin/progressive/AccessorsTest.kt
+++ b/state/src/commonTest/kotlin/progressive/AccessorsTest.kt
@@ -10,6 +10,8 @@ class AccessorsTest {
 
     private object Failed
 
+    // region Get or null
+
     @Test
     fun valueOnSuccess() {
         assertEquals(
@@ -44,6 +46,28 @@ class AccessorsTest {
         )
     }
 
+    // endregion
+    // region Nothing variant
+
+    @Test
+    fun valueOnSuccessNothing() {
+        assertEquals(
+            5,
+            (5.success() as ProgressiveOutcome<Nothing, Int>).value,
+        )
+    }
+
+    @Test
+    fun failureOnFailureNothing() {
+        assertEquals(
+            Failed,
+            (Failed.failed() as ProgressiveOutcome<Failed, Nothing>).failure,
+        )
+    }
+
+    // endregion
+    // region Destructuration
+
     @Test
     fun destructurationOnSuccess() {
         val value: ProgressiveOutcome<*, Int> = ProgressiveOutcome.Success(5, loading(0.23))
@@ -70,4 +94,6 @@ class AccessorsTest {
         assertEquals(null, outcome)
         assertEquals(loading(0.23), progress)
     }
+
+    // endregion
 }