com.rpl.specter — com.rpl/specter 1.1.4

AFTER-ELEM clj/s

(AFTER-ELEM)

Navigate to 'void' element after the sequence. For transformations – if result is not NONE, then append that value.

ALL clj/s

(ALL)

Navigate to every element of the collection. For maps navigates to a vector of [key value].

ALL-WITH-META clj/s

(ALL-WITH-META)

Same as ALL, except maintains metadata on the structure.

ATOM clj/s

(ATOM)

Navigates to atom value.

BEFORE-ELEM clj/s

(BEFORE-ELEM)

Navigate to 'void' element before the sequence. For transformations – if result is not NONE, then prepend that value.

before-index clj/s

(before-index index)

Navigates to the empty space between the index and the prior index. For select navigates to NONE, and transforms to non-NONE insert at that position.

BEGINNING clj/s

(BEGINNING)

Navigate to the empty subsequence before the first element of the collection.

codewalker clj/s

Like walker but maintains metadata of any forms traversed.

collect clj/s

(collect & path)

collect-one clj/s

(collect-one & path)

collected? clj/s macro

(collected? params & body)

Creates a filter function navigator that takes in all the collected values as input. For arguments, can use (collected? [a b] ...) syntax to look at each collected value as individual arguments, or (collected? v ...) syntax to capture all the collected values as a single vector.

collector clj/s macro

(collector params [_ [_ structure-sym] & body])

comp-paths clj/s

(comp-paths & apath)

Returns a compiled version of the given path for use with compiled-{select/transform/setval/etc.} functions.

compact clj/s

(compact & path)

During transforms, after each step of navigation in subpath check if the value is empty. If so, remove that value by setting it to NONE.

compiled-multi-transform clj/s

Version of multi-transform that takes in a path precompiled with comp-paths

compiled-replace-in clj/s

Version of replace-in that takes in a path precompiled with comp-paths

compiled-select clj/s

Version of select that takes in a path precompiled with comp-paths

compiled-select-any clj/s

Version of select-any that takes in a path precompiled with comp-paths

compiled-select-first clj/s

Version of select-first that takes in a path precompiled with comp-paths

compiled-select-one clj/s

Version of select-one that takes in a path precompiled with comp-paths

compiled-select-one! clj/s

Version of select-one! that takes in a path precompiled with comp-paths

compiled-selected-any? clj/s

Version of selected-any? that takes in a path precompiled with comp-paths

compiled-setval clj/s

Version of setval that takes in a path precompiled with comp-paths

compiled-transform clj/s

Version of transform that takes in a path precompiled with comp-paths

compiled-traverse clj/s

Version of traverse that takes in a path precompiled with comp-paths

compiled-traverse-all clj/s

Version of traverse-all that takes in a path precompiled with comp-paths

compiled-vtransform clj/s

Version of vtransform that takes in a path precompiled with comp-paths

cond-path clj/s

(cond-path & conds)

Takes in alternating cond-path path cond-path path... Tests the structure if selecting with cond-path returns anything. If so, it uses the following path for this portion of the navigation. Otherwise, it tries the next cond-path. If nothing matches, then the structure is not selected.

continue-then-stay clj/s

(continue-then-stay & path)

Navigates to the provided path and then to the current element. This can be used to implement post-order traversal.

continuous-subseqs clj/s

(continuous-subseqs pred)

Navigates to every continuous subsequence of elements matching pred

declarepath clj/s macro

(declarepath name)

defcollector clj/s macro

(defcollector name & body)

defdynamicnav clj/s macro

(defdynamicnav name & args)

Defines a function that can choose what navigator to use at runtime based on the dynamic context. The arguments will either be static values or objects satisfying dynamic-param?. Use late-bound-nav to produce a runtime navigator that uses the values of the dynamic params. See selected? for an illustrative example of dynamic navs.

defmacroalias clj/s macro

(defmacroalias name target)

defnav clj/s macro

defprotocolpath clj/s macro

(defprotocolpath name)

(defprotocolpath name params)

Defines a navigator that chooses the path to take based on the type of the value at the current point. May be specified with parameters to specify that all extensions must require that number of parameters.

Currently not available for ClojureScript.

Example of usage: (defrecord SingleAccount [funds]) (defrecord FamilyAccount [single-accounts])

