pythonic-fp-fptools 6.0.0__tar.gz → 6.1.0__tar.gz

{pythonic_fp_fptools-6.0.0 → pythonic_fp_fptools-6.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythonic-fp-fptools
-Version: 6.0.0
+Version: 6.1.0
 Summary: Functional programming tools for Python.
 Keywords: either,fp,functional,functional programming,lazy,maybe,monad,non-strict
 Author-email: "Geoffrey R. Scheller" <geoffrey@scheller.com>
@@ -15,9 +15,9 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: 3.15
 Classifier: Typing :: Typed
 License-File: LICENSE
-Requires-Dist: pythonic-fp-booleans>=3.0.2
-Requires-Dist: pythonic-fp-circulararray>=6.0.4
-Requires-Dist: pythonic-fp-gadgets>=4.0.2
+Requires-Dist: pythonic-fp-booleans>=5,<6
+Requires-Dist: pythonic-fp-circulararray>=6.2.2,<6.4
+Requires-Dist: pythonic-fp-gadgets>=4.5.0,<6
 Project-URL: Changelog, https://github.com/grscheller/pythonic-fp-fptools/blob/main/CHANGELOG.md
 Project-URL: Documentation, https://grscheller.github.io/pythonic-fp-fptools/release/html/
 Project-URL: Homepage, https://grscheller.github.io/pythonic-fp/

{pythonic_fp_fptools-6.0.0 → pythonic_fp_fptools-6.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "flit_core.buildapi"
 
 [project]
 name = "pythonic-fp-fptools"
-version = "6.0.0"
+version = "6.1.0"
 description = "Functional programming tools for Python."
 readme = "README.md"
 requires-python = ">=3.14"  # floor: PEP 649/749 deferred annotations — class-level self-reference NameErrors on <3.14
@@ -32,9 +32,9 @@ classifiers = [
   "Typing :: Typed",
 ]
 dependencies = [
-  "pythonic-fp-booleans>=3.0.2",
-  "pythonic-fp-circulararray>=6.0.4",
-  "pythonic-fp-gadgets>=4.0.2",
+  "pythonic-fp-booleans>=5,<6",
+  "pythonic-fp-circulararray>=6.2.2,<6.4",
+  "pythonic-fp-gadgets>=4.5.0,<6",
 ]
 
 [project.urls]
@@ -50,9 +50,6 @@ docs = [
 ]
 test = [
   "pytest>=8.4.1",
-  "pythonic-fp-containers>=4.0.1",
-  "pythonic-fp-iterables>=5.1.3",
-  "pythonic-fp-queues>=5.1.1",
 ]
 
 [tool.flit.module]

{pythonic_fp_fptools-6.0.0 → pythonic_fp_fptools-6.1.0}/src/pythonic_fp/fptools/state.py

@@ -41,8 +41,9 @@ class State[S, A]:
                 Instance members:
 
                 - Property *run* is the **state action**
-                - Method *bind* performs state action composition
-                - Method *eval* performs the **run action**
+                - Method ``bind`` performs state action composition
+                - Method ``then`` performs 
+                - Method ``eval`` performs the **run action**
 
                   - the **run action** evaluates the **state action** by
 
@@ -78,16 +79,37 @@ class State[S, A]:
         """
         self.run = run
 
+    def eval(self, init: S) -> A:
+        """
+        .. admonition:: run action
+
+            Evaluate the state action by passing in an initial state
+            and returning the produced value.
+
+            :param init: An initial state to pass into the state action.
+            :returns: The value produced by the run action.
+
+        """
+        a, _ = self.run(init)
+        return a
+
     def bind[B](self, g: Callable[[A], State[S, B]]) -> State[S, B]:
         """
         .. admonition:: state action composition
 
+            Run the first action, use its result to compose
+            a new state action.
+
             :param g: A function that produces a State[S, B]
                       from an A.
             :returns: A State[S, B] whose state action is the
                       composition of the state actions from self
                       followed by the one produced by g.
 
+            .. note::
+
+                Same as the Haskell ``>>=`` operator.
+
         """
 
         def compose(s: S) -> tuple[B, S]:
@@ -96,19 +118,19 @@ class State[S, A]:
 
         return State(compose)
 
-    def eval(self, init: S) -> A:
+    def then[B](self, sb: State[S, B]) -> State[S, B]:
         """
-        .. admonition:: run action
+        .. admonition:: sequence two state actions
 
-            Evaluate the state action by passing in an initial state
-            and returning the produced value.
+            Run the first action, discard its result,
+            then run the second action.
 
-            :param init: An initial state to pass into the state action.
-            :returns: The value produced by the run action.
+            .. note::
+
+                Same as the Haskell ``>>`` operator.
 
         """
-        a, _ = self.run(init)
-        return a
+        return self.bind(lambda _: sb)
 
     def map[B](self, f: Callable[[A], B]) -> State[S, B]:
         """
@@ -230,7 +252,7 @@ class State[S, A]:
         return State.get().bind(lambda a: State.put(f(a)))
 
     @staticmethod
-    def sequence[ST, AA](sas: list[State[ST, AA]]) -> State[ST, list[AA]]:
+    def sequence[ST, AA](sa_list: list[State[ST, AA]]) -> State[ST, list[AA]]:
         """
         .. admonition:: sequence a list
 
@@ -253,9 +275,10 @@ class State[S, A]:
         """
 
         def append_ret(ls: list[AA], a: AA) -> list[AA]:
-            ls.append(a)
-            return ls
+            copy = ls.copy()
+            copy.append(a)
+            return copy
 
-        return CA(sas).foldl(
+        return CA(sa_list).foldl(
             lambda s1, sa: s1.map2(sa, append_ret), State.unit(list[AA]([]))
         )