com.wsscode.misc.coll — com.wsscode/cljc-misc 2024.12.18

*deep-merge-handlers* clj/s

assoc-if clj/s

(assoc-if m k v)

(assoc-if m k v & kvs)

Like assoc, but noop if v is falsy.

coll-append-at-head? clj/s

(coll-append-at-head? s)

Return true if column add items at head with conj.

collection? clj/s

(collection? x)

Returns true for sequential collections and sets, false for maps.

conj-at-index clj/s

(conj-at-index v idx x)

Add element to a vector at some specific index. Only works with vectors!

dedupe-by clj/s

(dedupe-by f)

(dedupe-by f coll)

Returns a lazy sequence removing consecutive duplicates in coll when passed to a function f. Returns a transducer when no collection is provided.

deep-merge clj/s

(deep-merge & maps)

Recursively merges maps together. If all the maps supplied have nested maps under the same keys, these nested maps are merged.

A custom merge strategy may be configured for specific keys, to do so you need to bind the value of deep-merge-handlers, the keys are the keywords and the values are functions to handle the merge of that key.

(binding [*deep-merge-handlers* {:foo +}]
  (deep-merge {:foo 1} {:foo 2}))
; => {:foo 3}

Another way to control the merge of values is to set some metadata to control the merge process (notice it only applies for types that support meta like maps and vectors, but not for keywords or numbers for example).

(deep-merge {:list [1 2 3]} ^{::merge-with into} {:list [:a :b]})
; => {:list [1 2 3 :a :b]}

The meta may go in the left or side of the merge, the right side has higher priority.

Note that meta mergers have higher priority than merge handlers.

Here is the merger pick order for clarity:

1. Value merger from meta at new value
2. Value merger from meta at current value
3. Merge key handler
4. Deep merge (in case both values are maps)
5. Keep the new value (as in clojure.core/merge)

Forked from Medley library.

distinct-by clj/s

(distinct-by f)

(distinct-by f coll)

Returns a lazy sequence of the elements of coll, removing any elements that return duplicate values when passed to a function f.

filter-keys clj/s

(filter-keys f m)

filter-vals clj/s

(filter-vals f m)

find-first clj/s

(find-first f coll)

Return the first element in coll that returns true for f.

index-by clj/s

(index-by f coll)

Like group by, but will keep only the last result.

index-of clj/s

(index-of coll x)

Find the index of element x in coll. Return nil if element is not found.

iterate-while clj/s

(iterate-while f x)

Like iterate, but stops when it sees a nil value.

iterator clj/s

(iterator coll)

CLJC utility to get an iterator from the collection.

keep-current clj/s

(keep-current a _)

Merge util to keep the value from the left side.

keep-new clj/s

(keep-new _ b)

Merge util to keep the value from the right side.

keys-set clj/s

(keys-set m)

Return the map keys, as a set. This also checks if the entry is a map, otherwise returns nil (instead of throw).

make-map-entry clj/s

(make-map-entry k v)

CLJC helper to create MapEntry.

map-keys clj/s

(map-keys f m)

Map over the given hash-map keys.

Example: (map-keys #(str/replace (name %) "_" "-") {"foo_bar" 1}) => {"foo-bar" 1}

map-vals clj/s

(map-vals f m)

Map over the given hash-map vals.

Example: (map-vals inc {:a 1 :b 2})

merge-defaults clj/s

(merge-defaults m defaults)

Like merge, but only add keys that are not present in the original map.

merge-grow clj/s

(merge-grow)

(merge-grow a)

(merge-grow a b)

Additive merging.

When merging maps, it does a deep merge. When merging sets, makes a union of them.

When value of the right side is nil, the left side will be kept.

For the rest works as standard merge.

native-map? clj/s

(native-map? x)

queue clj/s

(queue)

(queue coll)

Return a blank immutable queue or create one from coll.

remove-keys clj/s

(remove-keys f m)

remove-vals clj/s

(remove-vals f m)

restore-order clj/s

(restore-order inputs key items)

(restore-order inputs key items default-fn)

Sorts output list to match input list order.

(coll/restore-order [{:id 1} {:id 2} {:id 3}] :id [{:id 4 :x "a"} {:id 1 :x "b"} {:id 3 :x "c"} {:id 2 :x "d"}])

=> [{:id 1 :x "b"} {:id 2 :x "d"} {:id 3 :x "c"}]

(coll/restore-order [{:id 1, :id2 1} {:id 2, :id2 0} {:id 3, :id2 1}] #(select-keys % [:id :id2]) [{:id 4 :id2 0 :x "a"} {:id 1 :id2 1 :x "b"} {:id 3 :id2 1 :x "c"} {:id 2 :id2 0 :x "d"}])

=> [{:id 1 :id2 1 :x "b"} {:id 2 :id2 0 :x "d"} {:id 3 :id2 1 :x "c"}]

Note it will also remove items that don't match anything in the original items list.

In case the items contains a matching key more than once, the last one will be taken.

restore-order2 clj/s

(restore-order2 inputs key items)

(restore-order2 inputs key default-fn items)

Same functionality as restore-order, but fixes the arguments order to make it easier to thread with a default-fn.

Also, it returns nil for not found items instead of a map with the key.

sconj clj/s

update-contained clj/s

(update-contained m k f)

(update-contained m k f a1)

(update-contained m k f a1 a2)

(update-contained m k f a1 a2 a3)

(update-contained m k f a1 a2 a3 & args)

Update some key when that key is present in the map.

update-if clj/s

(update-if m k f)

(update-if m k f a1)

(update-if m k f a1 a2)

(update-if m k f a1 a2 a3)

(update-if m k f a1 a2 a3 & args)

Update some key if that key is present in the map and value is truthy.

value-merger clj/s

(value-merger x)

vconj clj/s

vector-compare clj/s

(vector-compare [value1 & rest1] [value2 & rest2])

Compare two vectors, this expects the vectors to be ordered.