(defprotocolpath FundsPath) (extend-protocolpath FundsPath SingleAccount :funds FamilyAccount [ALL FundsPath] )

defrichnav clj/s macro

DISPENSE clj/s

(DISPENSE)

Drops all collected values for subsequent navigation.

dynamic-param? clj/s

dynamicnav clj/s macro

(dynamicnav & args)

eachnav clj/s

(eachnav navfn)

END clj/s

(END)

Navigate to the empty subsequence after the last element of the collection.

end-fn clj/s macro

(end-fn & args)

extend-protocolpath clj/s macro

(extend-protocolpath protpath & extensions)

Used in conjunction with defprotocolpath. See defprotocolpath.

extend-protocolpath* clj

(extend-protocolpath* protpath-prot extensions)

filterer clj/s

(filterer & path)

Navigates to a view of the current sequence that only contains elements that match the given path. An element matches the selector path if calling select on that element with the path yields anything other than an empty sequence.

For transformation: NONE entries in the result sequence cause corresponding entries in input to be removed. A result sequence smaller than the input sequence is equivalent to padding the result sequence with NONE at the end until the same size as the input.

FIRST clj/s

Navigate to the first element of the collection. If the collection is empty navigation is stopped at this point.

if-path clj/s

(if-path cond-p then-path)

(if-path cond-p then-path else-path)

Like cond-path, but with if semantics.

index-nav clj/s

(index-nav i)

Navigates to the index of the sequence if within 0 and size. Transforms move element at that index to the new index, shifting other elements in the sequence.

INDEXED-VALS clj/s

indexed-vals with a starting index of 0.

indexed-vals clj/s

(indexed-vals start)

Navigate to [index elem] pairs for each element in a sequence. The sequence will be indexed starting from start. Changing index in transform has same effect as index-nav. Indices seen during transform take into account any shifting from prior sequence elements changing indices.

keypath clj/s

Navigate to the specified keys one after another. If navigate to NONE, that element is removed from the map or vector.

LAST clj/s

Navigate to the last element of the collection. If the collection is empty navigation is stopped at this point.

late-bound-collector clj/s macro

(late-bound-collector bindings impl)

late-bound-nav clj/s macro

(late-bound-nav bindings & impls)

late-bound-richnav clj/s macro

(late-bound-richnav bindings & impls)

late-path clj/s

late-resolved-fn clj/s

local-declarepath clj/s

map-key clj/s

(map-key key)

Navigates to the given key in the map (not to the value). Navigates only if the key currently exists in the map. Can transform to NONE to remove the key/value pair from the map.

MAP-KEYS clj/s

(MAP-KEYS)

Navigate to each key of the map. This is more efficient than navigating via [ALL FIRST]

MAP-VALS clj/s

(MAP-VALS)

Navigate to each value of the map. This is more efficient than navigating via [ALL LAST]

META clj/s

(META)

Navigates to the metadata of the structure, or nil if the structure has no metadata or may not contain metadata.

multi-path clj/s

(multi-path)

(multi-path path)

(multi-path path1 path2)

(multi-path path1 path2 & paths)

A path that branches on multiple paths. For updates, applies updates to the paths in order.

multi-transform clj/s macro

(multi-transform apath structure)

Just like transform but expects transform functions to be specified inline in the path using terminal or vterminal. Error is thrown if navigation finishes at a non-terminal navigator. terminal-val is a wrapper around terminal and is the multi-transform equivalent of setval. This macro will do inline caching of the path.

multi-transform* clj/s

(multi-transform* path structure)

Just like transform but expects transform functions to be specified inline in the path using terminal or vterminal. Error is thrown if navigation finishes at a non-terminal navigator. terminal-val is a wrapper around terminal and is the multi-transform equivalent of setval.

must clj/s

Navigate to the specified keys one after another, only if they exist in the data structure. If navigate to NONE, that element is removed from the map or vector.

NAME clj/s

(NAME)

Navigates to the name portion of the keyword or symbol

NAMESPACE clj/s

(NAMESPACE)

Navigates to the namespace portion of the keyword or symbol

nav clj/s macro

NIL->LIST clj/s

Navigates to '() if the value is nil. Otherwise it stays navigated at the current value.

NIL->SET clj/s

Navigates to #{} if the value is nil. Otherwise it stays navigated at the current value.

