Transducers are coming to Clojure

Post by pyrtsa » Thu, Aug 07, 2014, 11:31 AM UTC

mduerksen wrote: post #81

fnordsensei wrote: post #74

Tentative benchmark results have surfaced: https://github.com/thheller/transduce-bench Add salt according to taste.

The benchmark is wrong atm, the compared functions do not yield the same result. (comp (map inc) (filter even?)) means filtering first, then incrementing. The opposite for (->> data (map inc) (filter even?) ... - which is not the same. And of course, it also means that the latter has to increment the double amount of numbers. EDIT: It was me who was wrong, thanks for the corrections. Pitfall successfully identified :…

    (sequence (comp (map inc) (filter even?)) (range 10))
    ;;=> (2 4 6 8 10)
    (->> (range 10) (map inc) (filter even?))
    ;;=> (2 4 6 8 10)

Post by jeletonskelly » Thu, Aug 07, 2014, 12:01 PM UTC

oafitupa wrote: post #75

As someone who tried Clojure and failed, serious question: Does anyone actually use all these crazy features/patterns that keep getting added/discovered and talked about? I ask because even though I can imagine someone smart mastering these things and programming faster, I can't imagine a second person being able to understand his code, maintain it, and generally be productive. I imagine the second person losing a lo…

Post by puredanger » Thu, Aug 07, 2014, 1:11 PM UTC

bcoates wrote: post #62

vbit wrote: post #45

I'm not quite sure what this means, so here's my attempt to translate this into Python. A reducer is a function such as `add`: def add(sum, num): return sum + num Of course you can plug `add` directly in `reduce(add, [1, 2, 3], 0)` which gives `6`. A transducer is an object returned by a call such as `map(lambda x: x + 1)`. You can now apply the transducer to a reducer and get another reducer. map_inc = map(lambda x:…

If I understand right (I may not): In Python, the (complex, generic) iter() protocol is how every container provides a method to iterate itself, and reduce is a trivial application of a reducer (like your add function) to a container by using the iter protocol. In Clojure, it's the opposite: there is a reduce() protocol and every reducible container knows how to reduce itself. the traditional reduce function just tak…

Post by tel » Thu, Aug 07, 2014, 3:02 PM UTC

riwsky wrote: post #87

tel wrote: post #71

Earlier quoted context omitted.

Also, you can get rid of the sentinel value by packing along a termination continuation value as well: type Red r a = (r -> a -> r, r) zmap :: (b -> a) -> Red r a -> Red r b zmap f (f1, z1) = (\result input -> f1 result (f input), z1) zfilt :: (a -> Bool) -> Red r a -> Red r a zfilt p (f1, z1) = (\result input -> if p input then f1 result input else result, z1) ztake :: Int -> Red r a -> Red r a ztake n (f1, z1) = (r…

Doesn't ztake need to live in State Int (or something similar)? As written, I don't see how it passes the 'n' onto the next call. It seems that the transducer returned by ztake n for any n > 1 will always pass on (f1 result, z1). Thank you for posting this though, helpful to see someone work through it.

Post by neotrinity » Thu, Aug 07, 2014, 3:19 PM UTC

bcoates wrote: post #62

vbit wrote: post #45

I'm not quite sure what this means, so here's my attempt to translate this into Python. A reducer is a function such as `add`: def add(sum, num): return sum + num Of course you can plug `add` directly in `reduce(add, [1, 2, 3], 0)` which gives `6`. A transducer is an object returned by a call such as `map(lambda x: x + 1)`. You can now apply the transducer to a reducer and get another reducer. map_inc = map(lambda x:…

If I understand right (I may not): In Python, the (complex, generic) iter() protocol is how every container provides a method to iterate itself, and reduce is a trivial application of a reducer (like your add function) to a container by using the iter protocol. In Clojure, it's the opposite: there is a reduce() protocol and every reducible container knows how to reduce itself. the traditional reduce function just tak…