Merge pull request #11 from ourstudio-se/10-implement-a-constant-function-1

10 implement a constant function 1

Author: znittzel

README.md

@@ -19,11 +19,11 @@ You can use `maz` to compose function calls such that they call one another in a
 ```
 
 ##### Partial function
-When you want to fix a parameter in a function, you could just use the `functools.partial`. However, that doesn't support fixing a positional argument on a specific index, which are quite common later on when you want to build complex compositions. Here you can use the `maz.pospartial` instead
+When you want to fix a parameter in a function, you could just use the `functools.partial`. However, that doesn't support fixing a positional argument on a specific index, which are quite common later on when you want to build complex compositions. Here you can use the `maz.partialpos` instead
 ```python
 >>> import maz
 >>> def add(x,y): return x+y
->>> add_two = maz.pospartial(add, [(1,2)]) # meaning fix argument on index 1 with the value 2
+>>> add_two = maz.partialpos(add, {1:2}) # fixing argument for index 1 to 2 (y=2)
 >>> add_two(3)
 >>> 5
 ```
@@ -33,6 +33,7 @@ To support more complex compositions we've added some special functions such as
 ```python
 import maz
 import operator
+import itertools
 
 # "indexing" function - since only way to index a list in python is to do lst[x]
 lst = [2,1,3]
