make error and value private fields accessed by properties

add types
e.error unwraps

Author: graingert

src/outcome/_impl.py

@@ -164,22 +164,22 @@ class Value(Outcome[ValueT], Generic[ValueT]):
 
     """
 
-    value: ValueT = attr.ib()
+    _value: ValueT = attr.ib()
     """The contained value."""
 
     def __repr__(self) -> str:
         try:
-            return f'Value({self.value!r})'
+            return f'Value({self._value!r})'
         except AttributeError:
             return f'Value(<AlreadyUsed>)'
 
     def unwrap(self) -> ValueT:
         try:
-            v = self.value
+            v = self._value
         except AttributeError:
             pass
         else:
-            object.__delattr__(self, "value")
+            object.__delattr__(self, "_value")
             return v
         raise AlreadyUsedError
 
@@ -189,6 +189,10 @@ def send(self, gen: Generator[ResultT, ValueT, object]) -> ResultT:
     async def asend(self, agen: AsyncGenerator[ResultT, ValueT]) -> ResultT:
         return await agen.asend(self.unwrap())
 
+    @property
+    def value(self) -> ValueT:
+        return self.unwrap()
+
 
 @final
 @attr.s(frozen=True, repr=False, slots=True)
@@ -197,24 +201,24 @@ class Error(Outcome[NoReturn]):
 
     """
 
-    error: BaseException = attr.ib(
+    _error: BaseException = attr.ib(
         validator=attr.validators.instance_of(BaseException)
     )
     """The contained exception object."""
 
     def __repr__(self) -> str:
         try:
-            return f'Error({self.error!r})'
+            return f'Error({self._error!r})'
         except AttributeError:
             return 'Error(<AlreadyUsed>)'
 
     def _unwrap_error(self) -> BaseException:
         try:
-            v = self.error
+            v = self._error
         except AttributeError:
             pass
         else:
-            object.__delattr__(self, "error")
+            object.__delattr__(self, "_error")
             return v
         raise AlreadyUsedError
 
@@ -245,6 +249,10 @@ def send(self, gen: Generator[ResultT, NoReturn, object]) -> ResultT:
     async def asend(self, agen: AsyncGenerator[ResultT, NoReturn]) -> ResultT:
         return await agen.athrow(self._unwrap_error())
 
+    @property
+    def error(self) -> BaseException:
+        return self._unwrap_error()
+
 
 # A convenience alias to a union of both results, allowing exhaustiveness checking.
 Maybe = Union[Value[ValueT], Error]

tests/test_async.py

@@ -22,8 +22,9 @@ async def raise_ValueError(x):
         raise ValueError(x)
 
     e = await outcome.acapture(raise_ValueError, 9)
-    assert type(e.error) is ValueError
-    assert e.error.args == (9,)
+    error = e.error
+    assert type(error) is ValueError
+    assert error.args == (9,)
 
 
 async def test_asend():

tests/test_sync.py

@@ -10,6 +10,7 @@
 def test_Outcome():
     v = Value(1)
     assert v.value == 1
+    v = Value(1)
     assert repr(v) == "Value(1)"
     assert v.unwrap() == 1
     assert repr(v) == "Value(<AlreadyUsed>)"
@@ -21,13 +22,16 @@ def test_Outcome():
 
     exc = RuntimeError("oops")
     e = Error(exc)
-    assert e.error is exc
+    error = e.error
+    assert error is exc
+    e = Error(exc)
     assert repr(e) == f"Error({exc!r})"
+    e = Error(exc)
     with pytest.raises(RuntimeError):
         e.unwrap()
     with pytest.raises(AlreadyUsedError):
         e.unwrap()
-    assert repr(e) == "Error(<DEAD>)"
+    assert repr(e) == "Error(<AlreadyUsed>)"
 
     e = Error(exc)
     with pytest.raises(TypeError):
@@ -101,8 +105,9 @@ def raise_ValueError(x):
 
     e = outcome.capture(raise_ValueError, "two")
     assert type(e) == Error
-    assert type(e.error) is ValueError
-    assert e.error.args == ("two",)
+    error = e.error
+    assert type(error) is ValueError
+    assert error.args == ("two",)
 
 
 def test_inheritance():