stdlibx-result 0.1.0__tar.gz

stdlibx_result-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Lucino772
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

stdlibx_result-0.1.0/PKG-INFO

@@ -0,0 +1,25 @@
+Metadata-Version: 2.4
+Name: stdlibx-result
+Version: 0.1.0
+Summary: stdlibx-result
+Author: Lucino772
+License-Expression: MIT
+License-File: LICENSE
+Requires-Dist: typing-extensions>=4.10.0,<5
+Requires-Python: >=3.9
+Project-URL: Documentation, http://stdlibx.lucapalmi.com/
+Project-URL: Repository, https://github.com/Lucino772/stdlibx
+Description-Content-Type: text/markdown
+
+[![docs](https://github.com/Lucino772/stdlibx/actions/workflows/deploy-docs.yaml/badge.svg?branch=main)](https://github.com/Lucino772/stdlibx/actions/workflows/deploy-docs.yaml)
+
+# stdlibx
+**stdlibx** is a collection of small, focused Python utilities that simplify common programming patterns and help you write clearer, more composable code.
+
+It provides practical tools for handling optional values, explicit error management, cancellation, composition, configuration, pattern matching, and reactive flows.
+
+## Documentation
+Checkout the [documentation](http://stdlibx.lucapalmi.com/)
+
+## Licence
+This project uses a **MIT** Licence [view](https://github.com/Lucino772/stdlibx/blob/main/LICENSE)

stdlibx_result-0.1.0/README.md

@@ -0,0 +1,12 @@
+[![docs](https://github.com/Lucino772/stdlibx/actions/workflows/deploy-docs.yaml/badge.svg?branch=main)](https://github.com/Lucino772/stdlibx/actions/workflows/deploy-docs.yaml)
+
+# stdlibx
+**stdlibx** is a collection of small, focused Python utilities that simplify common programming patterns and help you write clearer, more composable code.
+
+It provides practical tools for handling optional values, explicit error management, cancellation, composition, configuration, pattern matching, and reactive flows.
+
+## Documentation
+Checkout the [documentation](http://stdlibx.lucapalmi.com/)
+
+## Licence
+This project uses a **MIT** Licence [view](https://github.com/Lucino772/stdlibx/blob/main/LICENSE)

stdlibx_result-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[project]
+name = "stdlibx-result"
+version = "0.1.0"
+description = "stdlibx-result"
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+readme = "README.md"
+authors = [
+    { name = "Lucino772" }
+]
+requires-python = ">=3.9"
+dependencies = [
+    "typing_extensions>=4.10.0,<5"
+]
+
+[project.urls]
+Documentation = "http://stdlibx.lucapalmi.com/"
+Repository = "https://github.com/Lucino772/stdlibx"
+
+[tool.uv.build-backend]
+module-name = "stdlibx.result"
+
+[build-system]
+requires = ["uv_build>=0.9.28,<0.10.0"]
+build-backend = "uv_build"

stdlibx_result-0.1.0/src/stdlibx/result/__init__.py

@@ -0,0 +1,23 @@
+from stdlibx.result._errors import ResultError, ResultExpectError, ResultUnwrapError
+from stdlibx.result._result import (
+    Error,
+    Ok,
+    Result,
+    as_result,
+    is_err,
+    is_ok,
+    result_of,
+)
+
+__all__ = [
+    "Error",
+    "Ok",
+    "Result",
+    "ResultError",
+    "ResultExpectError",
+    "ResultUnwrapError",
+    "as_result",
+    "is_err",
+    "is_ok",
+    "result_of",
+]

stdlibx_result-0.1.0/src/stdlibx/result/_errors.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+
+class ResultError(Exception): ...
+
+
+class ResultUnwrapError(ResultError): ...
+
+
+class ResultExpectError(ResultError): ...

stdlibx_result-0.1.0/src/stdlibx/result/_result.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+from functools import wraps
+from typing import TYPE_CHECKING, Callable, Generic, Literal, TypeVar
+
+from typing_extensions import ParamSpec, TypeAlias, TypeGuard
+
+if TYPE_CHECKING:
+    from stdlibx.result._types import Operation
+
+T = TypeVar("T")
+E = TypeVar("E")
+U = TypeVar("U")
+P = ParamSpec("P")
+_AnyException = TypeVar("_AnyException", bound=Exception)
+
+Result: TypeAlias = "Ok[T, E] | Error[T, E]"
+
+
+def is_ok(result: Result[T, E]) -> TypeGuard[Ok[T, E]]:
+    return result.is_ok()
+
+
+def is_err(result: Result[T, E]) -> TypeGuard[Error[T, E]]:
+    return result.is_err()
+
+
+def result_of(
+    func: Callable[P, T], *args: P.args, **kwargs: P.kwargs
+) -> Result[T, Exception]:
+    try:
+        return Ok(func(*args, **kwargs))
+    except Exception as e:
+        return Error(e)
+
+
+def as_result(
+    func: Callable[P, T], exceptions: tuple[type[_AnyException], ...] = (Exception,)
+) -> Callable[P, Result[T, _AnyException]]:
+    @wraps(func)
+    def _wrapped(*args: P.args, **kwargs: P.kwargs) -> Result[T, _AnyException]:
+        try:
+            return Ok(func(*args, **kwargs))
+        except exceptions as e:
+            return Error(e)
+
+    return _wrapped
+
+
+class Ok(Generic[T, E]):
+    __match_args__ = ("value",)
+    __slots__ = ("value",)
+
+    value: T
+
+    def __init__(self, value: T) -> None:
+        self.value = value
+
+    def __repr__(self) -> str:
+        return f"Ok({self.value!r})"
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, Ok):
+            return other.value == self.value
+        return False
+
+    def is_ok(self) -> Literal[True]:
+        return True
+
+    def is_err(self) -> Literal[False]:
+        return False
+
+    def apply(self, operation: Operation[Result[T, E], U]) -> U:
+        return operation(self)
+
+
+class Error(Generic[T, E]):
+    __match_args__ = ("error",)
+    __slots__ = ("error",)
+
+    error: E
+
+    def __init__(self, error: E) -> None:
+        self.error = error
+
+    def __repr__(self) -> str:
+        return f"Error({self.error!r})"
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, Error):
+            return other.error == self.error
+        return False
+
+    def is_ok(self) -> Literal[False]:
+        return False
+
+    def is_err(self) -> Literal[True]:
+        return True
+
+    def apply(self, operation: Operation[Result[T, E], U]) -> U:
+        return operation(self)

stdlibx_result-0.1.0/src/stdlibx/result/_types.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from typing import Callable, TypeVar
+
+from typing_extensions import TypeAlias
+
+T = TypeVar("T")
+E = TypeVar("E")
+U = TypeVar("U")
+
+Operation: TypeAlias = Callable[[T], U]

stdlibx_result-0.1.0/src/stdlibx/result/fn/__init__.py

@@ -0,0 +1,57 @@
+from stdlibx.result.fn.base import (
+    and_,
+    and_then,
+    expect,
+    expect_err,
+    flatten,
+    inspect,
+    inspect_err,
+    is_err_and,
+    is_ok_and,
+    map_,
+    map_err,
+    map_or,
+    map_or_else,
+    or_,
+    or_else,
+    unwrap,
+    unwrap_err,
+    unwrap_or,
+    unwrap_or_else,
+    unwrap_or_raise,
+    zipped,
+)
+from stdlibx.result.fn.collect import collect, collect_all
+
+__all__ = [
+    "and_",
+    "and_then",
+    "collect",
+    "collect_all",
+    "expect",
+    "expect_err",
+    "flatten",
+    "inspect",
+    "inspect_err",
+    "is_err_and",
+    "is_ok_and",
+    "map_",
+    "map_err",
+    "map_or",
+    "map_or_else",
+    "or_",
+    "or_else",
+    "unwrap",
+    "unwrap_err",
+    "unwrap_or",
+    "unwrap_or_else",
+    "unwrap_or_raise",
+    "zipped",
+]
+
+try:
+    from stdlibx.result.fn.option import err, ok, transpose
+
+    __all__ += ["err", "ok", "transpose"]
+except ImportError:
+    pass

stdlibx_result-0.1.0/src/stdlibx/result/fn/base.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+from functools import partial
+from typing import TYPE_CHECKING, Callable, TypeVar, Union
+
+from stdlibx.result import Result, methods
+from typing_extensions import TypeVarTuple, Unpack
+
+if TYPE_CHECKING:
+    from stdlibx.result._types import Operation
+
+T = TypeVar("T")
+E = TypeVar("E")
+U = TypeVar("U")
+F = TypeVar("F")
+Ts = TypeVarTuple("Ts")
+_AnyException = TypeVar("_AnyException", bound=Exception)
+
+
+def is_ok_and(func: Callable[[T], bool]) -> Operation[Result[T, E], bool]:
+    return partial(methods.is_ok_and, func=func)
+
+
+def is_err_and(func: Callable[[E], bool]) -> Operation[Result[T, E], bool]:
+    return partial(methods.is_err_and, func=func)
+
+
+def map_(func: Callable[[T], U]) -> Operation[Result[T, E], Result[U, E]]:
+    return partial(methods.map_, func=func)
+
+
+def map_or(default: U, func: Callable[[T], U]) -> Operation[Result[T, E], U]:
+    return partial(methods.map_or, default=default, func=func)
+
+
+def map_or_else(
+    default: Callable[[E], U], func: Callable[[T], U]
+) -> Operation[Result[T, E], U]:
+    return partial(methods.map_or_else, default=default, func=func)
+
+
+def map_err(func: Callable[[E], F]) -> Operation[Result[T, E], Result[T, F]]:
+    return partial(methods.map_err, func=func)
+
+
+def inspect(func: Callable[[T], None]) -> Operation[Result[T, E], Result[T, E]]:
+    return partial(methods.inspect, func=func)
+
+
+def inspect_err(func: Callable[[E], None]) -> Operation[Result[T, E], Result[T, E]]:
+    return partial(methods.inspect_err, func=func)
+
+
+def expect(msg: str) -> Operation[Result[T, E], T]:
+    return partial(methods.expect, msg=msg)
+
+
+def unwrap() -> Operation[Result[T, E], T]:
+    return methods.unwrap
+
+
+def expect_err(msg: str) -> Operation[Result[T, E], E]:
+    return partial(methods.expect_err, msg=msg)
+
+
+def unwrap_err() -> Operation[Result[T, E], E]:
+    return methods.unwrap_err
+
+
+def and_(other: Result[U, F]) -> Operation[Result[T, E], Result[U, Union[E, F]]]:
+    return partial(methods.and_, other=other)
+
+
+def and_then(
+    func: Callable[[T], Result[U, F]],
+) -> Operation[Result[T, E], Result[U, Union[E, F]]]:
+    return partial(methods.and_then, func=func)
+
+
+def or_(default: Result[T, F]) -> Operation[Result[T, E], Result[T, F]]:
+    return partial(methods.or_, default=default)
+
+
+def or_else(
+    default: Callable[[E], Result[T, F]],
+) -> Operation[Result[T, E], Result[T, F]]:
+    return partial(methods.or_else, default=default)
+
+
+def unwrap_or(default: T) -> Operation[Result[T, E], T]:
+    return partial(methods.unwrap_or, default=default)
+
+
+def unwrap_or_else(default: Callable[[E], T]) -> Operation[Result[T, E], T]:
+    return partial(methods.unwrap_or_else, default=default)
+
+
+def unwrap_or_raise() -> Operation[Result[T, _AnyException], T]:
+    return methods.unwrap_or_raise
+
+
+def flatten() -> Operation[Result[Result[T, E], F], Result[T, Union[E, F]]]:
+    return methods.flatten
+
+
+def zipped(
+    func: Callable[[Unpack[Ts]], Result[U, E]],
+) -> Operation[Result[tuple[Unpack[Ts]], E], Result[tuple[Unpack[Ts], U], E]]:
+    return partial(methods.zipped, func=func)

stdlibx_result-0.1.0/src/stdlibx/result/fn/collect.py

@@ -0,0 +1,160 @@
+from __future__ import annotations
+
+import functools
+from typing import Any, Iterable, TypeVar, Union, overload
+
+from stdlibx.result._result import Error, Ok, Result, is_err
+
+T = TypeVar("T")
+E = TypeVar("E")
+
+T1 = TypeVar("T1")
+T2 = TypeVar("T2")
+T3 = TypeVar("T3")
+T4 = TypeVar("T4")
+T5 = TypeVar("T5")
+T6 = TypeVar("T6")
+T7 = TypeVar("T7")
+T8 = TypeVar("T8")
+T9 = TypeVar("T9")
+
+E1 = TypeVar("E1")
+E2 = TypeVar("E2")
+E3 = TypeVar("E3")
+E4 = TypeVar("E4")
+E5 = TypeVar("E5")
+E6 = TypeVar("E6")
+E7 = TypeVar("E7")
+E8 = TypeVar("E8")
+E9 = TypeVar("E9")
+
+
+@overload
+def collect(
+    a: Result[T1, E1],
+    b: Result[T2, E2],
+    /,
+) -> Result[tuple[T1, T2], Union[E1, E2]]: ...
+
+
+@overload
+def collect(
+    a: Result[T1, E1],
+    b: Result[T2, E2],
+    c: Result[T3, E3],
+    /,
+) -> Result[tuple[T1, T2, T3], Union[E1, E2, E3]]: ...
+
+
+@overload
+def collect(
+    a: Result[T1, E1],
+    b: Result[T2, E2],
+    c: Result[T3, E3],
+    d: Result[T4, E4],
+    /,
+) -> Result[tuple[T1, T2, T3, T4], Union[E1, E2, E3, E4]]: ...
+
+
+@overload
+def collect(
+    a: Result[T1, E1],
+    b: Result[T2, E2],
+    c: Result[T3, E3],
+    d: Result[T4, E4],
+    e: Result[T5, E5],
+    /,
+) -> Result[tuple[T1, T2, T3, T4, T5], Union[E1, E2, E3, E4, E5]]: ...
+
+
+@overload
+def collect(
+    a: Result[T1, E1],
+    b: Result[T2, E2],
+    c: Result[T3, E3],
+    d: Result[T4, E4],
+    e: Result[T5, E5],
+    f: Result[T6, E6],
+    /,
+) -> Result[tuple[T1, T2, T3, T4, T5, T6], Union[E1, E2, E3, E4, E5, E6]]: ...
+
+
+@overload
+def collect(
+    a: Result[T1, E1],
+    b: Result[T2, E2],
+    c: Result[T3, E3],
+    d: Result[T4, E4],
+    e: Result[T5, E5],
+    f: Result[T6, E6],
+    g: Result[T7, E7],
+    /,
+) -> Result[tuple[T1, T2, T3, T4, T5, T6, T7], Union[E1, E2, E3, E4, E5, E6, E7]]: ...
+
+
+@overload
+def collect(
+    a: Result[T1, E1],
+    b: Result[T2, E2],
+    c: Result[T3, E3],
+    d: Result[T4, E4],
+    e: Result[T5, E5],
+    f: Result[T6, E6],
+    g: Result[T7, E7],
+    h: Result[T8, E8],
+    /,
+) -> Result[
+    tuple[T1, T2, T3, T4, T5, T6, T7, T8],
+    Union[E1, E2, E3, E4, E5, E6, E7, E8],
+]: ...
+
+
+@overload
+def collect(
+    a: Result[T1, E1],
+    b: Result[T2, E2],
+    c: Result[T3, E3],
+    d: Result[T4, E4],
+    e: Result[T5, E5],
+    f: Result[T6, E6],
+    g: Result[T7, E7],
+    h: Result[T8, E8],
+    i: Result[T9, E9],
+    /,
+) -> Result[
+    tuple[T1, T2, T3, T4, T5, T6, T7, T8, T9],
+    Union[E1, E2, E3, E4, E5, E6, E7, E8, E9],
+]: ...
+
+
+def collect(
+    initial: Result[Any, Any],
+    *others: Result[Any, Any],
+) -> Result[tuple[Any, ...], Any]:
+    def _combine(
+        a: Result[tuple[Any, ...], Any],
+        b: Result[Any, Any],
+    ) -> Result[tuple[Any, ...], Any]:
+        if is_err(a):
+            return Error(a.error)
+        elif is_err(b):
+            return Error(b.error)
+        else:
+            return Ok(((*a.value, b.value)))  # type: ignore
+
+    return functools.reduce(_combine, [initial, *others], Ok(()))
+
+
+def collect_all(iterable: Iterable[Result[T, E]]) -> Result[tuple[T, ...], E]:
+    def _combine(
+        a: Result[tuple[T, ...], E],
+        b: Result[T, E],
+    ) -> Result[tuple[T, ...], E]:
+        if is_err(a):
+            return Error(a.error)
+        elif is_err(b):
+            return Error(b.error)
+        else:
+            return Ok(((*a.value, b.value)))  # type: ignore
+
+    return functools.reduce(_combine, iterable, Ok(()))

stdlibx_result-0.1.0/src/stdlibx/result/fn/option.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, TypeVar
+
+from stdlibx.result import Result, methods
+
+if TYPE_CHECKING:
+    from stdlibx.option import Option
+    from stdlibx.result._types import Operation
+
+T = TypeVar("T")
+E = TypeVar("E")
+U = TypeVar("U")
+
+
+def ok() -> Operation[Result[T, E], Option[T]]:
+    return methods.ok
+
+
+def err() -> Operation[Result[T, E], Option[E]]:
+    return methods.err
+
+
+def transpose() -> Operation[Result[Option[U], E], Option[Result[U, E]]]:
+    return methods.transpose

stdlibx_result-0.1.0/src/stdlibx/result/methods/__init__.py

@@ -0,0 +1,54 @@
+from stdlibx.result.methods.base import (
+    and_,
+    and_then,
+    expect,
+    expect_err,
+    flatten,
+    inspect,
+    inspect_err,
+    is_err_and,
+    is_ok_and,
+    map_,
+    map_err,
+    map_or,
+    map_or_else,
+    or_,
+    or_else,
+    unwrap,
+    unwrap_err,
+    unwrap_or,
+    unwrap_or_else,
+    unwrap_or_raise,
+    zipped,
+)
+
+__all__ = [
+    "and_",
+    "and_then",
+    "expect",
+    "expect_err",
+    "flatten",
+    "inspect",
+    "inspect_err",
+    "is_err_and",
+    "is_ok_and",
+    "map_",
+    "map_err",
+    "map_or",
+    "map_or_else",
+    "or_",
+    "or_else",
+    "unwrap",
+    "unwrap_err",
+    "unwrap_or",
+    "unwrap_or_else",
+    "unwrap_or_raise",
+    "zipped",
+]
+
+try:
+    from stdlibx.result.methods.option import err, ok, transpose
+
+    __all__ += ["err", "ok", "transpose"]
+except ImportError:
+    pass

stdlibx_result-0.1.0/src/stdlibx/result/methods/base.py

@@ -0,0 +1,150 @@
+from __future__ import annotations
+
+from typing import Callable, TypeVar, Union
+
+from stdlibx.result._errors import ResultExpectError, ResultUnwrapError
+from stdlibx.result._result import Error, Ok, Result, is_err, is_ok
+from typing_extensions import TypeVarTuple, Unpack
+
+T = TypeVar("T")
+E = TypeVar("E")
+U = TypeVar("U")
+F = TypeVar("F")
+Ts = TypeVarTuple("Ts")
+_AnyException = TypeVar("_AnyException", bound=Exception)
+
+
+def is_ok_and(result: Result[T, E], func: Callable[[T], bool]) -> bool:
+    return is_ok(result) and func(result.value)
+
+
+def is_err_and(result: Result[T, E], func: Callable[[E], bool]) -> bool:
+    return is_err(result) and func(result.error)
+
+
+def map_(result: Result[T, E], func: Callable[[T], U]) -> Result[U, E]:
+    if is_ok(result):
+        return Ok(func(result.value))
+    return Error(result.error)  # type: ignore
+
+
+def map_or(result: Result[T, E], default: U, func: Callable[[T], U]) -> U:
+    if is_ok(result):
+        return func(result.value)
+    return default
+
+
+def map_or_else(
+    result: Result[T, E], default: Callable[[E], U], func: Callable[[T], U]
+) -> U:
+    if is_ok(result):
+        return func(result.value)
+    return default(result.error)  # type: ignore
+
+
+def map_err(result: Result[T, E], func: Callable[[E], F]) -> Result[T, F]:
+    if is_err(result):
+        return Error(func(result.error))
+    return Ok(result.value)  # type: ignore
+
+
+def inspect(result: Result[T, E], func: Callable[[T], None]) -> Result[T, E]:
+    if is_ok(result):
+        func(result.value)
+    return result
+
+
+def inspect_err(result: Result[T, E], func: Callable[[E], None]) -> Result[T, E]:
+    if is_err(result):
+        func(result.error)
+    return result
+
+
+def expect(result: Result[T, E], msg: str) -> T:
+    if is_ok(result):
+        return result.value
+
+    _msg = f"{msg}: {result.error}"  # type: ignore
+    raise ResultExpectError(_msg)
+
+
+def unwrap(result: Result[T, E]) -> T:
+    if is_ok(result):
+        return result.value
+
+    _msg = f"{result.error}"  # type: ignore
+    raise ResultUnwrapError(_msg)
+
+
+def expect_err(result: Result[T, E], msg: str) -> E:
+    if is_err(result):
+        return result.error
+
+    _msg = f"{msg}: {result.value}"  # type: ignore
+    raise ResultExpectError(_msg)
+
+
+def unwrap_err(result: Result[T, E]) -> E:
+    if is_err(result):
+        return result.error
+
+    _msg = f"{result.value}"  # type: ignore
+    raise ResultUnwrapError(_msg)
+
+
+def and_(result: Result[T, E], other: Result[U, F]) -> Result[U, Union[E, F]]:
+    if is_ok(result):
+        return other  # type: ignore
+    return Error(result.error)  # type: ignore
+
+
+def and_then(
+    result: Result[T, E], func: Callable[[T], Result[U, F]]
+) -> Result[U, Union[E, F]]:
+    if is_ok(result):
+        return func(result.value)  # type: ignore
+    return Error(result.error)  # type: ignore
+
+
+def or_(result: Result[T, E], default: Result[T, F]) -> Result[T, F]:
+    if is_ok(result):
+        return Ok(result.value)
+    return default
+
+
+def or_else(result: Result[T, E], default: Callable[[E], Result[T, F]]) -> Result[T, F]:
+    if is_err(result):
+        return default(result.error)
+    return Ok(result.value)  # type: ignore
+
+
+def unwrap_or(result: Result[T, E], default: T) -> T:
+    if is_ok(result):
+        return result.value
+    return default
+
+
+def unwrap_or_else(result: Result[T, E], default: Callable[[E], T]) -> T:
+    if is_ok(result):
+        return result.value
+    return default(result.error)  # type: ignore
+
+
+def unwrap_or_raise(result: Result[T, _AnyException]) -> T:
+    if is_ok(result):
+        return result.value
+    raise result.error  # type: ignore
+
+
+def flatten(result: Result[Result[T, E], F]) -> Result[T, Union[E, F]]:
+    if is_ok(result):
+        return result.value  # type: ignore
+    return Error(result.error)  # type: ignore
+
+
+def zipped(
+    result: Result[tuple[Unpack[Ts]], E], func: Callable[[Unpack[Ts]], Result[U, E]]
+) -> Result[tuple[Unpack[Ts], U], E]:
+    if is_ok(result):
+        return map_(func(*result.value), lambda val: (*result.value, val))
+    return Error(result.error)  # type: ignore

stdlibx_result-0.1.0/src/stdlibx/result/methods/option.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from typing import TypeVar
+
+from stdlibx.option import Nothing, Option, Some, is_some
+from stdlibx.result._result import Error, Ok, Result, is_err, is_ok
+
+T = TypeVar("T")
+E = TypeVar("E")
+U = TypeVar("U")
+
+
+def ok(result: Result[T, E]) -> Option[T]:
+    if is_ok(result):
+        return Some(result.value)
+    return Nothing()
+
+
+def err(result: Result[T, E]) -> Option[E]:
+    if is_err(result):
+        return Some(result.error)
+    return Nothing()
+
+
+def transpose(result: Result[Option[U], E]) -> Option[Result[U, E]]:
+    if is_ok(result) and is_some(result.value):
+        return Some(Ok(result.value.value))
+    elif is_err(result):
+        return Some(Error(result.error))
+    else:
+        return Nothing()