Added some methods and functions to option and result

* Convert `Option`s to `Result`s and vice versa
* Added `Option#to_optional` for easy convertion to Python's `Optional[T]`
* Added a `Result#swap` method
* Added tests for all of the above

Also:
* Fixed some documentation for `Result#default_values` and `Result#default_with`

Author: brendanmaguire

expression/core/option.py

@@ -28,13 +28,15 @@
 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 ..collections.seq import Seq
 
 _TSource = TypeVar("_TSource")
 _TResult = TypeVar("_TResult")
+_TError = TypeVar("_TError")
 
 _T1 = TypeVar("_T1")
 _T2 = TypeVar("_T2")
@@ -156,6 +158,26 @@ def of_optional(cls, value: Optional[_TSource]) -> Option[_TSource]:
         """Convert optional value to an option."""
         return of_optional(value)
 
+    @classmethod
+    def of_result(cls, result: Result[_TSource, _TError]) -> Option[_TSource]:
+        """Convert result to an option."""
+        return of_result(result)
+
+    @abstractmethod
+    def to_optional(self) -> Optional[_TSource]:
+        """Convert option to an optional."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def to_result(self, error: _TError) -> Result[_TSource, _TError]:
+        """Convert option to a result."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def to_result_with(self, error: Callable[[], _TError]) -> Result[_TSource, _TError]:
+        """Convert option to a result."""
+        raise NotImplementedError
+
     @abstractmethod
     def dict(self) -> _TSource | Dict[str, Any]:
         """Returns a json string representation of the option."""
@@ -272,6 +294,18 @@ def to_seq(self) -> Seq[_TSource]:
 
         return Seq.of(self._value)
 
+    def to_optional(self) -> Optional[_TSource]:
+        """Convert option to an optional."""
+        return self._value
+
+    def to_result(self, error: _TError) -> Result[_TSource, _TError]:
+        """Convert option to a result."""
+        return Ok(self._value)
+
+    def to_result_with(self, error: Callable[[], _TError]) -> Result[_TSource, _TError]:
+        """Convert option to a result."""
+        return Ok(self._value)
+
     def dict(self) -> _TSource:
         attr = getattr(self._value, "dict", None) or getattr(self._value, "dict", None)
         if attr and callable(attr):
@@ -384,6 +418,18 @@ def to_seq(self) -> Seq[_TSource]:
 
         return Seq()
 
+    def to_optional(self) -> Optional[_TSource]:
+        """Convert option to an optional."""
+        return None
+
+    def to_result(self, error: _TError) -> Result[_TSource, _TError]:
+        """Convert option to a result."""
+        return Error(error)
+
+    def to_result_with(self, error: Callable[[], _TError]) -> Result[_TSource, _TError]:
+        """Convert option to a result."""
+        return Error(error())
+
     def dict(self) -> Dict[str, Any]:
         return {}  # Pydantic cannot handle None or other types than Optional
 
@@ -518,12 +564,21 @@ def to_seq(option: Option[_TSource]) -> Seq[_TSource]:
     return option.to_seq()
 
 
+def to_optional(value: Option[_TSource]) -> Optional[_TSource]:
+    """Convert an option value to an optional.
+
+    Args:
+        value: The input option value.
+
+    Return:
+        The result optional.
+    """
+    return value.to_optional()
+
+
 def of_optional(value: Optional[_TSource]) -> Option[_TSource]:
     """Convert an optional value to an option.
 
-    Convert a value that could be `None` into an `Option` value. Same as
-    `of_obj` but with typed values.
-
     Args:
         value: The input optional value.
 
@@ -550,6 +605,24 @@ def of_obj(value: Any) -> Option[Any]:
     return of_optional(value)
 
 
+def of_result(result: Result[_TSource, _TError]) -> Option[_TSource]:
+    match result:
+        case Ok(value):
+            return Some(value)
+        case _:
+            return Nothing
+
+
+def to_result(value: Option[_TSource], error: _TError) -> Result[_TSource, _TError]:
+    return value.to_result(error)
+
+
+def to_result_with(
+    value: Option[_TSource], error: Callable[[], _TError]
+) -> Result[_TSource, _TError]:
+    return value.to_result_with(error)
+
+
 def dict(value: Option[_TSource]) -> _TSource | Dict[Any, Any] | None:
     return value.dict()
 
@@ -583,6 +656,9 @@ def default_arg(value: Option[_TSource], default_value: _TSource) -> _TSource:
     "to_list",
     "dict",
     "to_seq",
+    "to_optional",
     "of_optional",
+    "to_result",
+    "of_result",
     "of_obj",
 ]

expression/core/result.py

@@ -28,6 +28,7 @@
 
 from typing_extensions import TypeAlias, TypeGuard
 
+from . import option
 from .curry import curry_flip
 from .error import EffectError
 from .pipe import PipeMixin
@@ -81,7 +82,7 @@ class BaseResult(
     def default_value(self, value: _TSource) -> _TSource:
         """Get with default value.
 
-        Gets the value of the option if the option is Some, otherwise
+        Gets the value of the result if the result is Ok, otherwise
         returns the specified default value.
         """
         raise NotImplementedError
@@ -90,7 +91,7 @@ def default_value(self, value: _TSource) -> _TSource:
     def default_with(self, getter: Callable[[_TError], _TSource]) -> _TSource:
         """Get with default value lazily.
 
-        Gets the value of the option if the option is Some, otherwise
+        Gets the value of the result if the result is Ok, otherwise
         returns the value produced by the getter
         """
         raise NotImplementedError
@@ -138,6 +139,30 @@ def dict(self) -> Dict[str, Union[_TSource, _TError]]:
         """Returns a json serializable representation of the result."""
         raise NotImplementedError
 
+    @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"""
+        raise NotImplementedError
+
+    @abstractmethod
+    def to_option(self) -> option.Option[_TSource]:
+        """Convert result to an option."""
+        raise NotImplementedError
+
+    @classmethod
+    def of_option(
+        cls, value: option.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]
+    ) -> Result[_TSource, _TError]:
+        """Convert option to a result."""
+        return of_option_with(value, error)
+
     def __eq__(self, o: Any) -> bool:
         raise NotImplementedError
 
@@ -229,6 +254,14 @@ def dict(self) -> 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"""
+        return Error(self._value)
+
+    def to_option(self) -> option.Option[_TSource]:
+        """Convert result to an option."""
+        return option.Some(self._value)
+
     def __match__(self, pattern: Any) -> Iterable[_TSource]:
         if self is pattern or self == pattern:
             return [self.value]
@@ -338,6 +371,14 @@ def dict(self) -> 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"""
+        return Ok(self._error)
+
+    def to_option(self) -> option.Option[_TSource]:
+        """Convert result to an option."""
+        return option.Nothing
+
     def __eq__(self, o: Any) -> bool:
         if isinstance(o, Error):
             return self.error == o.error  # type: ignore
@@ -361,7 +402,7 @@ def __hash__(self) -> int:
 
 
 def default_value(value: _TSource) -> Callable[[Result[_TSource, Any]], _TSource]:
-    """Gets the value of the option if the option is Some, otherwise
+    """Gets the value of the result if the result is Ok, otherwise
     returns the specified default value.
     """
 
@@ -426,6 +467,31 @@ def is_error(result: Result[_TSource, _TError]) -> TypeGuard[Error[_TSource, _TE
     return result.is_error()
 
 
+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"""
+    return result.swap()
+
+
+def to_option(result: Result[_TSource, _TError]) -> option.Option[_TSource]:
+    match result:
+        case Ok(value):
+            return option.Some(value)
+        case _:
+            return option.Nothing
+
+
+def of_option(
+    value: option.Option[_TSource], error: _TError
+) -> Result[_TSource, _TError]:
+    return value.to_result(error)
+
+
+def of_option_with(
+    value: option.Option[_TSource], error: Callable[[], _TError]
+) -> Result[_TSource, _TError]:
+    return value.to_result_with(error)
+
+
 Result: TypeAlias = Union[Ok[_TSource, _TError], Error[_TSource, _TError]]
 
 __all__ = [
@@ -439,4 +505,7 @@ def is_error(result: Result[_TSource, _TError]) -> TypeGuard[Error[_TSource, _TE
     "dict",
     "is_ok",
     "is_error",
+    "to_option",
+    "of_option",
+    "of_option_with",
 ]

tests/test_option.py

@@ -6,7 +6,18 @@
 from pydantic import BaseModel
 from tests.utils import CustomException
 
-from expression import Nothing, Option, Some, effect, option, pipe, pipe2
+from expression import (
+    Error,
+    Nothing,
+    Ok,
+    Option,
+    Result,
+    Some,
+    effect,
+    option,
+    pipe,
+    pipe2,
+)
 from expression.core.option import BaseOption, Nothing_
 from expression.extra.option import pipeline
 
@@ -321,6 +332,50 @@ def test_option_of_object_value():
     assert xs.is_some()
 
 
+def test_option_of_result_ok():
+    result: Result[int, Any] = Ok(42)
+    xs = option.of_result(result)
+    assert xs.is_some()
+
+
+def test_option_of_result_error():
+    xs: Option[int] = option.of_result(Error("oops"))
+    assert xs.is_none()
+
+
+def test_option_to_result_ok():
+    xs = option.to_result(Some(42), "oops")
+    assert xs == Ok(42)
+
+
+def test_option_to_result_error():
+    xs = option.to_result(Nothing, "oops")
+    assert xs == Error("oops")
+
+
+def test_option_to_result_with_ok():
+    def raise_error() -> Any:
+        raise Exception("Should not be called")
+
+    xs = option.to_result_with(Some(42), error=raise_error)
+    assert xs == Ok(42)
+
+
+def test_option_to_result_with_error():
+    xs = option.to_result_with(Nothing, error=lambda: "oops")
+    assert xs == Error("oops")
+
+
+def test_option_to_optional_some():
+    xs = option.to_optional(Some(1))
+    assert xs == 1
+
+
+def test_option_to_optional_nothing():
+    xs = option.to_optional(Nothing)
+    assert xs is None
+
+
 def test_option_builder_zero():
     @effect.option[int]()
     def fn():