You can also easily write pipeline() (which is just a reduction over callables inside a lambda[0]) such that: process = pipeline(partial(filter, even),

You can also easily write pipeline() (which is just a reduction over callables inside a lambda[0]) such that: process = pipeline(partial(filter, even), partial(map, inc), sum) process(some-iterable) I'll grant that it's not syntactically ideal (this is the tradeoff the thrush combinator (pipeline) running as a function instead of working as a macro. The benefit of being able to follow down the program as it works remains. (def process [xs] (->> xs (filter even?) (map inc) (reduce +))) (process some-iterable) If you compare a function-based approach[1] (instead of a macro) you might get: (def process (pipeline (partial filter even?) (partial map inc) (partial reduce +))) process(some-iterable) [0] A sample Python definiton (python doesn't have compose to reverse): def pipeline(*fns): return reduce(lambda f, g: lambda *xs, **ys: g(f(*xs, **ys)), fns) [1] A clojure implementation: (defn pipeline [& fs] (apply compose (reverse fs)))