(->collection item)
Ensure an item implements java.util.Collection. This is inherently true for seqs and any implementation of java.util.List but not true for object arrays. For maps this returns the entry set.
Ensure an item implements java.util.Collection. This is inherently true for seqs and any implementation of java.util.List but not true for object arrays. For maps this returns the entry set.
(->random-access item)
(->reducible item)
(apply-concat)
(apply-concat data)
(concat)
(concat a)
(concat a & args)
(constant-count data)
Constant time count. Returns nil if input doesn't have a constant time count.
Constant time count. Returns nil if input doesn't have a constant time count.
(constant-countable? data)
(filter pred)
(filter pred coll)
(into-array aseq)
(into-array ary-type aseq)
(into-array ary-type mapfn aseq)
(make-readonly-list n idxvar read-code)
(make-readonly-list cls-type-kwd n idxvar read-code)
Implement a readonly list. If cls-type-kwd is provided it must be, at compile time, either :int64, :float64 or :object and the getLong, getDouble or get interface methods will be filled in, respectively. In those cases read-code must return the appropriate type.
Implement a readonly list. If cls-type-kwd is provided it must be, at compile time, either :int64, :float64 or :object and the getLong, getDouble or get interface methods will be filled in, respectively. In those cases read-code must return the appropriate type.
(map f)
(map f arg)
(map f arg & args)
(map-indexed map-fn coll)
(map-reducible f r)
Map a function over r - r need only be reducible. Returned value does not implement seq but is countable when r is countable countable.
Map a function over r - r need only be reducible. Returned value does not implement seq but is countable when r is countable countable.
(object-array item)
Faster version of object-array for eductions, java collections and strings.
Faster version of object-array for eductions, java collections and strings.
(partition-by f)
(partition-by f coll)
(partition-by f options coll)
Lazy noncaching version of partition-by. For reducing partitions into a singular value please see
apply-concat
. Return value most efficiently implements reduce with a slightly less efficient
implementation of Iterable.
Unlike clojure.core/partition-by this does not store intermediate elements nor does it build up intermediate containers. This makes it somewhat faster in most contexts.
Each sub-collection must be iterated through entirely before the next method of the parent iterator else the result will not be correct.
Options:
:ignore-leftover?
- When true leftover items in the previous iteration do not cause an exception.
Defaults to false.user> ;;incorrect - inner items not iterated and non-caching!
user> (into [] (lznc/partition-by identity [1 1 1 2 2 2 3 3 3]))
Execution error at ham_fisted.lazy_noncaching.PartitionBy/reduce (lazy_noncaching.clj:514).
Sub-collection was not entirely consumed.
user> ;;correct - transducing form of into calls vec on each sub-collection
user> ;;thus iterating through it entirely.
user> (into [] (map vec) (lznc/partition-by identity [1 1 1 2 2 2 3 3 3]))
[[1 1 1] [2 2 2] [3 3 3]]
user> (def init-data (vec (lznc/apply-concat (lznc/map #(repeat 100 %) (range 1000)))))
#'user/init-data
user> (crit/quick-bench (mapv hamf/sum-fast (lznc/partition-by identity init-data)))
Execution time mean : 366.915796 µs
...
nil
user> (crit/quick-bench (mapv hamf/sum-fast (clojure.core/partition-by identity init-data)))
Execution time mean : 6.699424 ms
...
nil
user> (crit/quick-bench (into [] (comp (clojure.core/partition-by identity)
(map hamf/sum-fast)) init-data))
Execution time mean : 1.705864 ms
...
Lazy noncaching version of partition-by. For reducing partitions into a singular value please see [[apply-concat]]. Return value most efficiently implements reduce with a slightly less efficient implementation of Iterable. Unlike clojure.core/partition-by this does not store intermediate elements nor does it build up intermediate containers. This makes it somewhat faster in most contexts. Each sub-collection must be iterated through entirely before the next method of the parent iterator else the result will not be correct. Options: * `:ignore-leftover?` - When true leftover items in the previous iteration do not cause an exception. Defaults to false. ```clojure user> ;;incorrect - inner items not iterated and non-caching! user> (into [] (lznc/partition-by identity [1 1 1 2 2 2 3 3 3])) Execution error at ham_fisted.lazy_noncaching.PartitionBy/reduce (lazy_noncaching.clj:514). Sub-collection was not entirely consumed. user> ;;correct - transducing form of into calls vec on each sub-collection user> ;;thus iterating through it entirely. user> (into [] (map vec) (lznc/partition-by identity [1 1 1 2 2 2 3 3 3])) [[1 1 1] [2 2 2] [3 3 3]] user> (def init-data (vec (lznc/apply-concat (lznc/map #(repeat 100 %) (range 1000))))) #'user/init-data user> (crit/quick-bench (mapv hamf/sum-fast (lznc/partition-by identity init-data))) Execution time mean : 366.915796 µs ... nil user> (crit/quick-bench (mapv hamf/sum-fast (clojure.core/partition-by identity init-data))) Execution time mean : 6.699424 ms ... nil user> (crit/quick-bench (into [] (comp (clojure.core/partition-by identity) (map hamf/sum-fast)) init-data)) Execution time mean : 1.705864 ms ... ```
(reindex coll indexes)
Permut coll by the given indexes. Result is random-access and the same length as the index collection. Indexes are expected to be in the range of [0->count(coll)).
Permut coll by the given indexes. Result is random-access and the same length as the index collection. Indexes are expected to be in the range of [0->count(coll)).
(remove pred)
(remove pred coll)
Returns a lazy sequence of the items in coll for which (pred item) returns logical false. pred must be free of side-effects. Returns a transducer when no collection is provided.
Returns a lazy sequence of the items in coll for which (pred item) returns logical false. pred must be free of side-effects. Returns a transducer when no collection is provided.
(repeatedly f)
(repeatedly n f)
(repeatedly n f opts)
When called with one argument, produce infinite list of calls to v. When called with two arguments, produce a random access list of length n of calls to v.
When called with one argument, produce infinite list of calls to v. When called with two arguments, produce a random access list of length n of calls to v.
(seed->random seed)
(shift n coll)
Shift a collection forward or backward repeating either the first or the last entries. Returns a random access list with the same elements as coll.
Example:
ham-fisted.api> (shift 2 (range 10))
[0 0 0 1 2 3 4 5 6 7]
ham-fisted.api> (shift -2 (range 10))
[2 3 4 5 6 7 8 9 9 9]
Shift a collection forward or backward repeating either the first or the last entries. Returns a random access list with the same elements as coll. Example: ```clojure ham-fisted.api> (shift 2 (range 10)) [0 0 0 1 2 3 4 5 6 7] ham-fisted.api> (shift -2 (range 10)) [2 3 4 5 6 7 8 9 9 9] ```
(shuffle coll)
(shuffle coll opts)
shuffle values returning random access container.
Options:
:seed
- If instance of java.util.Random, use this. If integer, use as seed.
If not provided a new instance of java.util.Random is created.shuffle values returning random access container. Options: * `:seed` - If instance of java.util.Random, use this. If integer, use as seed. If not provided a new instance of java.util.Random is created.
cljdoc is a website building & hosting documentation for Clojure/Script libraries
× close