clojure.contrib.djui.coll — org.clojure.contrib/djui 1.10

Collection helper functions.

alternate clj

(alternate n coll)

Return a list of lists containing the items coll modulo n.

any-true? clj deprecated

(any-true? coll)

Returns a boolean if any value in coll is logically true. Deprecated: Use (any? coll).

any? clj

(any? coll)

(any? pred coll)

Returns a boolean representing if any value in coll is true. If pred is given, return if any value in coll satisfies pred.

create-map clj macro

(create-map & vars)

Return a map with a list of variable's name as keys and the variable's values as value.

deep-merge clj

(deep-merge & vals)

Like merge, but merges maps recursively. If vals are not maps, the last value wins.

deep-merge-with clj

(deep-merge-with f & vals)

Like merge-with, but merges maps recursively. If vals are not maps, (apply f vals) determines the winner.

distinct-by clj

(distinct-by ident coll)

Like distinct, but using ident as the identity function for elements.

Example: (distinct-by :b [{:a 2, :b 7} {:a 3, :b 7} {:a 4, :b 8}]) => [{:a 2, :b 7} {:a 4, :b 8}]) (distinct-by second [[:a 2] [:b 2] [:b 3]]) => [[:a 2] [:b 3]] (= (distinct-by identity [1 1 2 3 4 4 5]) (distinct [1 1 2 3 4 4 5])) => true

gapmap clj

(gapmap f coll)

Returns a lazy sequence consisting of the result of applying f to all adjacent values of coll. f should be a function taking 2 arguments. If coll contains less than 2 items, it is returned and f is not called.

pjuxt clj

(pjuxt & fns)

Like juxt, but parallelized.

pmapcat clj

(pmapcat f & colls)

Like mapcat but with parallelized map.

sequential! clj deprecated

(sequential! x)

Ensure x is sequential. If x is nil, nil is returned. Deprecated, use to-sequence instead.

sort-maps-by clj

(sort-maps-by coll & ks)

Sort a collection of maps on multiple keys. Items with a missing key have precedence.

Example: (sort-maps-by [{:a 2 :b 2} {:a 1} {:a 2 :b 1}] :a :b) => [{:a 1 :b 2} {:a 2 :b 1} {:a 2 :b 2}]

to-list clj

(to-list x)

Like list, but (to-list nil) returns nil.

to-sequence clj

(to-sequence x)

Like sequence, but (to-sequence nil) returns nil.

to-vector clj

(to-vector x)

Like vector, but (to-vector nil) returns nil.

tree-seq+ clj

(tree-seq+ branch?
           children
           root
           &
           [{:keys [parallel? limit]
             :or {parallel? true limit Double/POSITIVE_INFINITY}}])

Like tree-seq but, optionally, parallelized and with max. traversion limit.

unit clj

(unit coll)

Returns the value in a collection if it only contains one item; also know as singleton.

|> clj deprecated

(|> & args)

Piping/Thrushing, similar to F#'s or OCaml |>, or Haskells $. Limitations: Args are not evaluated lazily and functions can only take one argument (as last argument). Deprecated with Clojure 1.5, use clojure.core/-> or clojure.core/->> instead.