Краща композиційна функція в Python

Ви не можете отримати цей точний синтаксис, хоча ви можете отримати щось на зразок F (x) (foo, bar, baz) . Ось простий приклад:

class F(object):
    def __init__(self, arg):
        self.arg = arg

    def __call__(self, *funcs):
        arg = self.arg
        for f in funcs:
            arg = f(arg)
        return arg

def a(x):
    return x+2
def b(x):
    return x**2
def c(x):
    return 3*x

>>> F(2)(a, b, c)
48
>>> F(2)(c, b, a)
38

Це дещо відрізняється від відповіді Блендера, оскільки зберігає аргумент, який пізніше можна використовувати з різними функціями.

Це схоже на протилежність застосунку звичайної функції: замість того, щоб вказати функцію вперед і залишити деякі аргументи, що будуть вказані пізніше, ви вкажете аргумент і залиште функції, які потрібно вказати пізніше. Це цікава іграшка, але важко думати, чому ти дійсно хочеш цього.

Якщо ви хочете використовувати fn , з невеликим хаксом ви можете отримати трохи ближче до синтаксису Clojure:

>>> def r(x): return lambda: x
>>> (F() >> r(x) >> foo >> bar >> baz)()

Подивіться, як я додав ще одну функцію на початку ланцюжка композиції, яка просто поверне x під час виклику. Проблема з цим полягає в тому, що вам все одно доведеться викликати вашу зібрану функцію, просто без будь-яких аргументів.

Я думаю, що відповідь від Blender - це ваш найкращий пари, намагаючись емулювати функцію потоку Clojure в Python.

Я придумав це

def _composition(arg, *funcs_and_args):
    """
    _composition(
        [1,2,3], 
        (filter, lambda x: x % 2 == 1), 
        (map, lambda x: x+3)
    )
    #=> [4, 6]
    """
    for func_and_args in funcs_and_args:
        func, *b = func_and_args
        arg = func(*b, arg)
    return(arg)

Моя функція compose , яка повертає функцію

def compose(*args):
    length = len(args)
    def _composeInner(lastResult, index):
        if ((length - 1) < index):
            return lastResult
        return _composeInner(args[index](lastResult), index + 1)

    return (lambda x: _composeInner(x, 0))

Використання:

fn = compose(
        lambda x: x * 2,
        lambda x: x + 2,
        lambda x: x + 1,
        lambda x: x/3
    )

result = fn(6) # -> 5

Здається, це працює для простого введення. Не впевнені, що варто докласти зусиль для складного введення, наприклад, ((42, 'спам'), {'спам': 42}) .

def compose(function, *functions):
    return function if not functions else \
            lambda *args, **kwargs: function(compose(*functions)(*args, **kwargs))

def rcompose(*functions):
    return compose(*reversed(functions))

def postfix(arg, *functions):
    return rcompose(*functions)(arg)

Приклад:

>>> postfix(1, str, len, hex)
'0x1'
>>> postfix(1, hex, len)
3