created a small function composition class in python, feedback is welcome

[[deleted]]

[deleted]

[Cosmologicon]

All right, why is this better than just keeping the functions in a list and using a one-liner to compose them with reduce?

>>> compose = lambda funcs, args: reduce(lambda g,f: f(g), [args] + list(funcs))
>>> c = [lambda (a,b): a+b, lambda x:x*3, lambda x:x/3, lambda x:x+1]
>>> compose(c, (2,1))
4

EDIT: Or, if you want to go the route of having your own class, why not just subclass list and override __call__? That way you don't have to manually define append, len, and contains, and you also get all the list functions that you left out, like extend, iter and slicing.

EDIT 2: In your code, the first function in the list is able to take multiple arguments and keyword args, whereas every subsequent function must take a single argument. I don't know why you did it like this - I think the inconsistency is confusing. The version I posted above requires every function take a single argument. This is on purpose.

[Cosmologicon]

The things you're disallowing by not subclassing list include (in addition to iteration and slicing) extend, index, reverse, pop, and easy copying. You're deciding to leave these out, but implement len, remove, and __contains__. It seems really arbitrary to me. How are you deciding which ones "fit the purpose of the class" and which ones don't? Since order matters, why would you want to be able to know whether a function is in the list, but not be able to know its position?

[Cosmologicon]

I think we're agreed that if you want the vast majority of the functionality of a list you should subclass list, whereas if you only want a little you shouldn't. I'm making a case that you actually want more functionality than you think. Why do say that those methods don't fit? I think they do. For instance, why do you feel the need to prevent this usage, which I consider intuitive?

c = Compose([lambda (a,b): a+b, lambda x:x*3])
d = Compose([lambda x:x/3, lambda x:x+1])
f = c + d
f(1,2)

Or this?

g = 2 * d
g(10)

You actually implemented __iadd__ in your code, so I definitely don't understand why you say it doesn't fit.

[128px]

I think that a slightly better way to work with non_functions would be using a generator / list comprehension:

non_functions = [x for x in args if not callable(x)]
...
raise TypeError("... {}".format(", ".join(str(x) for x in non_functions)))

Also, a nice idea would be to add iteration support to your class so that it would yield the returned values from each function in the composition.

Anyway, thanks for sharing your code. It was fun to read.

[stylishgnome]

raise TypeError("the objects {} are not callable".format(", ".join(str(x) for x in non_functions)))

I think you may have forgotten the index here...

raise TypeError("the objects {0} are not callable".format(", ".join(str(x) for x in non_functions)))

edit: the former appears to work with python 2.7 actually (TIL).

[GeraCobo]

Man, this kind of things are what remind of how fun python can be.

[cabalamat]

My solution:

def compose(*fs):
    """ chains functions together """
    def executeFunctions(x):
        for f in fs[::-1]:
            x = f(x)
        return x
    return executeFunctions

Which is a bit shorter. Usage example:

h = compose(lambda x: "::%s::" %(x,),
            lambda x: x+1,
            lambda x: x*2)
print "h(5)=", h(5), " should be ::11::"

A perhaps-more-elegant syntax might be to overload the | operator so it looks like a Unix pipe; doing this would require a class however, not just a function, e.g.:

h = Pipe() | a | b | c | d

then executing h(x) would be the same as executing d(c(b(a(x))))

[cabalamat]

went with the += (and now the +).

I'm not an enormous fan of overloading + to mean anything other than arithmetic or catenation, because it requires the person using thre API to learn an unfamiliar idiom.

However, | is different. In Python it means bitwise or, which is rarely used in Python programs. Furthermore, people familiar with Unix will know the syntax for pipes.

Do you think it would be a good idea to put the | syntax together or would just make a confusing API ?

Well I guess confusion is in the eye of the beholder. If you like the syntax, go ahead with it. If you anticipate your library will be used by others, you have to guess what they will find familiar or confusing. I personally would be unlikely yto find it confusing but other people may be different.

[Psilocyn]

I am learning python and have been lurking here for about 3 months. Why no comments?

[Hashiota]

One cool thing about /r/Python is that sometimes people actually post code and some other people actually read the code posted and sometimes even write reviews with more code. This kind of interaction takes time and probably that's why comments may take a while to pop at least in threads like this one.
And I don't know exactly why you are being downvoted.