Clojure

Add seqable? predicate

Details

  • Type: Enhancement Enhancement
  • Status: Open Open
  • Priority: Major Major
  • Resolution: Unresolved
  • Affects Version/s: None
  • Fix Version/s: None
  • Component/s: None
  • Labels:
    None
  • Approval:
    Triaged

Description

Many people have found a need for this function and one exists in clojure.core.incubator that is sometimes used and/or copied elsewhere:

https://github.com/clojure/core.incubator/blob/master/src/main/clojure/clojure/core/incubator.clj#L83

This predicate would be valuable to have as it is not a simple check on Seqable since RT.seq() covers a number of additional cases. Alternatively, there could be a protocol for this that could be extended to both Seqable as well as other supported Java use cases turning this into a satisfies? check.

Old prior discussion (although this also comes up regularly on #clojure):

Activity

Alex Miller made changes -
Field Original Value New Value
Fix Version/s Backlog [ 10035 ]
Alex Miller made changes -
Priority Major [ 3 ]
Alex Miller made changes -
Approval Triaged [ 10120 ]
Reporter Alex Miller [ alexmiller ]
Nicola Mometto made changes -
Description This was vaguely discussed [here|http://groups.google.com/group/clojure/browse_thread/thread/c9eef488d27bdf37] and could potenntially help [this ticket|http://www.assembla.com/spaces/clojure/support/tickets/400-a-faster-flatten] as well as be generally useful.

I don't speak for everyone but when I saw sequential? I assumed it would have the semantics that seqable? does. Just my opinion, I'd love to hear someone's who is more informed than mine.

In the proposed patch referenced in the ticket above, if seqable? could be used in place of sequential? flatten could be more powerful and work with maps/sets/java collections. Here's how it would look:
{code}(defn flatten [coll]
  (lazy-seq
    (when-let [coll (seq coll)]
      (let [x (first coll)]
        (if (seqable? x)
          (concat (flatten x) (flatten (next coll)))
          (cons x (flatten (next coll))))))))
{code}
And an example:

user=> (flatten #{1 2 3 #{4 5 {6 {7 [8 9 10 #{11 12 (java.util.ArrayList. [13 14 15]) (int-array [16 17 18])}]}}}})
(1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18)
This was vaguely discussed [here|http://groups.google.com/group/clojure/browse_thread/thread/c9eef488d27bdf37] and could potenntially help [this ticket|http://www.assembla.com/spaces/clojure/support/tickets/400-a-faster-flatten] as well as be generally useful.

I don't speak for everyone but when I saw sequential? I assumed it would have the semantics that seqable? does. Just my opinion, I'd love to hear someone's who is more informed than mine.

In the proposed patch referenced in the ticket above, if seqable? could be used in place of sequential? flatten could be more powerful and work with maps/sets/java collections. Here's how it would look:
{code}(defn flatten [coll]
  (lazy-seq
    (when-let [coll (seq coll)]
      (let [x (first coll)]
        (if (seqable? x)
          (concat (flatten x) (flatten (next coll)))
          (cons x (flatten (next coll))))))))
{code}
And an example:
{code}
user=> (flatten #{1 2 3 #{4 5 {6 {7 [8 9 10 #{11 12 (java.util.ArrayList. [13 14 15]) (int-array [16 17 18])}]}}}})
(1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18)
{code}
Alex Miller made changes -
Description This was vaguely discussed [here|http://groups.google.com/group/clojure/browse_thread/thread/c9eef488d27bdf37] and could potenntially help [this ticket|http://www.assembla.com/spaces/clojure/support/tickets/400-a-faster-flatten] as well as be generally useful.

I don't speak for everyone but when I saw sequential? I assumed it would have the semantics that seqable? does. Just my opinion, I'd love to hear someone's who is more informed than mine.

In the proposed patch referenced in the ticket above, if seqable? could be used in place of sequential? flatten could be more powerful and work with maps/sets/java collections. Here's how it would look:
{code}(defn flatten [coll]
  (lazy-seq
    (when-let [coll (seq coll)]
      (let [x (first coll)]
        (if (seqable? x)
          (concat (flatten x) (flatten (next coll)))
          (cons x (flatten (next coll))))))))
{code}
And an example:
{code}
user=> (flatten #{1 2 3 #{4 5 {6 {7 [8 9 10 #{11 12 (java.util.ArrayList. [13 14 15]) (int-array [16 17 18])}]}}}})
(1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18)
{code}
Many people have found a need for this function and one exists in clojure.core.incubator that is sometimes used and/or copied elsewhere:

https://github.com/clojure/core.incubator/blob/master/src/main/clojure/clojure/core/incubator.clj#L83

This predicate would be valuable to have as it is not a simple check on Seqable since RT.seq() covers a number of additional cases. Alternatively, there could be a protocol for this that could be extended to both Seqable as well as other supported Java use cases turning this into a satisfies? check.

Old prior discussion (although this also comes up regularly on #clojure):
* http://groups.google.com/group/clojure/browse_thread/thread/c9eef488d27bdf37

Summary Promote "seqable?" from contrib? Add seqable? predicate

People

Vote (5)
Watch (3)

Dates

  • Created:
    Updated: