Merge pull request #4 from ourstudio-se/3-compose-should-be-class-implement-predicate-class

3 compose should be class implement predicate class

Author: znittzel

.github/workflows/publish.yml

@@ -0,0 +1,20 @@
+name: Publish to PyPI.org
+on:
+  release:
+    types: [published]
+  
+jobs:
+  build-publish:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout main
+        uses: actions/checkout@v3
+
+      - name: Install python and build package
+        uses: actions/setup-python@v4
+      - run: python3 -m pip install --upgrade build && python3 -m build
+
+      - name: Publish package to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          password: ${{ secrets.PYPI_API_TOKEN }}

maz/__init__.py

@@ -72,8 +72,9 @@ def pospartial(function, positional_arguments):
         which yield
             res == 23+32+19 == 74
 
-        Return:
-            callable
+        Returns
+        -------
+            out : Callable
     """
 
     def wrapper(*args, fn=function, pas=positional_arguments, **kwargs):
@@ -83,8 +84,7 @@ def wrapper(*args, fn=function, pas=positional_arguments, **kwargs):
         return fn(*nargs, **kwargs)
     return wrapper
 
-def compose_pair(f, g):
-
+class compose_pair:
     """
         Composes new function h = f(g(x)), from
         f and g.
@@ -96,33 +96,77 @@ def compose_pair(f, g):
             >>> h(1)
             >>> 4
 
-        Return:
-            Callable
+        Returns
+        -------
+            out : Callable
     """
-    def composed(*args, f=f, g=g, **kwargs):
-        return f(g(*args, **kwargs))
 
-    return composed
+    def __init__(self, f, g):
+        self.f = f
+        self.g = g
+
+    def __call__(self, *args, **kwargs):
+        return self.f(
+            self.g(*args, **kwargs)
+        )
 
-def compose(*functions):
+class compose:
 
     """
         Sequence composite functions of `functions`.
         E.g. let fns be a list of functions [f, g, h] and
         compose(fns) would then represent lambda x : f(g(h(x)))
 
-        Example:
+        Examples
+        --------
             >>> inc = lambda x: x+1
             >>> double = lambda x: x*2
             >>> f = compose(inc, double, inc)
             >>> f(2)
-            >>> 7
+            7
 
-        Return:
-            function
+        Returns
+        -------
+            out : Callable
+    """
+
+    def __init__(self, *functions):
+        self.fn = functools.reduce(compose_pair, functions)
+
+    def __call__(self, *args, **kwargs):
+        return self.fn(*args, **kwargs)
+
+class fnmap:
+
+    """
+        Runs an iterable of functions with same arguments.
+        Returns an iterable of result from each of the functions.
+
+        Examples
+        --------
+            >>> fn = fnmap(lambda x: x+1, lambda x: x+2)
+            >>> list(fn(3))
+            [4, 5]
+
+            >>> def add_one(x): return x+1
+            >>> def mul_two(x): return x*2
+            >>> fn = fnmap(add_one, mul_two)
+            >>> list(fn(x=3))
+            [4, 6]
+
+        Returns
+        -------
+            out : Callable
     """
 
-    return functools.reduce(compose_pair, functions)
+    def __init__(self, *functions):
+        self.functions = functions
+    
+    def __call__(self, *args, **kwargs):
+        return map(
+            lambda fn: fn(*args, **kwargs),
+            self.functions
+        )
 
 def indexing(lst: list, index_item):
 

setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = maz
-version = 0.0.1
+version = 0.0.2
 author = ourstudio
 author_email = rikard@ourstudio.se
 description = Functional programming tools.

tests/test_maz.py

@@ -63,4 +63,14 @@ def f(x,y,z):
         return x+y+z
 
     _f = maz.pospartial(f, [(1, 32), (2, 19)])
-    assert _f(23) == 74
+    assert _f(23) == 74
+
+def test_fnmap():
+
+    fn = maz.fnmap(lambda x: x+1, lambda x: x+2)
+    assert list(fn(3)) == [4, 5]
+
+    def add_one(x): return x+1
+    def mul_two(x): return x*2
+    fn = maz.fnmap(add_one, mul_two)
+    assert list(fn(x=3)) == [4, 6]