funstruct 1.0.0__tar.gz → 1.0.2__tar.gz

funstruct-1.0.2/.github/workflows/docs.yml

@@ -0,0 +1,31 @@
+name: Docs
+
+on:
+  push:
+    branches: [main]
+  release:
+    types: [published]
+
+permissions:
+  contents: write
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+      - uses: astral-sh/setup-uv@v7
+      - run: uv sync --group docs
+      - name: Deploy docs
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          if [ "${{ github.event_name }}" = "release" ]; then
+            VERSION=${{ github.event.release.tag_name }}
+          else
+            VERSION=dev
+          fi
+          uv run mike deploy "$VERSION" latest --update-aliases --push
+          uv run mike set-default latest --push

{funstruct-1.0.0 → funstruct-1.0.2}/PKG-INFO

@@ -1,8 +1,9 @@
 Metadata-Version: 2.5
 Name: funstruct
-Version: 1.0.0
+Version: 1.0.2
 Summary: Fun & functional structures for Python
-Project-URL: Homepage, https://github.com/veyga/funstruct
+Project-URL: Homepage, https://veyga.github.io/funstruct/
+Project-URL: Documentation, https://veyga.github.io/funstruct/
 Project-URL: Repository, https://github.com/veyga/funstruct
 Author-email: Andrew Stefanich <andrewstefanich@gmail.com>
 License: MIT
@@ -99,6 +100,7 @@ class Monad(Applicative):
     def __rshift__ = bind  # >>
 
 class MonadTransformer(Monad, Generic[_F, _A]):
+    def lift_f(cls, inner: _F) -> MonadTransformer: ...
     def and_then(self, other) -> MonadTransformer: ...
 ```
 

{funstruct-1.0.0 → funstruct-1.0.2}/README.md

@@ -86,6 +86,7 @@ class Monad(Applicative):
     def __rshift__ = bind  # >>
 
 class MonadTransformer(Monad, Generic[_F, _A]):
+    def lift_f(cls, inner: _F) -> MonadTransformer: ...
     def and_then(self, other) -> MonadTransformer: ...
 ```
 

{funstruct-1.0.0 → funstruct-1.0.2}/funstruct/applicative/validated.py

@@ -17,6 +17,10 @@ from __future__ import annotations
 from abc import abstractmethod
 from collections.abc import Callable
 from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from funstruct.monad.result import Result
 from typing import Generic, TypeVar
 
 from funstruct.collections.cons import Cons
@@ -33,6 +37,9 @@ class Validated(Applicative):
     @abstractmethod
     def ap(self, other) -> Validated: ...
 
+    def __add__(self, other) -> Validated:
+        return self.ap(other)
+
     @property
     @abstractmethod
     def is_valid(self) -> bool: ...
@@ -42,6 +49,12 @@ class Validated(Applicative):
         """Eliminate the Validated — apply on_invalid or on_valid."""
         ...
 
+    @abstractmethod
+    def to_result(self) -> Result: ...
+
+    @abstractmethod
+    def to_result_or(self, exc_cls, combine=None) -> Result: ...
+
     @classmethod
     def pure(cls, value) -> Validated:
         """Lift a value into Valid."""

{funstruct-1.0.0 → funstruct-1.0.2}/funstruct/monad/result.py

@@ -35,14 +35,16 @@ Examples:
 from __future__ import annotations
 
 import inspect
-from collections.abc import Awaitable, Callable
+from abc import abstractmethod
+from collections.abc import Awaitable, Callable, Coroutine
 from dataclasses import dataclass
 from functools import wraps
-from typing import Any, Generic, ParamSpec, TypeVar
+from typing import Any, Generic, ParamSpec, TypeVar, overload
 
 from funstruct.monad.either import Either, Left, Right
 
 _A = TypeVar("_A")
+_B = TypeVar("_B")
 
 
 class Result(Either[Exception, _A], Generic[_A]):
@@ -52,19 +54,32 @@ class Result(Either[Exception, _A], Generic[_A]):
     Same as Either[Exception, A] but with 1 param for cleaner annotations.
     """
 
-    pass
+    @abstractmethod
+    def map(self, f: Callable[[_A], _B]) -> Result[_B]: ...
+    @abstractmethod
+    def bind(self, f: Callable[[_A], Result[_B]]) -> Result[_B]: ...
+    @abstractmethod
+    def alt(self, f: Callable[[Exception], Exception]) -> Result[_A]: ...
+    @abstractmethod
+    def or_else(self, f: Callable[[Exception], Result[_A]]) -> Result[_A]: ...
 
 
 @dataclass(frozen=True, eq=False)
 class Ok(Right):
     """Success case of Result."""
 
-    def map(self, f: Callable) -> Either:
+    def map(self, f: Callable[[_A], _B]) -> Result[_B]:
         return Ok(f(self.value))
 
-    def bind(self, f: Callable) -> Either:
+    def bind(self, f: Callable[[_A], Result[_B]]) -> Result[_B]:
         return f(self.value)
 
+    def alt(self, f: Callable[[Exception], Exception]) -> Result[_A]:
+        return self
+
+    def or_else(self, f: Callable[[Exception], Result[_A]]) -> Result[_A]:
+        return self
+
     def __repr__(self) -> str:
         return f"Ok({repr(self.value)})"
 
@@ -73,10 +88,16 @@ class Ok(Right):
 class Err(Left):
     """Error case of Result."""
 
-    def alt(self, f: Callable) -> Either:
+    def map(self, f: Callable[[_A], _B]) -> Result[_B]:
+        return self
+
+    def bind(self, f: Callable[[_A], Result[_B]]) -> Result[_B]:
+        return self
+
+    def alt(self, f: Callable[[Exception], Exception]) -> Result[_A]:
         return Err(f(self.error))
 
-    def or_else(self, f: Callable) -> Either:
+    def or_else(self, f: Callable[[Exception], Result[_A]]) -> Result[_A]:
         return f(self.error)
 
     def __repr__(self) -> str:
@@ -96,7 +117,7 @@ class AsyncResult(Generic[_A]):
 
     __slots__ = ("_coro",)
 
-    def __init__(self, coro: Awaitable[Either[Exception, _A]]) -> None:
+    def __init__(self, coro: Awaitable[Result[_A]]) -> None:
         self._coro = coro
 
     def __del__(self):
@@ -106,10 +127,10 @@ class AsyncResult(Generic[_A]):
     def __await__(self):
         return self._awaitable().__await__()
 
-    async def _awaitable(self) -> Either[Exception, _A]:
+    async def _awaitable(self) -> Result[_A]:
         return await self._coro
 
-    def map(self, f: Callable[[_A], Any]) -> AsyncResult:
+    def map(self, f: Callable[[_A], _B]) -> AsyncResult[_B]:
         """Transform the success value without executing."""
 
         async def _inner():
@@ -118,11 +139,11 @@ class AsyncResult(Generic[_A]):
 
         return AsyncResult(_inner())
 
-    def bind(self, f: Callable) -> AsyncResult:
+    def bind(self, f: Callable[[_A], Any]) -> AsyncResult:
         """Chain: f receives value. Short-circuits on Err.
 
         Handles all return types from f:
