http://dev.clojure.org/jira This file is an XML representation of an issue en-us 4.4 649 25-07-2011 http://dev.clojure.org/jira/browse/CLJ-993 Clojure <p>Rich mentioned in IRC today he'd welcome a reducer implementation of clojure.core/range. Now that I've figured out how to do iterate, I figure I'll knock out range as well by the end of the night. Just opening the issue early to announce my intentions to anyone else interested in doing it.</p> CLJ-993

`range` reducer

Enhancement Major Open Unresolved Unassigned Alan Malloy Thu, 10 May 2012 21:47:40 -0500 Sat, 18 Aug 2012 19:18:48 -0500 Release 1.5 1 2 <p>Implemented range. A separate commit is attached, making iterate and range also Seqable, since I'm not sure if that's desired. Apply it or not, as you prefer.</p> <p>Range should be foldable</p> <p>Yep, so it should. Time for me to dig into the folding implementations!</p> <p>Should I fold (har har) all of these commits into one? I don't know what is preferred on JIRA, and I also don't know whether range/iterate should be seqable or if I should just drop the second commit.</p> <p>Yes, please merge these together, it's hard to see otherwise (I can barely read diffs as is <img class="emoticon" src="http://dev.clojure.org/jira/images/icons/emoticons/smile.gif" height="20" width="20" align="absmiddle" alt="" border="0"/>. range and iterate shouldn't be novel in reducers, but just enhanced return values of core fns. The enhancement (e.g. protocol extensions) <em>can</em> come by requiring reducers since it can't be leveraged without it. Also, I'm not sure how I feel about an allocating protocol for 'splittable' - I've avoided it thus far.</p> <p>So you want clojure.core/range to return some object (a Range), which implements Counted and Seqable (but isn't just a lazy-seq), and then inside of clojure.core.reducers I extend CollReduce and CollFold to that type? Okay, I can do that.</p> <p>I don't quite follow what you mean by an allocating protocol. I see your point that my fold-by-halves which takes a function in is analogous to a protocol with a single function, but it doesn't allocate anything more than foldvec already does - I just pulled that logic out so that the fork/join fiddly work doesn't need to be repeated in everything foldable. Do you have an alternative recommendation, or is it just something that makes you uneasy and you're still thinking about?</p> <p>While vector-fold allocs subvecs, the halving-fn must return a new vector, for all implementations. It's ok, I don't think it's likely to dominate (since fj needs new closures anyway). Please proceed, but keep range and iterate in core. They are sources, not transformers, and only transformers (which must be different from their seq-based counterparts) must reside in reducers. Thanks!</p> <p>One big patch file is preferred, although that file may contain multiple commits if that makes the intent clearer.</p> <p>When adding a patch, update the description of the ticket to indicate which file is the most recent. Leave old patch files around for historical reference.</p> <p>It's looking harder than I expected to move iterate and range into core.clj. My plan was to just have them implement Seqable, which is easy enough, but currently they are actually instances of ISeq, because they inherit from LazySeq. A bunch of code all over the place (eg, to print them in the repl) depends on them being ISeq, so I can't just ignore it. To implement all of these methods (around thirty) would take a large amount of code, which can't easily be shared between Iteration, Range, and any future reducible sources that are added to core.clj.</p> <p>I could write a macro like (defseq Range <span class="error">&#91;start end step&#93;</span> Counted (count <span class="error">&#91;this&#93;</span> ...) ...) which takes normal deftype args and also adds in implementations for ISeq, Collection, and so forth in terms of (.seq this), which will be a LazySeq. However, this seems like a somewhat awkward approach that I would be a little embarrassed to clutter up core.clj with. If anyone has a better alternative I will be pleased to hear it. In the mean time, I will go ahead with this macro implementation, in case it turns out to be the best choice.</p> <p>&#8211; This patch subsumes all previous patches to this issue and to <a href="http://dev.clojure.org/jira/browse/CLJ-992" title="`iterate` reducer">CLJ-992</a> &#8211;</p> <p>In order to create an object which is both a lazy sequence and a<br/> reducible source, I needed to add a macro named defseq to core_deftype.<br/> It is basically a reimplementation of clojure.lang.LazySeq as a clojure<br/> macro, so that I can "mix in" lazy-sequence functions into a new class<br/> with whatever methods are needed for reducing and folding.</p> <p>If we wanted, we could use this macro to implement lazy-seq in clojure instead of in java, but that's unrelated so I didn't do that in this patch.</p> <p>As noted in a previous comment, defseq may not be the right approach, but this works until something better is suggested.</p> <p>I accidentally included an implementation of drop-while in this patch, which I was playing around with to make sure I understood how this all works. I guess I'll leave it in for the moment, since it works and is useful, but I can remove it, or move it to a new JIRA ticket, if it's not wanted at this time.</p> <p>Ok, I think this patch is officially off the rails. There must be a better way. Let's start with: touching core/deftype and reimplementing lazy-seq as a macro are off the table. The return value of range doesn't have to <em>be</em> a LazySeq, it has to be a lazy seq, .e.g. implement ISeq (7 methods, not 30) which it can do by farming out to its existing impl. It can also implement some new interface for use by the reducer logic. There is also still clojure.lang.Range still there, which is another approach. Please take an extremely conservative approach in these things.</p> <p>Okay, thanks for the feedback - I'm glad I went into that last patch knowing it was probably wrong <img class="emoticon" src="http://dev.clojure.org/jira/images/icons/emoticons/smile.gif" height="20" width="20" align="absmiddle" alt="" border="0"/>. I thought I would need to implement the java collection interfaces that LazySeq does, eg java.util.List, in order to avoid breaking interop functions like (defn range-list <span class="error">&#91;n&#93;</span> (ArrayList. (range n))). If it's sufficient to implement ISeq (and thus IPersistentCollection), then that's pretty manageable. </p> <p>It's still an unpleasant chunk of boilerplate for each new source, though; would you welcome a macro like defseq if I didn't put it in core_deftype? If so, it seems like it might as well implement the interop interfaces; if not, I can skip them and implement the 7 (isn't it more like 9?) methods in ISeq, IPersistentCollection, and Seqable for each new source type.</p> <p>Thanks for pointing out clojure.lang.Range to me - I didn't realize we had it there. Of course with implementation inheritance it would be easy to make Range, Iteration, etc inherit from LazySeq and just extend protocols from them. But that means moving functionality out of clojure and into java, which I didn't think we'd want to do.</p> <p>I'll put together a patch that just implements ISeq by hand for both of these new types, and attach it probably later today.</p> <p>So I've written a patch that implements ISeq, but not the java Collections interfaces, and it mostly works but there are definitely assumptions in some parts of clojure.core and clojure.lang that assume seqs are Collections. The most obvious to me (ie, it shows up when running mvn test) is RT/toArray - it tests for Collection, but never for ISeq, implying that it's not willing to handle an ISeq that is not also a collection. Functions which rely on toArray (eg to-array and vec) now fail.</p> <p>This patch subsumes all previous patches on this issue, but is not suitable for application because it leaves some failing tests behind - it is intended only for intermediate feedback.</p> <p>It would be a great help if, time permitting, you could please write up the issues, challenges and options you've discovered somewhere on the dev wiki (even a simple table would be fantastic). I realize this has been a challenging task, and at this point perhaps we should opt for the more modest reducers/range and reducers/iterate and leave the two worlds separate. I'd like at some point to unify range, as there are many extant ranges it would be nice to be able to fold, as we can extant vectors.</p> <p>Should r/range return something Seqable and Counted?</p> <p>If so, I'll do the same for r/repeat.</p> <p>I've sketched out a description of the issues and options. I'm not very familiar with the dev wiki and couldn't figure out where was the right place to put this. "release.next" seems to still be about 1.4 issues, and I don't know if it's "appropriate" to create a whole new category for this. It's available <a href="https://gist.github.com/1586b2460329dde1c374">as a gist</a> until a better home can be found for it.</p> <p>Here's a single patch summing up the state Rich suggested "rolling back" to: separate r/range and r/iterate functions. I haven't heard any feedback since doing the writeup Rich asked for, so am not making any further progress at the moment; if something other than this patch is desired just let me know.</p> <p>I prefer not to see the use of extend like this for new types. Perhaps this code is too DRY? Also, it does a lot in one patch which makes it hard to parse and accept. This adds Range, switches impl of vector folds etc. Can it be broken up into separate tickets that do each step that builds on the previous, e.g. one ticket could be: capture vector fold impl for reuse by similar things.</p> <p>Okay, I should be able to split it up over the weekend. I'll also see about converting fold-by-halves into a function that is used by Range/Vector, rather than a function that gets extended onto them.</p> <p>As requested, I have split up the large patch on this issue into four smaller tickets. The other three are: <a href="http://dev.clojure.org/jira/browse/CLJ-1045" title="Generalize/refactor implementation of PersistentVector/coll-fold">CLJ-1045</a>, <a href="http://dev.clojure.org/jira/browse/CLJ-1046" title="Drop-while as a reducer">CLJ-1046</a>, and <a href="http://dev.clojure.org/jira/browse/CLJ-992" title="`iterate` reducer">CLJ-992</a>.</p> <p><a href="http://dev.clojure.org/jira/browse/CLJ-1045" title="Generalize/refactor implementation of PersistentVector/coll-fold">CLJ-1045</a> contains the implementation of fold-by-halves, and as such this patch cannot be applied until <a href="http://dev.clojure.org/jira/browse/CLJ-1045" title="Generalize/refactor implementation of PersistentVector/coll-fold">CLJ-1045</a> is accepted. This ticket does not depend on the other two, but there will be minor merge conflicts if this is merged before them.</p> Global Rank Patch Code and Test