nil->val clj/s

(nil->val v)

Navigates to the provided val if the structure is nil. Otherwise it stays navigated at the structure.

NIL->VECTOR clj/s

Navigates to [] if the value is nil. Otherwise it stays navigated at the current value.

NONE clj/s

Global value used to indicate no elements selected during select-any.

NONE-ELEM clj/s

(NONE-ELEM)

Navigate to 'void' elem in the set. For transformations - if result is not NONE, then add that value to the set.

not-selected? clj/s

(not-selected? & path)

nthpath clj/s

Navigate to the specified indices one after another. If navigate to NONE, that element is removed from the sequence.

parser clj/s

(parser parse-fn unparse-fn)

Navigate to the result of running parse-fn on the value. For transforms, the transformed value then has unparse-fn run on it to get the final value at this point.

path clj/s macro

(path & path)

Same as calling comp-paths, except it caches the composition of the static parts of the path for later re-use (when possible). For almost all idiomatic uses of Specter provides huge speedup. This macro is automatically used by the select/transform/setval/replace-in/etc. macros.

pred clj/s

Keeps the element only if it matches the supplied predicate. Functions in paths implicitly convert to this navigator.

pred< clj/s

(pred< v)

pred<= clj/s

(pred<= v)

pred= clj/s

(pred= v)

pred> clj/s

(pred> v)

pred>= clj/s

(pred>= v)

providepath clj/s macro

(providepath name apath)

putval clj/s

Adds an external value to the collected vals. Useful when additional arguments are required to the transform function that would otherwise require partial application or a wrapper function.

e.g., incrementing val at path [:a :b] by 3: (transform [:a :b (putval 3)] + some-map)

recursive-path clj/s macro

(recursive-path params self-sym path)

regex-nav clj/s

(regex-nav re)

replace-in clj/s macro

(replace-in apath transform-fn structure & args)

Similar to transform, except returns a pair of [transformed-structure sequence-of-user-ret]. The transform-fn in this case is expected to return [ret user-ret]. ret is what's used to transform the data structure, while user-ret will be added to the user-ret sequence in the final return. replace-in is useful for situations where you need to know the specific values of what was transformed in the data structure. This macro will do inline caching of the path.

replace-in* clj/s

(replace-in* path
             transform-fn
             structure
             &
             {:keys [merge-fn] :or {merge-fn concat}})

Similar to transform, except returns a pair of [transformed-structure sequence-of-user-ret]. The transform-fn in this case is expected to return [ret user-ret]. ret is what's used to transform the data structure, while user-ret will be added to the user-ret sequence in the final return. replace-in is useful for situations where you need to know the specific values of what was transformed in the data structure.

richnav clj/s macro

satisfies-protpath? clj/s macro

(satisfies-protpath? protpath o)

select clj/s macro

(select apath structure)

Navigates to and returns a sequence of all the elements specified by the path. This macro will do inline caching of the path.

select* clj/s

(select* path structure)

Navigates to and returns a sequence of all the elements specified by the path.

select-any clj/s macro

(select-any apath structure)

Returns any element found or NONE if nothing selected. This is the most efficient of the various selection operations. This macro will do inline caching of the path.

select-any* clj/s

(select-any* path structure)

Returns any element found or NONE if nothing selected. This is the most efficient of the various selection operations.

select-first clj/s macro

(select-first apath structure)

Returns first element found. This macro will do inline caching of the path.

select-first* clj/s

(select-first* path structure)

Returns first element found.

select-one clj/s macro

(select-one apath structure)

Like select, but returns either one element or nil. Throws exception if multiple elements found. This macro will do inline caching of the path.

select-one! clj/s macro

(select-one! apath structure)

Returns exactly one element, throws exception if zero or multiple elements found. This macro will do inline caching of the path.

select-one!* clj/s

(select-one!* path structure)

Returns exactly one element, throws exception if zero or multiple elements found

select-one* clj/s

(select-one* path structure)

Like select, but returns either one element or nil. Throws exception if multiple elements found

selected-any? clj/s macro

(selected-any? apath structure)

Returns true if any element was selected, false otherwise. This macro will do inline caching of the path.

selected-any?* clj/s

(selected-any?* path structure)

Returns true if any element was selected, false otherwise.

