swiss-arrows

Swiss arrows ftw! https://github.com/rplevy/swiss-arrows https://github.com/hipeta/arrow-macros

I've found -<> and -<>> very useful- they by default put things in first and last place respectively, but let you override with <>: (-<> x (foo bar) (map baz <>)) Found here: https://github.com/rplevy/swiss-arrows

This comes for free from Haskell's automatic partial application (that arises from Haskell's pervasive use of function currying). So several different Haskell variants of Clojure's `compose` correspond to different versions of Clojure's threading macros. Clojure's threading macros arise because it's a little bit more awkward in Clojure to partially apply functions (either anonymous functions with # or use `partial`) and it reads more fluently to just use threading macros there. However, Clojure can do fancier things with variants of the common threading macros (https://github.com/rplevy/swiss-arrows)

Also check out the Swiss arrows project which builds on the idea a bit. https://github.com/rplevy/swiss-arrows

Two solutions. Threading macros wherein instead of nested parens like (x (y (z))) one writes ((->> z) y x) In clojure there is an interesting package https://github.com/rplevy/swiss-arrows which allows one to perform successive operations with explicit placement of the result of prior evaluation by placing a <> in the form ((->> (z <>)) (y <> 7) (x <>)) In practice it seems like there is often less need to do so as many similar functions or the same variety have the same ordering and other options like as-> exist too. There is also the idea of processing math expressions infix as expected when desired. https://github.com/rm-hull/infix ($= 3 + 5 * 8) ; => 43

If it's particularly confusing you can always use swiss arrows[0] instead: (-<> (range 10) (map #(+ % 2) <>) (reduce + <>)) [0] https://github.com/rplevy/swiss-arrows It's more common in functional languages and called a thrush or pipe operator. F#: [|0..9|] |> Seq.map ((+) 2) |> Seq.sum Javascript (Ramda): R.pipe(R.range(0,10), R.map(R.add(2)), R.sum)(); //With slightly more magic let {pipe, range, map, add, sum} = R; pipe(range(0), map(add(2)), sum)(10);

I've been using Swiss Arrows. https://github.com/rplevy/swiss-arrows