@@ -63,4 +64,21 @@ fn = maz.ifttt(
 fn(3) # >>> 4
 fn(4) # >>> 3
 
+# "starfilter" just as itertools.starmap but a filter instead
+# Example, filter tuples who's sum is greater than 4 
+next(
+    maz.starfilter(
+        maz.compose(
+            lambda i: i > 4,
+            add
+        ), 
+        itertools.product(range(3), range(3,6))
+    )
+) # >>> (0,5)
+
+# "constant" returns a function which, no matter the argument, returns a constant value.
+cnst_fn = maz.constant(True)
+cnst_fn() # >>> True
+cnst_fn(cnst_fn()) # >>> True
+
 ```

maz/__init__.py

@@ -1,3 +1,4 @@
+import inspect
 import functools
 import typing
 import operator
@@ -56,6 +57,8 @@ def starzip(iterables: list):
 def pospartial(function, positional_arguments):
 
     """
+        DEPRECATED. Use partialpos instead.
+
         `pospartial` is a complementing function to functools.partial, where
         one can say which positional argument should be hardcoded into function.
         Usually, this is solved by instead setting a keyword argument and thus
@@ -89,6 +92,71 @@ def wrapper(*args, fn=function, pas=positional_arguments, **kwargs):
         return fn(*nargs, **kwargs)
     return wrapper
 
+class partialpos:
+
+    """
+        Return a new partial function object which when called behave like
+        `function` called with positional arguments given in `positional_arguments`.
+        Each key `i` corresponds to the `i`'th argument in `function`.
+
+    """
+
+    def __init__(self, function, positional_arguments: typing.Dict[int, typing.Any]):
+        self.function = function
+        self.positional_arguments = positional_arguments
+
+    def _defaults(self) -> dict:
+        return dict(
+            itertools.starmap(
+                lambda k,v: (
+                    self.function.__code__.co_varnames.index(k), 
+                    v.default
+                ),
+                filter(
+                    compose(
+                        lambda x: x is not inspect.Parameter.empty,
+                        operator.attrgetter("default"),
+                        operator.itemgetter(1),
+                    ),
+                    inspect.signature(self.function).parameters.items()
+                )
+            )
+        )
+
+    def __call__(self, *args, **kwargs):
+
+        # First we collect function's default arguments,
+        # all positional arguments hard coded in self.positional_arguments
+        # and then given from kwargs input. It is also priorized in that order,
+        # so if e.g. default value on argument a=1, but user gives a=2 in kwargs,
+        # then a=2 is what will be calculated on.
+        # Finally will append the positional arguments given from
+        # user into function. So the experience will be as if it is
+        # calling any other function. 
+
+        left = set(range(len(self.function.__code__.co_varnames))).difference(self.positional_arguments.keys())        
+        return self.function(
+            *map(
+                operator.itemgetter(1),
+                sorted(
+                    dict(
+                        itertools.chain(
+                            self._defaults().items(),
+                            self.positional_arguments.items(),
+                            itertools.starmap(
+                                lambda k,v: (
+                                    self.function.__code__.co_varnames.index(k),
+                                    v
+                                ),
+                                kwargs.items(),
+                            ),
+                            zip(left, args)
+                        )
+                    ).items(),
+                    key=operator.itemgetter(0),
+                )
+            )
+        )
 
 class compose_pair:
     """
@@ -228,8 +296,16 @@ def kwargs2dict(**kwargs):
 class fnexcept:
 
     """
-        Wrapping a raising function to return the exception
-        as the second item in a tuple.
+        Wrapping a raising function and a handler function that
+        returns an alternative to the exception.
+
+        Parameters
+        ----------
+            raising_function: Callable
+                a function that may raise exceptions for perticular input values
+
+            handler_function: Callable
+                a function, taking same arguments as raising_function, returning some alternative value
 
         Examples
         --------
@@ -246,7 +322,7 @@ class fnexcept:
             ...         raise Exception("not allowed")
             ...     return a+1
             >>> raising_wrapper = fnexcept(raising, lambda: 0)
-            >>> raising_wrapper(2)
+            >>> raising_wrapper(1)
             2
 
         Returns
@@ -264,7 +340,7 @@ def __call__(self, *args, **kwargs) -> typing.Any:
                 *args,
                 **kwargs
             )
-        except Exception as e:
+        except:
             return self.handler_function(*args, **kwargs)
 
 
@@ -353,13 +429,71 @@ def __call__(self, objects: typing.Iterable[typing.Any]) -> typing.Iterable[typi
 
 class ifttt:
 
+    """
+        Returns a function object that will evaluate `fnif` first.
+        If it evaluated to true, then `fnthen` will be called, or else
+        `fnelse` will be called. `fnif`, `fnthen` and `fnelse` all has 
+        the same function signature.
+
+        Parameters
+        ----------
+            fnif: Callable[typing.Any, bool]
+                a predicate function returning true or false
+
+            fnthen: Callable[typing.Any, typing.Any]
+                any function object 
+
+            fnelse: Callable[typing.Any, typing.Any]
+                any function object 
+
+        Examples
+        --------
+            >>> list(
+            ...     map(
+            ...         ifttt(
+            ...             lambda x: x > 2, # if number is greater than 2
+            ...             lambda x: x + 1, # then add by 1
+            ...             lambda x: x - 1  # else subtract by 1
+            ...         ),
+            ...         range(5)
+            ...     )    
+            ... )
+            [-1, 0, 1, 4, 5]
+
+        Returns
+        -------
+            out : Callable[Any, Any]
+    """
+
     def __init__(self, fnif, fnthen, fnelse):
         self.fnif = fnif
         self.fnthen = fnthen
         self.fnelse = fnelse
 
-    def __call__(self, obj: typing.Any) -> typing.Any:
-        if self.fnif(obj):
-            return self.fnthen(obj)
+    def __call__(self, *args, **kwargs) -> typing.Any:
+        if self.fnif(*args, **kwargs):
+            return self.fnthen(*args, **kwargs)
         else:
-            return self.fnelse(obj)
+            return self.fnelse(*args, **kwargs)
+
+def starfilter(function, iterable):
+    
+    """
+        As built in `filter` but function is called with each item in iterable as a starred argument.
+    """
+    return filter(
+        lambda x: function(*x),
+        iterable,
+    )
+
+class constant:
+
+    """
+        Returns a function which returns `val`.
+    """
+
+    def __init__(self, val):
+        self.val = val
+
+    def __call__(self, *args, **kwargs):
+        return self.val

setup.cfg

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

tests/test_maz.py

@@ -1,6 +1,7 @@
+import functools
 import maz
 import operator
-import functools
+import pytest
 
 
 def test_compose():
@@ -163,4 +164,41 @@ def __eq__(self, o):
         Var("d", 5),
         Var("e", 6),
     ]
-    assert actual == expected
+    assert actual == expected
+
+def test_partialpos():
+
+    def f(a,b,c,d=1):
+        return 1*a + 2*b + 3*c + 4*d
+
+    assert maz.partialpos(f, {1:2, 2:2})(1,2) == 1*1 + 2*2 + 3*2 + 4*2
+    assert maz.partialpos(f, {1:2, 2:2})(1)   == 1*1 + 2*2 + 3*2 + 4*1
+    assert maz.partialpos(f, {1:2, 3:3})(1,3) == 1*1 + 2*2 + 3*3 + 4*3
+
+    def f(a,b):
+        return a+b
+
+    assert maz.partialpos(f, {1: 2})(1) == 3
+    assert maz.partialpos(f, {1: 2})(1,2) == 3
+
+    with pytest.raises(Exception):
+        assert maz.partialpos(f, {"1":2})(1)
+
+    with pytest.raises(Exception):
+        assert maz.partialpos(f, {1:2})()
+
+def test_starfilter():
+
+    assert list(
+        maz.starfilter(
+            lambda x,y: x+y >= 4,
+            [(1,2),(2,3),(3,4),(4,5)]
+        )
+    ) == [(2,3),(3,4),(4,5)]
+
+def test_constant():
+
+    cnst_fn = maz.constant(True)
+    assert cnst_fn(0) == True
+    assert cnst_fn("hello") == True
+    assert cnst_fn(lambda x: x+1) == True