selected? clj/s

(selected? & path)

Filters the current value based on whether a path finds anything. e.g. (selected? :vals ALL even?) keeps the current element only if an even number exists for the :vals key.

set-elem clj/s

(set-elem elem)

Navigates to the given element in the set only if it exists in the set. Can transform to NONE to remove the element from the set.

setval clj/s macro

(setval apath aval structure)

Navigates to each value specified by the path and replaces it by aval. This macro will do inline caching of the path.

setval* clj/s

(setval* path val structure)

Navigates to each value specified by the path and replaces it by val

srange clj/s

(srange start end)

Navigates to the subsequence bound by the indexes start (inclusive) and end (exclusive)

srange-dynamic clj/s

(srange-dynamic start-index-fn end-index-fn)

Uses start-index-fn and end-index-fn to determine the bounds of the subsequence to select when navigating. start-index-fn takes in the structure as input. end-index-fn can be one of two forms. If a regular function (e.g. defined with fn), it takes in only the structure as input. If a function defined using special end-fn macro, it takes in the structure and the result of start-index-fn.

STAY clj/s

Stays navigated at the current point. Essentially a no-op navigator.

stay-then-continue clj/s

(stay-then-continue & path)

Navigates to the current element and then navigates via the provided path. This can be used to implement pre-order traversal.

STOP clj/s

(STOP)

Stops navigation at this point. For selection returns nothing and for transformation returns the structure unchanged

submap clj/s

(submap m-keys)

Navigates to the specified submap (using select-keys). In a transform, that submap in the original map is changed to the new value of the submap.

subselect clj/s

(subselect & path)

Navigates to a sequence that contains the results of (select ...), but is a view to the original structure that can be transformed.

Requires that the input navigators will walk the structure's children in the same order when executed on "select" and then "transform".

If transformed sequence is smaller than input sequence, missing entries will be filled in with NONE, triggering removal if supported by that navigator.

Value collection (e.g. collect, collect-one) may not be used in the subpath.

subset clj/s

(subset aset)

Navigates to the specified subset (by taking an intersection). In a transform, that subset in the original set is changed to the new value of the subset.

terminal clj/s

Defines an endpoint in the navigation the transform function run. The transform function works just like it does in transform, with collected values given as the first arguments

terminal-val clj/s

(terminal-val v)

Like terminal but specifies a val to set at the location regardless of the collected values or the value at the location.

transform clj/s macro

(transform apath transform-fn structure)

Navigates to each value specified by the path and replaces it by the result of running the transform-fn on it. This macro will do inline caching of the path.

transform* clj/s

(transform* path transform-fn structure)

Navigates to each value specified by the path and replaces it by the result of running the transform-fn on it

transformed clj/s

(transformed path update-fn)

Navigates to a view of the current value by transforming it with the specified path and update-fn.

traverse clj/s macro

(traverse apath structure)

Return a reducible object that traverses over structure to every element specified by the path. This macro will do inline caching of the path.

traverse* clj/s

(traverse* apath structure)

Return a reducible object that traverses over structure to every element specified by the path

traverse-all clj/s macro

(traverse-all apath)

Returns a transducer that traverses over each element with the given path.

traverse-all* clj/s

(traverse-all* apath)

Returns a transducer that traverses over each element with the given path.

traversed clj/s

(traversed path reduce-fn)

Navigates to a view of the current value by transforming with a reduction over the specified traversal.

VAL clj/s

view clj/s

(view afn)

Navigates to result of running afn on the currently navigated value.

vterminal clj/s

Defines an endpoint in the navigation the transform function run.The transform function works differently than it does in transform. Rather than receive collected vals spliced in as the first arguments to the function, this function always takes two arguemnts. The first is all collected vals in a vector, and the second is the navigated value.

vtransform clj/s macro

(vtransform apath transform-fn structure)

Navigates to each value specified by the path and replaces it by the result of running the transform-fn on two arguments: the collected values as a vector, and the navigated value.

walker clj/s

Navigate the data structure until reaching a value for which afn returns truthy. Has same semantics as clojure.walk.

with-fresh-collected clj/s

(with-fresh-collected & path)

with-inline-debug clj/s macro

(with-inline-debug & body)

wrap-dynamic-nav clj/s

(wrap-dynamic-nav f)