wird 1.1.0__tar.gz → 1.2.0__tar.gz

{wird-1.1.0 → wird-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wird
-Version: 1.1.0
+Version: 1.2.0
 Summary: Basic monads for implementing pipe-styled processing
 Project-URL: Repository, https://github.com/katunilya/wird
 Project-URL: Issues, https://github.com/katunilya/wird/issues
@@ -260,3 +260,83 @@ and returns internally stored `Maybe` instance.
 Also in some cases one might need point-free versions of `Maybe` interface methods, so
 one can access them via `maybe` module. For `FutureMaybe` point-free functions one can
 use `future_maybe` module.
+
+### `Result`
+
+Exception handling is one of the most important tasks in development. We often face
+cases when invocation of some logic can lead to Exception raise. In python default
+handling mechanism is `try` - `except` - `finally` block, which is actually just another
+for of `if` statement.
+
+Worst thing about this approach is that commonly in python the only way to know that
+function can raise an exception is documentation (which is not always written or written
+good). There is no explicit mechanism to tell LSP / type checker / linter, that this
+specific function needs exception handling.
+
+`Result` monad provides another approach, which is common for Rust and Go developers -
+let's return exceptions instead of raising them. Thus we can explicitly tell that soma
+action can fail and requires edge-case handling.
+
+Like `Maybe`, `Result` is just a protocol and has 2 implementations:
+
+- `Ok` - container indicating that calculation succeeded
+- `Err` - container indicating that calculation failed
+
+Simplest case of using `Result` is division:
+
+```python
+from wird import Result, Ok, Err
+
+def try_div(a: int, b: int) -> Result[float, ZeroDivisionError]:
+  if b == 0:
+    return Err(ZeroDivisionError())
+  
+  return Ok(a / b)
+```
+
+There we explicitly tell that division operation can lead to failure and even pinpoint
+specific type of error.
+
+`Result` provides the following interface:
+
+- `Result.unwrap` - extract internally stored value of `Ok` or raise `ErrUnwrapError`
+- `Result.unwrap_or` - extract internally stored value of `Ok` or return other
+- `Result.unwrap_or_else` - extract internally stored value of `Ok` or return closure
+  result
+- `Result.unwrap_or_else_async` - same as `Result.unwrap_or_else`, but for async
+  closures
+- `Result.unwrap_err` - same as `Result.unwrap`, but for `Err`
+- `Result.unwrap_err_or` - same as `Result.unwrap_err_or`, but for `Err`
+- `Result.unwrap_err_or_else` - same as `Result.unwrap_err_or_else`, but for `Err`
+- `Result.unwrap_err_or_else_async` - same as `Result.unwrap_err_or_else_async`, but for
+  `Err`
+- `Result.map` - binding method for `Ok`
+- `Result.map_async` - same as `Result.map`, but for async functions
+- `Result.inspect` - binding side-effect method for `Ok`
+- `Result.inspect_async`- same as `Result.inspect_async`, but for async functions
+- `Result.map_err` - same as `Result.map`, but for `Err`
+- `Result.map_err_async` - same as `Result.map_async`, but for `Err`
+- `Result.inspect_err` - same as `Result.inspect`, but for `Err`
+- `Result.inspect_err_async` - same as `Result.inspect_async`, but for `Err`
+- `Result.and_` - logical AND, replaces current `Result` with passed on `Ok`
+- `Result.and_then` - same as `Result.map`, but for functions returning `Result`
+- `Result.and_then_async` - same as `Result.and_then`, but for async functions
+- `Result.or_` - logical OR, replaces current `Result` with passed on `Err`
+- `Result.or_else` - same as `Result.map_err`, but for functions returning `Result`
+- `Result.or_else_async` - same as `Result.or_else`, but for async functions
+- `Result.is_ok` - `True` on `Ok`
+- `Result.is_ok_and` - `True` on `Ok` and predicate `True`
+- `Result.is_ok_and_async` - same as `Result.is_ok_and`, but for async predicate
+- `Result.is_ok_or` - `True` on `Ok` or `Err` predicate `True`
+- `Result.is_ok_or_async` - same as `Result.is_ok_or`, but for async predicate
+- `Result.is_err` - `True` on `Err`
+- `Result.is_err_and` - `True` on `Err` and predicate `True`
+- `Result.is_err_and_async` - same as `Result.is_err_and`, but for async predicate
+- `Result.is_err_or` - `True` on `Err` or `Ok` predicate `True
+- `Result.is_err_or_async` - same as `result.is_err_or`, but for async predicate
+
+In the same manner as with `Maybe` we wird provides:
+
+- `FutureResult` as seamless adapter for `Future[Result]`
+- point-free `Result` API in `wird.result` module
+- point-free `FutureResult` API in `wird.future_result` module

{wird-1.1.0 → wird-1.2.0}/README.md

@@ -249,3 +249,83 @@ and returns internally stored `Maybe` instance.
 Also in some cases one might need point-free versions of `Maybe` interface methods, so
 one can access them via `maybe` module. For `FutureMaybe` point-free functions one can
 use `future_maybe` module.
+
+### `Result`
+
+Exception handling is one of the most important tasks in development. We often face
+cases when invocation of some logic can lead to Exception raise. In python default
+handling mechanism is `try` - `except` - `finally` block, which is actually just another
+for of `if` statement.
+
+Worst thing about this approach is that commonly in python the only way to know that
+function can raise an exception is documentation (which is not always written or written
+good). There is no explicit mechanism to tell LSP / type checker / linter, that this
+specific function needs exception handling.
+
+`Result` monad provides another approach, which is common for Rust and Go developers -
+let's return exceptions instead of raising them. Thus we can explicitly tell that soma
+action can fail and requires edge-case handling.
+
+Like `Maybe`, `Result` is just a protocol and has 2 implementations:
+
+- `Ok` - container indicating that calculation succeeded
+- `Err` - container indicating that calculation failed
+
+Simplest case of using `Result` is division:
+
+```python
+from wird import Result, Ok, Err
+
+def try_div(a: int, b: int) -> Result[float, ZeroDivisionError]:
+  if b == 0:
+    return Err(ZeroDivisionError())
+  
+  return Ok(a / b)
+```
+
+There we explicitly tell that division operation can lead to failure and even pinpoint
+specific type of error.
+
+`Result` provides the following interface:
+
+- `Result.unwrap` - extract internally stored value of `Ok` or raise `ErrUnwrapError`
+- `Result.unwrap_or` - extract internally stored value of `Ok` or return other
+- `Result.unwrap_or_else` - extract internally stored value of `Ok` or return closure
+  result
+- `Result.unwrap_or_else_async` - same as `Result.unwrap_or_else`, but for async
+  closures
+- `Result.unwrap_err` - same as `Result.unwrap`, but for `Err`
+- `Result.unwrap_err_or` - same as `Result.unwrap_err_or`, but for `Err`
+- `Result.unwrap_err_or_else` - same as `Result.unwrap_err_or_else`, but for `Err`
+- `Result.unwrap_err_or_else_async` - same as `Result.unwrap_err_or_else_async`, but for
+  `Err`
+- `Result.map` - binding method for `Ok`
+- `Result.map_async` - same as `Result.map`, but for async functions
+- `Result.inspect` - binding side-effect method for `Ok`
+- `Result.inspect_async`- same as `Result.inspect_async`, but for async functions
+- `Result.map_err` - same as `Result.map`, but for `Err`
+- `Result.map_err_async` - same as `Result.map_async`, but for `Err`
+- `Result.inspect_err` - same as `Result.inspect`, but for `Err`
+- `Result.inspect_err_async` - same as `Result.inspect_async`, but for `Err`
+- `Result.and_` - logical AND, replaces current `Result` with passed on `Ok`
+- `Result.and_then` - same as `Result.map`, but for functions returning `Result`
+- `Result.and_then_async` - same as `Result.and_then`, but for async functions
+- `Result.or_` - logical OR, replaces current `Result` with passed on `Err`
+- `Result.or_else` - same as `Result.map_err`, but for functions returning `Result`
+- `Result.or_else_async` - same as `Result.or_else`, but for async functions
+- `Result.is_ok` - `True` on `Ok`
+- `Result.is_ok_and` - `True` on `Ok` and predicate `True`
+- `Result.is_ok_and_async` - same as `Result.is_ok_and`, but for async predicate
+- `Result.is_ok_or` - `True` on `Ok` or `Err` predicate `True`
+- `Result.is_ok_or_async` - same as `Result.is_ok_or`, but for async predicate
+- `Result.is_err` - `True` on `Err`
+- `Result.is_err_and` - `True` on `Err` and predicate `True`
+- `Result.is_err_and_async` - same as `Result.is_err_and`, but for async predicate
+- `Result.is_err_or` - `True` on `Err` or `Ok` predicate `True
+- `Result.is_err_or_async` - same as `result.is_err_or`, but for async predicate
+
+In the same manner as with `Maybe` we wird provides:
+
+- `FutureResult` as seamless adapter for `Future[Result]`
+- point-free `Result` API in `wird.result` module
+- point-free `FutureResult` API in `wird.future_result` module

{wird-1.1.0 → wird-1.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "wird"
-version = "1.1.0"
+version = "1.2.0"
 description = "Basic monads for implementing pipe-styled processing"
 readme = "README.md"
 requires-python = ">=3.13"
@@ -36,7 +36,13 @@ asyncio_mode = "auto"
 asyncio_default_fixture_loop_scope = "module"
 
 [tool.coverage.run]
-omit = ["tests/*", "wird/maybe.py", "wird/future_maybe.py"]
+omit = [
+    "tests/*",
+    "wird/maybe.py",
+    "wird/future_maybe.py",
+    "wird/result.py",
+    "wird/future_result.py",
+]
 branch = true
 
 [tool.coverage.report]

{wird-1.1.0 → wird-1.2.0}/tests/test_maybe.py

@@ -2,8 +2,7 @@ import operator
 
 import pytest
 
-from wird import Empty, Future, Maybe, Some
-from wird._maybe import EmptyUnwrapError, FutureMaybe
+from wird import Empty, EmptyUnwrapError, Future, FutureMaybe, Maybe, Some
 
 
 async def test_some_unwraps() -> None:

wird-1.2.0/tests/test_result.py

@@ -0,0 +1,331 @@
+import operator
+
+import pytest
+
+from wird import Err, ErrUnwrapError, Future, FutureResult, Ok, OkUnwrapError, Result
+
+
+async def test_ok_unwraps() -> None:
+    r = Ok(1).of_err_type(str)
+
+    assert r.unwrap() == 1
+    assert r.unwrap_or(2) == 1
+    assert r.unwrap_or_else(lambda: 2) == 1
+    assert await r.unwrap_or_else_async(lambda: Future.from_(2)) == 1
+
+    with pytest.raises(OkUnwrapError, match="expected Err, got Ok"):
+        r.unwrap_err()
+
+    with pytest.raises(OkUnwrapError, match="on ok"):
+        r.unwrap_err(on_ok="on ok")
+
+    assert r.unwrap_err_or("err") == "err"
+    assert r.unwrap_err_or_else(lambda: "err") == "err"
+    assert await r.unwrap_err_or_else_async(lambda: Future.from_("err")) == "err"
+
+    assert await FutureResult.from_(r).unwrap() == 1
+    assert await FutureResult.from_(r).unwrap_or(2) == 1
+    assert await FutureResult.from_(r).unwrap_or_else(lambda: 2) == 1
+    assert (
+        await FutureResult.from_(r).unwrap_or_else_async(lambda: Future.from_(2)) == 1
+    )
+
+    with pytest.raises(OkUnwrapError, match="expected Err, got Ok"):
+        await FutureResult.from_(r).unwrap_err()
+
+    with pytest.raises(OkUnwrapError, match="on ok"):
+        await FutureResult.from_(r).unwrap_err(on_ok="on ok")
+
+    assert await FutureResult.from_(r).unwrap_err_or("err") == "err"
+    assert await FutureResult.from_(r).unwrap_err_or_else(lambda: "err") == "err"
+    assert (
+        await FutureResult.from_(r).unwrap_err_or_else_async(
+            lambda: Future.from_("err")
+        )
+        == "err"
+    )
+
+
+async def test_err_unwraps() -> None:
+    r = Err("err").of_ok_type(int)
+
+    with pytest.raises(ErrUnwrapError, match="expected Ok, got Err"):
+        r.unwrap()
+
+    with pytest.raises(ErrUnwrapError, match="on err"):
+        r.unwrap(on_err="on err")
+
+    assert r.unwrap_or(2) == 2
+    assert r.unwrap_or_else(lambda: 2) == 2
+    assert await r.unwrap_or_else_async(lambda: Future.from_(2)) == 2
+
+    assert r.unwrap_err() == "err"
+    assert r.unwrap_err_or("error") == "err"
+    assert r.unwrap_err_or_else(lambda: "error") == "err"
+    assert await r.unwrap_err_or_else_async(lambda: Future.from_("error")) == "err"
+
+    with pytest.raises(ErrUnwrapError, match="expected Ok, got Err"):
+        await FutureResult.from_(r).unwrap()
+
+    with pytest.raises(ErrUnwrapError, match="on err"):
+        await FutureResult.from_(r).unwrap(on_err="on err")
+
+    assert await FutureResult.from_(r).unwrap_or(2) == 2
+    assert await FutureResult.from_(r).unwrap_or_else(lambda: 2) == 2
+    assert (
+        await FutureResult.from_(r).unwrap_or_else_async(lambda: Future.from_(2)) == 2
+    )
+
+    assert await FutureResult.from_(r).unwrap_err() == "err"
+    assert await FutureResult.from_(r).unwrap_err_or("error") == "err"
+    assert await FutureResult.from_(r).unwrap_err_or_else(lambda: "error") == "err"
+    assert (
+        await FutureResult.from_(r).unwrap_err_or_else_async(
+            lambda: Future.from_("error")
+        )
+        == "err"
+    )
+
+
+@pytest.mark.parametrize(
+    ("result", "target"),
+    [
+        (Ok(1), Ok(5)),
+        (Err(""), Err("")),
+    ],
+)
+async def test_result_map(
+    result: Result[int, str],
+    target: Result[int, str],
+) -> None:
+    assert (
+        await result.map(operator.add, 1)
+        .map_async(lambda x: Future.from_(x + 1))
+        .map(operator.add, 1)
+        .map_async(lambda x: Future.from_(x + 1))
+        == target
+    )
+
+
+@pytest.mark.parametrize(
+    ("result", "target"),
+    [
+        (Ok(""), Ok("")),
+        (Err(1), Err(5)),
+    ],
+)
+async def test_result_map_err(
+    result: Result[str, int],
+    target: Result[str, int],
+) -> None:
+    assert (
+        await result.map_err(operator.add, 1)
+        .map_err_async(lambda x: Future.from_(x + 1))
+        .map_err(operator.add, 1)
+        .map_err_async(lambda x: Future.from_(x + 1))
+        == target
+    )
+
+
+@pytest.mark.parametrize(
+    ("result", "target"),
+    [
+        (Ok({}), Ok({"a": 1, "b": 2, "c": 3, "d": 4})),
+        (Err(""), Err("")),
+    ],
+)
+async def test_result_inspect(
+    result: Result[dict, str],
+    target: Result[dict, str],
+) -> None:
+    async def set_item(data: dict, key: str, value: int) -> None:
+        data[key] = value
+
+    assert (
+        await result.inspect(operator.setitem, "a", 1)
+        .inspect_async(set_item, "b", 2)
+        .inspect(operator.setitem, "c", 3)
+        .inspect_async(set_item, "d", 4)
+    )
+
+
+@pytest.mark.parametrize(
+    ("result", "target"),
+    [
+        (Err({}), Err({"a": 1, "b": 2, "c": 3, "d": 4})),
+        (Ok(""), Ok("")),
+    ],
+)
+async def test_result_inspect_err(
+    result: Result[str, dict],
+    target: Result[str, dict],
+) -> None:
+    async def set_item(data: dict, key: str, value: int) -> None:
+        data[key] = value
+
+    assert (
+        await result.inspect_err(operator.setitem, "a", 1)
+        .inspect_err_async(set_item, "b", 2)
+        .inspect_err(operator.setitem, "c", 3)
+        .inspect_err_async(set_item, "d", 4)
+    ) == target
+
+
+async def test_ok_predicates() -> None:
+    r = Ok(1).of_err_type(str)
+
+    assert r.is_ok()
+    assert r.is_ok_and(lambda x: x % 2 == 1)
+    assert r.is_ok_or(lambda x: len(x) > 10)
+    assert await r.is_ok_and_async(lambda x: Future.from_(x % 2 == 1))
+    assert await r.is_ok_or_async(lambda x: Future.from_(len(x) > 10))
+
+    assert not r.is_err()
+    assert not r.is_err_and(lambda x: len(x) > 10)
+    assert r.is_err_or(lambda x: x % 2 == 1)
+    assert not await r.is_err_and_async(lambda x: Future.from_(len(x) > 10))
+    assert await r.is_err_or_async(lambda x: Future.from_(x % 2 == 1))
+
+    assert await FutureResult.from_(r).is_ok()
+    assert await FutureResult.from_(r).is_ok_and(lambda x: x % 2 == 1)
+    assert await FutureResult.from_(r).is_ok_or(lambda x: len(x) > 10)
+    assert await FutureResult.from_(r).is_ok_and_async(
+        lambda x: Future.from_(x % 2 == 1)
+    )
+    assert await FutureResult.from_(r).is_ok_or_async(
+        lambda x: Future.from_(len(x) > 10)
+    )
+
+    assert not await FutureResult.from_(r).is_err()
+    assert not await FutureResult.from_(r).is_err_and(lambda x: len(x) > 10)
+    assert await FutureResult.from_(r).is_err_or(lambda x: x % 2 == 1)
+    assert not await FutureResult.from_(r).is_err_and_async(
+        lambda x: Future.from_(len(x) > 10)
+    )
+    assert await FutureResult.from_(r).is_err_or_async(
+        lambda x: Future.from_(x % 2 == 1)
+    )
+
+
+async def test_err_predicates() -> None:
+    r = Err(1).of_ok_type(str)
+
+    assert not r.is_ok()
+    assert not r.is_ok_and(lambda x: len(x) > 10)
+    assert r.is_ok_or(lambda x: x % 2 == 1)
+    assert not await r.is_ok_and_async(lambda x: Future.from_(len(x) > 10))
+    assert await r.is_ok_or_async(lambda x: Future.from_(x % 2 == 1))
+
+    assert r.is_err()
+    assert r.is_err_and(lambda x: x % 2 == 1)
+    assert r.is_err_or(lambda x: len(x) > 10)
+    assert await r.is_err_and_async(lambda x: Future.from_(x % 2 == 1))
+    assert await r.is_err_or_async(lambda x: Future.from_(len(x) > 10))
+
+    assert not await FutureResult.from_(r).is_ok()
+    assert not await FutureResult.from_(r).is_ok_and(lambda x: len(x) > 10)
+    assert await FutureResult.from_(r).is_ok_or(lambda x: x % 2 == 1)
+    assert not await FutureResult.from_(r).is_ok_and_async(
+        lambda x: Future.from_(len(x) > 10)
+    )
+    assert await FutureResult.from_(r).is_ok_or_async(
+        lambda x: Future.from_(x % 2 == 1)
+    )
+
+    assert await FutureResult.from_(r).is_err()
+    assert await FutureResult.from_(r).is_err_and(lambda x: x % 2 == 1)
+    assert await FutureResult.from_(r).is_err_or(lambda x: len(x) > 10)
+    assert await FutureResult.from_(r).is_err_and_async(
+        lambda x: Future.from_(x % 2 == 1)
+    )
+    assert await FutureResult.from_(r).is_err_or_async(
+        lambda x: Future.from_(len(x) > 10)
+    )
+
+
+async def test_ok_and() -> None:
+    r = Ok(1).of_err_type(str)
+
+    assert r.and_(Ok(2)) == Ok(2)
+    assert r.and_(Err("")) == Err("")
+    assert r.and_then(lambda _: Ok(2)) == Ok(2)
+    assert r.and_then(lambda _: Err("")) == Err("")
+    assert await r.and_then_async(lambda _: Future.from_(Ok(2))) == Ok(2)
+    assert await r.and_then_async(lambda _: Future.from_(Err(""))) == Err("")
+
+    assert await FutureResult.from_(r).and_(Ok(2)) == Ok(2)
+    assert await FutureResult.from_(r).and_(Err("")) == Err("")
+    assert await FutureResult.from_(r).and_then(lambda _: Ok(2)) == Ok(2)
+    assert await FutureResult.from_(r).and_then(lambda _: Err("")) == Err("")
+    assert await FutureResult.from_(r).and_then_async(
+        lambda _: Future.from_(Ok(2))
+    ) == Ok(2)
+    assert await FutureResult.from_(r).and_then_async(
+        lambda _: Future.from_(Err(""))
+    ) == Err("")
+
+
+async def test_ok_or() -> None:
+    r = Ok(1).of_err_type(str)
+
+    assert r.or_(Ok(2)) == Ok(1)
+    assert r.or_(Err("")) == Ok(1)
+    assert r.or_else(lambda _: Ok(2)) == Ok(1)
+    assert r.or_else(lambda _: Err("")) == Ok(1)
+    assert await r.or_else_async(lambda _: Future.from_(Ok(2))) == Ok(1)
+    assert await r.or_else_async(lambda _: Future.from_(Err(""))) == Ok(1)
+
+    assert await FutureResult.from_(r).or_(Ok(2)) == Ok(1)
+    assert await FutureResult.from_(r).or_(Err("")) == Ok(1)
+    assert await FutureResult.from_(r).or_else(lambda _: Ok(2)) == Ok(1)
+    assert await FutureResult.from_(r).or_else(lambda _: Err("")) == Ok(1)
+    assert await FutureResult.from_(r).or_else_async(
+        lambda _: Future.from_(Ok(2))
+    ) == Ok(1)
+    assert await FutureResult.from_(r).or_else_async(
+        lambda _: Future.from_(Err(""))
+    ) == Ok(1)
+
+
+async def test_err_and() -> None:
+    r = Err(1).of_ok_type(str)
+
+    assert r.and_(Ok("ok")) == Err(1)
+    assert r.and_(Err(2)) == Err(1)
+    assert r.and_then(lambda _: Ok("ok")) == Err(1)
+    assert r.and_then(lambda _: Err(2)) == Err(1)
+    assert await r.and_then_async(lambda _: Future.from_(Ok("ok"))) == Err(1)
+    assert await r.and_then_async(lambda _: Future.from_(Err(2))) == Err(1)
+
+    assert await FutureResult.from_(r).and_(Ok("ok")) == Err(1)
+    assert await FutureResult.from_(r).and_(Err(2)) == Err(1)
+    assert await FutureResult.from_(r).and_then(lambda _: Ok("ok")) == Err(1)
+    assert await FutureResult.from_(r).and_then(lambda _: Err(2)) == Err(1)
+    assert await FutureResult.from_(r).and_then_async(
+        lambda _: Future.from_(Ok("ok"))
+    ) == Err(1)
+    assert await FutureResult.from_(r).and_then_async(
+        lambda _: Future.from_(Err(2))
+    ) == Err(1)
+
+
+async def test_err_or() -> None:
+    r = Err(1).of_ok_type(str)
+
+    assert r.or_(Ok("ok")) == Ok("ok")
+    assert r.or_(Err(2)) == Err(2)
+    assert r.or_else(lambda _: Ok("ok")) == Ok("ok")
+    assert r.or_else(lambda _: Err(2)) == Err(2)
+    assert await r.or_else_async(lambda _: Future.from_(Ok("ok"))) == Ok("ok")
+    assert await r.or_else_async(lambda _: Future.from_(Err(2))) == Err(2)
+
+    assert await FutureResult.from_(r).or_(Ok("ok")) == Ok("ok")
+    assert await FutureResult.from_(r).or_(Err(2)) == Err(2)
+    assert await FutureResult.from_(r).or_else(lambda _: Ok("ok")) == Ok("ok")
+    assert await FutureResult.from_(r).or_else(lambda _: Err(2)) == Err(2)
+    assert await FutureResult.from_(r).or_else_async(
+        lambda _: Future.from_(Ok("ok"))
+    ) == Ok("ok")
+    assert await FutureResult.from_(r).or_else_async(
+        lambda _: Future.from_(Err(2))
+    ) == Err(2)

{wird-1.1.0 → wird-1.2.0}/uv.lock

@@ -310,7 +310,7 @@ wheels = [
 
 [[package]]
 name = "wird"
-version = "1.1.0"
+version = "1.2.0"
 source = { editable = "." }
 
 [package.dev-dependencies]

{wird-1.1.0 → wird-1.2.0}/wird/__init__.py

@@ -1,16 +1,26 @@
 from . import maybe, future_maybe  # noqa
+from . import result, future_result
 from ._future import Future
 from ._maybe import Empty, EmptyUnwrapError, FutureMaybe, Maybe, Some
 from ._value import Value
+from ._result import Result, Err, Ok, FutureResult, OkUnwrapError, ErrUnwrapError
 
 __all__ = (
     "Empty",
     "EmptyUnwrapError",
+    "Err",
+    "ErrUnwrapError",
     "Future",
     "FutureMaybe",
+    "FutureResult",
     "Maybe",
+    "Ok",
+    "OkUnwrapError",
+    "Result",
     "Some",
     "Value",
     "future_maybe",
+    "future_result",
     "maybe",
+    "result",
 )

{wird-1.1.0 → wird-1.2.0}/wird/_maybe.py

@@ -6,6 +6,7 @@ from typing import (
     Awaitable,
     Callable,
     Concatenate,
+    Generator,
     NoReturn,
     Protocol,
     Type,
@@ -653,7 +654,7 @@ class FutureMaybe[T]:
     def from_[V](value: Maybe[V]) -> FutureMaybe[V]:
         return FutureMaybe(f.Future.from_(value))
 
-    def __await__(self) -> f.Generator[Any, Any, Maybe[T]]:
+    def __await__(self) -> Generator[Any, Any, Maybe[T]]:
         return self.internal.__await__()
 
     @overload