remove reference to value/error when unwrapping outcome

Author: graingert

src/outcome/_impl.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import enum
 import abc
 from typing import (
     TYPE_CHECKING,
@@ -12,17 +13,20 @@
     TypeVar,
     Union,
     overload,
+    Literal,
 )
 
 import attr
 
 from ._util import AlreadyUsedError, remove_tb_frames
 
 if TYPE_CHECKING:
-    from typing_extensions import ParamSpec, final
+    from typing_extensions import ParamSpec, final, Final
     ArgsT = ParamSpec("ArgsT")
 else:
 
+    Final = object
+
     def final(func):
         return func
 
@@ -106,6 +110,14 @@ async def acapture(
         return Error(exc)
 
 
+class _Unwrapped(enum.Enum):
+    IS_UNWRAPPED = enum.auto()
+
+
+IS_UNWRAPPED: Final = _Unwrapped.IS_UNWRAPPED
+IsUnwrapped: TypeAlias = Literal[_Unwrapped.IS_UNWRAPPED]
+
+
 @attr.s(repr=False, init=False, slots=True)
 class Outcome(abc.ABC, Generic[ValueT]):
     """An abstract class representing the result of a Python computation.
@@ -122,13 +134,6 @@ class Outcome(abc.ABC, Generic[ValueT]):
     hashable.
 
     """
-    _unwrapped: bool = attr.ib(default=False, eq=False, init=False)
-
-    def _set_unwrapped(self) -> None:
-        if self._unwrapped:
-            raise AlreadyUsedError
-        object.__setattr__(self, '_unwrapped', True)
-
     @abc.abstractmethod
     def unwrap(self) -> ValueT:
         """Return or raise the contained value or exception.
@@ -170,23 +175,30 @@ class Value(Outcome[ValueT], Generic[ValueT]):
 
     """
 
-    value: ValueT = attr.ib()
+    _value: IsUnwrapped | ValueT = attr.ib()
     """The contained value."""
 
+    @property
+    def value(self) -> ValueT:
+        return self.unwrap()
+
     def __repr__(self) -> str:
         return f'Value({self.value!r})'
 
     def unwrap(self) -> ValueT:
-        self._set_unwrapped()
-        return self.value
+        if self._value is IS_UNWRAPPED:
+            raise AlreadyUsedError
+
+        try:
+            return self._value
+        finally:
+            object.__setattr__(self, "_value", IS_UNWRAPPED)
 
     def send(self, gen: Generator[ResultT, ValueT, object]) -> ResultT:
-        self._set_unwrapped()
-        return gen.send(self.value)
+        return gen.send(self.unwrap())
 
     async def asend(self, agen: AsyncGenerator[ResultT, ValueT]) -> ResultT:
-        self._set_unwrapped()
-        return await agen.asend(self.value)
+        return await agen.asend(self.unwrap())
 
 
 @final
@@ -196,16 +208,24 @@ class Error(Outcome[NoReturn]):
 
     """
 
-    error: BaseException = attr.ib(
+    _error: IsUnwrapped | BaseException = attr.ib(
         validator=attr.validators.instance_of(BaseException)
     )
     """The contained exception object."""
 
+    @property
+    def error(self):
+        if self._error is IS_UNWRAPPED:
+            raise AlreadyUsedError
+        try:
+            return self._error
+        finally:
+            object.__setattr__(self, "_error", IsUnwrapped)
+
     def __repr__(self) -> str:
         return f'Error({self.error!r})'
 
     def unwrap(self) -> NoReturn:
-        self._set_unwrapped()
         # Tracebacks show the 'raise' line below out of context, so let's give
         # this variable a name that makes sense out of context.
         captured_error = self.error
@@ -227,11 +247,9 @@ def unwrap(self) -> NoReturn:
             del captured_error, self
 
     def send(self, gen: Generator[ResultT, NoReturn, object]) -> ResultT:
-        self._set_unwrapped()
         return gen.throw(self.error)
 
     async def asend(self, agen: AsyncGenerator[ResultT, NoReturn]) -> ResultT:
-        self._set_unwrapped()
         return await agen.athrow(self.error)