コード例 #1
0
ファイル: function.py プロジェクト: pyx/fx
    def compose(self, function):
        """Creates a Function as composition of ``function`` with ``self``.

        Function composition:

        >>> f = Function(lambda a: -a).compose(abs)
        >>> f(-1)
        -1

        Function composition operator ``**``:

        >>> f = Function(lambda a: -a) ** abs
        >>> f(-1)
        -1

        ``**`` works on either side, no need to wrap both sides:

        >>> f = Function(list) ** map << 1 .__add__
        >>> f(range(10))
        [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
        >>> f = list ** Function(map) << 1 .__add__
        >>> f(range(10))
        [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
        """
        return self.clone(compose(self.invoke, self.clone(function)))
コード例 #2
0
    def compose(self, function):
        """Creates a Function as composition of ``function`` with ``self``.

        Function composition:

        >>> f = Function(lambda a: -a).compose(abs)
        >>> f(-1)
        -1

        Function composition operator ``**``:

        >>> f = Function(lambda a: -a) ** abs
        >>> f(-1)
        -1

        ``**`` works on either side, no need to wrap both sides:

        >>> f = Function(list) ** map << 1 .__add__
        >>> f(range(10))
        [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
        >>> f = list ** Function(map) << 1 .__add__
        >>> f(range(10))
        [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
        """
        return self.clone(compose(self.invoke, self.clone(function)))
コード例 #3
0
ファイル: function.py プロジェクト: pyx/fx
    def pipe(self, function):
        """Creates a Function that pipes output into ``function`` if invoked.

        Piping output:

        >>> f = Function(range).pipe(sum).pipe(int.__neg__)
        >>> f(1, 101)
        -5050

        Pipe operator ``|``:

        >>> f = Function(range) | sum | int.__neg__
        >>> f(1, 101)
        -5050

        >>> f = Function(map) << 1 .__add__ | list
        >>> f(range(10))
        [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

        >>> sum_upto = 1 .__add__ | Function(range) << 1 | sum
        >>> sum_upto(100)
        5050
        """
        return self.clone(compose(function, self.invoke))
コード例 #4
0
    def pipe(self, function):
        """Creates a Function that pipes output into ``function`` if invoked.

        Piping output:

        >>> f = Function(range).pipe(sum).pipe(int.__neg__)
        >>> f(1, 101)
        -5050

        Pipe operator ``|``:

        >>> f = Function(range) | sum | int.__neg__
        >>> f(1, 101)
        -5050

        >>> f = Function(map) << 1 .__add__ | list
        >>> f(range(10))
        [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

        >>> sum_upto = 1 .__add__ | Function(range) << 1 | sum
        >>> sum_upto(100)
        5050
        """
        return self.clone(compose(function, self.invoke))
コード例 #5
0
def test_compose():
    identity = lambda a: a

    # Left identity
    f = int
    g = compose(identity, f)

    assert f('42') == g('42')

    for n in range(42):  # this number is not significant here.
        assert f(n) == g(n)

    # Right identity
    f = str
    g = compose(f, identity)

    assert f(42) == g(42)

    for n in range(42):  # this number is not significant here.
        assert f(n) == g(n)

    # Associative

    # NOTE: these functions are specifically chosen, so that when composed in
    # different orders, yield different outputs.
    f = hash
    g = str
    h = type

    f1 = compose(f, compose(g, h))
    f2 = compose(compose(f, g), h)

    ns = [42, 0.5, '42', sum, f, lambda: 0]
    for n in ns:
        # make sure these functions yield different outputs when composed in
        # different order,
        assert f1(n) != compose(f, compose(h, g))(n)
        assert f2(n) != compose(f, compose(h, g))(n)
        assert f1(n) != compose(g, compose(f, h))(n)
        assert f2(n) != compose(g, compose(f, h))(n)
        assert f1(n) != compose(g, compose(h, f))(n)
        assert f2(n) != compose(g, compose(h, f))(n)
        assert f1(n) != compose(h, compose(g, f))(n)
        assert f2(n) != compose(h, compose(g, f))(n)
        assert f1(n) != compose(h, compose(f, g))(n)
        assert f2(n) != compose(h, compose(f, g))(n)
        # but compose should obey associative law.
        assert f1(n) == f2(n)