Revert "make error and value private fields accessed by properties"

This reverts commit 2606efb.

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,10 +189,6 @@ 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)
@@ -201,24 +197,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
 
@@ -249,10 +245,6 @@ 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,9 +22,8 @@ async def raise_ValueError(x):
         raise ValueError(x)
 
     e = await outcome.acapture(raise_ValueError, 9)
-    error = e.error
-    assert type(error) is ValueError
-    assert error.args == (9,)
+    assert type(e.error) is ValueError
+    assert e.error.args == (9,)
 
 
 async def test_asend():

tests/test_sync.py

@@ -10,7 +10,6 @@
 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>)"
@@ -22,16 +21,13 @@ def test_Outcome():
 
     exc = RuntimeError("oops")
     e = Error(exc)
-    error = e.error
-    assert error is exc
-    e = Error(exc)
+    assert e.error is 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(<AlreadyUsed>)"
+    assert repr(e) == "Error(<DEAD>)"
 
     e = Error(exc)
     with pytest.raises(TypeError):
@@ -105,9 +101,8 @@ def raise_ValueError(x):
 
     e = outcome.capture(raise_ValueError, "two")
     assert type(e) == Error
-    error = e.error
-    assert type(error) is ValueError
-    assert error.args == ("two",)
+    assert type(e.error) is ValueError
+    assert e.error.args == ("two",)
 
 
 def test_inheritance():