Use TYPE_CHECKING guard to avoid circular imports between result and option

Author: brendanmaguire

expression/core/option.py

@@ -15,12 +15,12 @@
 from .curry import curry_flip
 from .error import EffectError
 from .pipe import PipeMixin
-from .result import Error, Ok, Result
 from .typing import GenericValidator, ModelField, SupportsValidation
 
 
 if TYPE_CHECKING:
     from expression.collections.seq import Seq
+    from expression.core.result import Result
 
 _TSource = TypeVar("_TSource")
 _TResult = TypeVar("_TResult")
@@ -158,7 +158,7 @@ def of_result(cls, result: Result[_TSource, _TError]) -> Option[_TSource]:
         return of_result(result)
 
     @abstractmethod
-    def to_optional(self) -> Optional[_TSource]:
+    def to_optional(self) -> _TSource | None:
         """Convert option to an optional."""
         raise NotImplementedError
 
@@ -293,16 +293,20 @@ def to_seq(self) -> Seq[_TSource]:
 
         return Seq.of(self._value)
 
-    def to_optional(self) -> Optional[_TSource]:
+    def to_optional(self) -> _TSource | None:
         """Convert option to an optional."""
         return self._value
 
     def to_result(self, error: _TError) -> Result[_TSource, _TError]:
         """Convert option to a result."""
+        from expression.core.result import Ok
+
         return Ok(self._value)
 
     def to_result_with(self, error: Callable[[], _TError]) -> Result[_TSource, _TError]:
         """Convert option to a result."""
+        from expression.core.result import Ok
+
         return Ok(self._value)
 
     def dict(self) -> _TSource:
@@ -419,16 +423,20 @@ def to_seq(self) -> Seq[_TSource]:
 
         return Seq()
 
-    def to_optional(self) -> Optional[_TSource]:
+    def to_optional(self) -> _TSource | None:
         """Convert option to an optional."""
         return None
 
     def to_result(self, error: _TError) -> Result[_TSource, _TError]:
         """Convert option to a result."""
+        from expression.core.result import Error
+
         return Error(error)
 
     def to_result_with(self, error: Callable[[], _TError]) -> Result[_TSource, _TError]:
         """Convert option to a result."""
+        from expression.core.result import Error
+
         return Error(error())
 
     def dict(self) -> builtins.dict[str, Any]:
@@ -564,7 +572,7 @@ def to_seq(option: Option[_TSource]) -> Seq[_TSource]:
     return option.to_seq()
 
 
-def to_optional(value: Option[_TSource]) -> Optional[_TSource]:
+def to_optional(value: Option[_TSource]) -> _TSource | None:
     """Convert an option value to an optional.
 
     Args:
@@ -606,6 +614,8 @@ def of_obj(value: Any) -> Option[Any]:
 
 
 def of_result(result: Result[_TSource, _TError]) -> Option[_TSource]:
+    from expression.core.result import Ok
+
     match result:
         case Ok(value):
             return Some(value)

expression/core/result.py

@@ -14,6 +14,7 @@
 from abc import ABC, abstractmethod
 from collections.abc import Callable, Generator, Iterable, Iterator
 from typing import (
+    TYPE_CHECKING,
     Any,
     ClassVar,
     Generic,
@@ -24,7 +25,10 @@
     get_origin,
 )
 
-from . import option
+
+if TYPE_CHECKING:
+    from expression.core.option import Option
+
 from .curry import curry_flip
 from .error import EffectError
 from .pipe import PipeMixin
@@ -139,24 +143,24 @@ def dict(self) -> builtins.dict[str, _TSource | _TError]:
 
     @abstractmethod
     def swap(self) -> Result[_TError, _TResult]:
-        """Swaps the value in the result so an Ok becomes an Error and an Error becomes an Ok"""
+        """Swaps the value in the result so an Ok becomes an Error and an Error becomes an Ok."""
         raise NotImplementedError
 
     @abstractmethod
-    def to_option(self) -> option.Option[_TSource]:
+    def to_option(self) -> Option[_TSource]:
         """Convert result to an option."""
         raise NotImplementedError
 
     @classmethod
     def of_option(
-        cls, value: option.Option[_TSource], error: _TError
+        cls, value: Option[_TSource], error: _TError
     ) -> Result[_TSource, _TError]:
         """Convert option to a result."""
         return of_option(value, error)
 
     @classmethod
     def of_option_with(
-        cls, value: option.Option[_TSource], error: Callable[[], _TError]
+        cls, value: Option[_TSource], error: Callable[[], _TError]
     ) -> Result[_TSource, _TError]:
         """Convert option to a result."""
         return of_option_with(value, error)
@@ -254,12 +258,14 @@ def dict(self) -> builtins.dict[str, _TSource | _TError]:
         return {"ok": value}
 
     def swap(self) -> Result[_TError, _TSource]:
-        """Swaps the value in the result so an Ok becomes an Error and an Error becomes an Ok"""
+        """Swaps the value in the result so an Ok becomes an Error and an Error becomes an Ok."""
         return Error(self._value)
 
-    def to_option(self) -> option.Option[_TSource]:
+    def to_option(self) -> Option[_TSource]:
         """Convert result to an option."""
-        return option.Some(self._value)
+        from expression.core.option import Some
+
+        return Some(self._value)
 
     def __match__(self, pattern: Any) -> Iterable[_TSource]:
         if self is pattern or self == pattern:
@@ -376,12 +382,14 @@ def dict(self) -> builtins.dict[str, Any]:
         return {"error": error}
 
     def swap(self) -> Result[_TError, _TSource]:
-        """Swaps the value in the result so an Ok becomes an Error and an Error becomes an Ok"""
+        """Swaps the value in the result so an Ok becomes an Error and an Error becomes an Ok."""
         return Ok(self._error)
 
-    def to_option(self) -> option.Option[_TSource]:
+    def to_option(self) -> Option[_TSource]:
         """Convert result to an option."""
-        return option.Nothing
+        from expression.core.option import Nothing
+
+        return Nothing
 
     def __eq__(self, o: Any) -> bool:
         if isinstance(o, Error):
@@ -471,26 +479,26 @@ def is_error(result: Result[_TSource, _TError]) -> TypeGuard[Error[_TSource, _TE
 
 
 def swap(result: Result[_TSource, _TError]) -> Result[_TError, _TSource]:
-    """Swaps the value in the result so an Ok becomes an Error and an Error becomes an Ok"""
+    """Swaps the value in the result so an Ok becomes an Error and an Error becomes an Ok."""
     return result.swap()
 
 
-def to_option(result: Result[_TSource, _TError]) -> option.Option[_TSource]:
+def to_option(result: Result[_TSource, _TError]) -> Option[_TSource]:
+    from expression.core.option import Nothing, Some
+
     match result:
         case Ok(value):
-            return option.Some(value)
+            return Some(value)
         case _:
-            return option.Nothing
+            return Nothing
 
 
-def of_option(
-    value: option.Option[_TSource], error: _TError
-) -> Result[_TSource, _TError]:
+def of_option(value: Option[_TSource], error: _TError) -> Result[_TSource, _TError]:
     return value.to_result(error)
 
 
 def of_option_with(
-    value: option.Option[_TSource], error: Callable[[], _TError]
+    value: Option[_TSource], error: Callable[[], _TError]
 ) -> Result[_TSource, _TError]:
     return value.to_result_with(error)