com.rpl.specter.defhelpers
define-ParamsNeededPath
macro
(define-ParamsNeededPath clj? fn-type invoke-name var-arity-impl)(define-ParamsNeededPath clj? fn-type invoke-name var-arity-impl)Takes a compiled path that needs late-bound params and supplies it with +an array of params and a position in the array from which to begin reading +params. The return value is an executable selector.
Version of replace-in that takes in a path precompiled with comp-paths +
Version of select-first that takes in a path pre-compiled with comp-paths +
Version of select-one that takes in a path pre-compiled with comp-paths +
Version of select-one! that takes in a path pre-compiled with comp-paths +
Version of transform that takes in a path pre-compiled with comp-paths +
(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. + +The input paths may be parameterized, in which case the result of cond-path +will be parameterized in the order of which the parameterized navigators +were declared.
(continue-then-stay & path)Navigates to the provided path and then to the current element. This can be used +to implement post-order traversal.
Navigates to every continuous subsequence of elements matching `pred` +
(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. + + The input path may be parameterized, in which case the result of filterer + will be parameterized in the order of which the parameterized selectors + were declared.
(if-path cond-p if-path)(if-path cond-p if-path else-path)Like cond-path, but with if semantics. +
(multi-path & paths)A path that branches on multiple paths. For updates, +applies updates to the paths in order.
Mandate that operations that do inline path factoring and compilation +(select/transform/setval/replace-in/path/etc.) must succeed in +factoring the path into static and dynamic portions. If not, an +error will be thrown and the reasons for not being able to factor +will be printed. Defaults to false, and `(must-cache-paths! false)` +can be used to turn this feature off. + +Reasons why it may not be able to factor a path include using +a local symbol, special form, or regular function invocation +where a navigator is expected.
Navigates to the provided val if the structure is nil. Otherwise it stays +navigated at the structure.
Keeps the element only if it matches the supplied predicate. This is the +late-bound parameterized version of using a function directly in a path.
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)
(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.
(select* path structure)Navigates to and returns a sequence of all the elements specified by the path. +
(select-first* path structure)Returns first element found. Not any more efficient than select, just a convenience +
(select-one!* path structure)Returns exactly one element, throws exception if zero or multiple elements found +
(select-one* path structure)Like select, but returns either one element or nil. Throws exception if multiple elements found +
(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. + +The input path may be parameterized, in which case the result of selected? +will be parameterized in the order of which the parameterized navigators +were declared.
(setval* path val structure)Navigates to each value specified by the path and replaces it by val +
Navigates to the subsequence bound by the indexes start (inclusive) +and end (exclusive)
Uses start-fn and end-fn to determine the bounds of the subsequence +to select when navigating. Each function takes in the structure as input.
(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.
Stops navigation at this point. For selection returns nothing and for +transformation returns the structure unchanged
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 & 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".
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.
(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 path update-fn)Navigates to a view of the current value by transforming it with the +specified path and update-fn. + +The input path may be parameterized, in which case the result of transformed +will be parameterized in the order of which the parameterized navigators +were declared.
(paramscollector params impl)Defines a Collector with late bound parameters. This collector can be precompiled +with other selectors without knowing the parameters. When precompiled with other +selectors, the resulting selector takes in parameters for all selectors in the path +that needed parameters (in the order in which they were declared). +
(path & path)Same as calling comp-paths, except it caches the composition of the static part +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.
(pathed-collector [name path] impl)This helper is used to define collectors that take in a single selector +paths as input. That path may require late-bound params, so this helper +will create a parameterized selector if that is the case. If no late-bound params +are required, then the result is executable.
Navigate the zipper to the first element +in the structure matching predfn. A linear scan +is done using NEXT to find the element.
Navigate to the subsequence containing only +the node currently pointed to. This works just +like srange and can be used to remove elements +from the structure
To install, add the following dependency to your project or build file:
[com.rpl/specter "0.11.1-SNAPSHOT"]
Public variables and functions: