Tassilo Horn <tass...@member.fsf.org> writes: Hi again,
>>> https://github.com/ninjudd/ordered-set >> >> Oh, yes, that looks exactly as what I was looking for. And judging >> from the implementation, it looks promising performance-wise for my >> usecase. > > I've now switched to that, and I get some slight performance > improvements. After enabling *warn-on-reflection*, which I didn't know before (as said, 1st clojure project), I added tons of type hints to the calls to Java code, which made everything about 10 times faster. :-) Bye, Tassilo > However, I noticed that lazyness supresses the "no-duplicates" > property. > > Here's the context: I develop a graph querying DSL in Clojure. From a > given vertex v1, you can get the directly reachable vertices with right > to the connecting edge's direction using (--> v1), (<-- v1), or (<-> > v1), which all return them as ordered-set. > > Now I also have functions that compose these simple expressions, like > `p-alt' for a alternative of path expressions. > > (defn p-alt > "Path alternative starting at v and traversing one of p. > v may be a vertex or a seq of vertices. > p is a varags seq of alternative path descriptions." > [v & p] > (apply concat > (map #(p-apply v %1) > p))) > > You call it like (p-alt v1 --> <--), meaning one may either traverse one > outgoing or one incoming edge. > > That function (and others) return lazy sequences, because of the use of > `apply', `concat' and friends. Because the graph is finite, these seqs > should be finite as well, and most of the time one is interested in the > complete seqs of reachable vertices, anyway. Now the problem is, that > > (count my-lazy-seq) != (count (apply ordered-set my-lazy-seq)) > > although the basic functions -->, <->, <-- that all these expressions > boil down to return ordered-sets. So in my path iteration function > `p-+', which iterates the given path description one or many times, I > have to use this ugly code in order to specify a termination condition > (iteration may stop if nothing new is found anymore): > > (defn p-+ > "Path iteration starting at v and traversing p one or many times. > v may be a vertex or a seq of vertices. > p is a path description." > ([v p] > (p-+ (if (coll? v) v (ordered-set v)) p true)) > ([v p skip-v] > (let [n (p-apply v p) > ;; FIXME: > ;; The transformation into ordered set is needed, because it seems > ;; in the LazySeq form, (count vn) counts duplicates, which the > ;; backing ordered-set would suppress... > vn (apply ordered-set (concat v n))] > (if (and (not skip-v) > (= (count vn) (count v))) > vn > (recur (if skip-v n vn) p false))))) > > Ok, long story. I guess, my question is: > > Is there a way to drop lazyness completely for these path expression > functions? > > IMO, it doesn't make much sense in my context, because `p-+' has to > realize the seqs for its termination condition, and most of the time one > is interested in all reachable vertices, anyway. > > Bye, > Tassilo -- You received this message because you are subscribed to the Google Groups "Clojure" group. To post to this group, send email to clojure@googlegroups.com Note that posts from new members are moderated - please be patient with your first post. To unsubscribe from this group, send email to clojure+unsubscr...@googlegroups.com For more options, visit this group at http://groups.google.com/group/clojure?hl=en