-        - AsyncResult[B] → awaited, produces Either
+        - AsyncResult[B] → awaited, produces Result
         - Either[E, B] / Result[B] → used directly
         - Awaitable[B] → awaited, plain value wrapped in Ok
         - Plain B → wrapped in Ok
@@ -143,7 +164,7 @@ class AsyncResult(Generic[_A]):
 
         return AsyncResult(_inner())
 
-    def alt(self, f: Callable) -> AsyncResult:
+    def alt(self, f: Callable[[Exception], Exception]) -> AsyncResult[_A]:
         """Transform the error without recovering."""
 
         async def _inner():
@@ -156,11 +177,11 @@ class AsyncResult(Generic[_A]):
 
         return AsyncResult(_inner())
 
-    def or_else(self, f: Callable) -> AsyncResult:
+    def or_else(self, f: Callable[[Exception], Any]) -> AsyncResult:
         """Recover from error: f receives error. Short-circuits on success.
 
         Handles all return types from f:
-        - AsyncResult[A] → awaited, produces Either
+        - AsyncResult[A] → awaited, produces Result
         - Either[E, A] / Result[A] → used directly
         - Awaitable[A] → awaited, plain value wrapped in Ok
         - Plain A → wrapped in Ok
@@ -181,11 +202,11 @@ class AsyncResult(Generic[_A]):
 
         return AsyncResult(_inner())
 
-    def then(self, next_result: AsyncResult) -> AsyncResult:
+    def then(self, next_result: AsyncResult[_B]) -> AsyncResult[_B]:
         """Sequence: run self, discard value, run next."""
         return self.bind(lambda _: next_result)
 
-    def ap(self, other: AsyncResult) -> AsyncResult:
+    def ap(self, other: AsyncResult[_B]) -> AsyncResult[tuple[_A, _B]]:
         """Applicative: run both, tuple the values."""
         return self.bind(lambda a: other.map(lambda b: (a, b)))
 
@@ -239,6 +260,14 @@ def Try(
     return wrapper
 
 
+@overload
+def TryAsync(
+    f: Callable[_P, Coroutine[Any, Any, _A]],
+) -> Callable[_P, AsyncResult[_A]]: ...
+@overload
+def TryAsync(
+    f: Callable[_P, _A],
+) -> Callable[_P, AsyncResult[_A]]: ...
 def TryAsync(
     f: Callable[_P, _A],
 ) -> Callable[_P, AsyncResult[_A]]:

{funstruct-1.0.0 → funstruct-1.0.2}/mkdocs.yml

@@ -54,6 +54,10 @@ nav:
   - util:
       - tailrec: util/tailrec.md
 
+extra:
+  version:
+    provider: mike
+
 plugins:
   - search
   - mkdocstrings:

{funstruct-1.0.0 → funstruct-1.0.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "funstruct"
-version = "1.0.0"
+version = "1.0.2"
 description = "Fun & functional structures for Python"
 authors = [{name = "Andrew Stefanich", email = "andrewstefanich@gmail.com"}]
 license = {text = "MIT"}
@@ -10,7 +10,8 @@ keywords = ["functional", "immutable", "fp", "data structures", "cons"]
 dependencies = []
 
 [project.urls]
-Homepage = "https://github.com/veyga/funstruct"
+Homepage = "https://veyga.github.io/funstruct/"
+Documentation = "https://veyga.github.io/funstruct/"
 Repository = "https://github.com/veyga/funstruct"
 
 [build-system]

{funstruct-1.0.0 → funstruct-1.0.2}/uv.lock

@@ -476,7 +476,7 @@ wheels = [
 
 [[package]]
 name = "funstruct"
-version = "1.0.0"
+version = "1.0.2"
 source = { editable = "." }
 
 [package.dev-dependencies]

funstruct-1.0.2/uv.toml

@@ -0,0 +1,3 @@
+[[index]]
+url = "https://pypi.org/simple/"
+default = true