Merge pull request #398 from ariebovenberg/compose-improvements

Improvements to "compose"

Author: eriknw

toolz/functoolz.py

@@ -4,6 +4,7 @@
 from operator import attrgetter
 from importlib import import_module
 from textwrap import dedent
+from types import MethodType
 
 from .compatibility import PY3, PY34, PYPY
 from .utils import no_default
@@ -521,6 +522,45 @@ def __name__(self):
         except AttributeError:
             return type(self).__name__
 
+    def __repr__(self):
+        return '{.__class__.__name__}{!r}'.format(
+            self, tuple(reversed((self.first, ) + self.funcs)))
+
+    def __eq__(self, other):
+        if isinstance(other, Compose):
+            return other.first == self.first and other.funcs == self.funcs
+        return NotImplemented
+
+    def __ne__(self, other):
+        equality = self.__eq__(other)
+        return NotImplemented if equality is NotImplemented else not equality
+
+    def __hash__(self):
+        return hash(self.first) ^ hash(self.funcs)
+
+    # Mimic the descriptor behavior of python functions.
+    # i.e. let Compose be called as a method when bound to a class.
+    if PY3:  # pragma: py2 no cover
+        # adapted from
+        # docs.python.org/3/howto/descriptor.html#functions-and-methods
+        def __get__(self, obj, objtype=None):
+            return self if obj is None else MethodType(self, obj)
+    else:  # pragma: py3 no cover
+        # adapted from
+        # docs.python.org/2/howto/descriptor.html#functions-and-methods
+        def __get__(self, obj, objtype=None):
+            return self if obj is None else MethodType(self, obj, objtype)
+
+    # introspection with Signature is only possible from py3.3+
+    if PY3:  # pragma: py2 no cover
+        @instanceproperty
+        def __signature__(self):
+            base = inspect.signature(self.first)
+            last = inspect.signature(self.funcs[-1])
+            return base.replace(return_annotation=last.return_annotation)
+
+    __wrapped__ = instanceproperty(attrgetter('first'))
+
 
 def compose(*funcs):
     """ Compose functions to operate in series.

toolz/tests/test_functoolz.py

@@ -1,8 +1,10 @@
+import inspect
 import platform
 
 from toolz.functoolz import (thread_first, thread_last, memoize, curry,
                              compose, compose_left, pipe, complement, do, juxt,
                              flip, excepts, apply)
+from toolz.compatibility import PY3
 from operator import add, mul, itemgetter
 from toolz.utils import raises
 from functools import partial
@@ -24,6 +26,26 @@ def double(x):
     return 2 * x
 
 
+class AlwaysEquals(object):
+    """useful to test correct __eq__ implementation of other objects"""
+
+    def __eq__(self, other):
+        return True
+
+    def __ne__(self, other):
+        return False
+
+
+class NeverEquals(object):
+    """useful to test correct __eq__ implementation of other objects"""
+
+    def __eq__(self, other):
+        return False
+
+    def __ne__(self, other):
+        return True
+
+
 def test_apply():
     assert apply(double, 5) == 10
     assert tuple(map(apply, [double, inc, double], [10, 500, 8000])) == (20, 501, 16000)
@@ -573,6 +595,74 @@ def g(a):
     assert composed.__name__ == 'Compose'
     assert composed.__doc__ == 'A composition of functions'
 
+    assert repr(composed) == 'Compose({!r}, {!r})'.format(f, h)
+
+    assert composed == compose(f, h)
+    assert composed == AlwaysEquals()
+    assert not composed == compose(h, f)
+    assert not composed == object()
+    assert not composed == NeverEquals()
+
+    assert composed != compose(h, f)
+    assert composed != NeverEquals()
+    assert composed != object()
+    assert not composed != compose(f, h)
+    assert not composed != AlwaysEquals()
+
+    assert hash(composed) == hash(compose(f, h))
+    assert hash(composed) != hash(compose(h, f))
+
+    bindable = compose(str, lambda x: x*2, lambda x, y=0: int(x) + y)
+
+    class MyClass:
+
+        def __int__(self):
+            return 8
+
+        my_method = bindable
+        my_static_method = staticmethod(bindable)
+
+    assert MyClass.my_method(3) == '6'
+    assert MyClass.my_method(3, y=2) == '10'
+    assert MyClass.my_static_method(2) == '4'
+    assert MyClass().my_method() == '16'
+    assert MyClass().my_method(y=3) == '22'
+    assert MyClass().my_static_method(0) == '0'
+    assert MyClass().my_static_method(0, 1) == '2'
+
+    assert compose(f, h).__wrapped__ is h
+    assert compose(f, h).__class__.__wrapped__ is None
+
+    # __signature__ is python3 only
+    if PY3:
+
+        def myfunc(a, b, c, *d, **e):
+            return 4
+
+        def otherfunc(f):
+            return 'result: {}'.format(f)
+
+        # set annotations compatibly with python2 syntax
+        myfunc.__annotations__ = {
+            'a': int,
+            'b': str,
+            'c': float,
+            'd': int,
+            'e': bool,
+            'return': int,
+        }
+        otherfunc.__annotations__ = {'f': int, 'return': str}
+
+        composed = compose(otherfunc, myfunc)
+        sig = inspect.signature(composed)
+        assert sig.parameters == inspect.signature(myfunc).parameters
+        assert sig.return_annotation == str
+
+        class MyClass:
+            method = composed
+
+        assert len(inspect.signature(MyClass().method).parameters) == 4
+
 
 def generate_compose_left_test_cases():
     """
@@ -708,4 +798,3 @@ def raise_(a):
     excepting = excepts(object(), object(), object())
     assert excepting.__name__ == 'excepting'
     assert excepting.__doc__ == excepts.__doc__
-