net.cgrand.xforms — net.cgrand/xforms 0.19.6

Extra transducers for Clojure

avg clj/s

by-key clj/s

(by-key xform)

(by-key kfn xform)

(by-key kfn vfn xform)

(by-key kfn vfn pair xform)

Returns a transducer which partitions items according to kfn. It applies the transform specified by xform to each partition. Partitions contain the "value part" (as returned by vfn) of each item. The resulting transformed items are wrapped back into a "pair" using the pair function. Default values for kfn, vfn and pair are first, second (or identity if kfn is specified) and vector.

count clj/s

(count rf)

(count xform coll)

Count the number of items. Either used directly as a transducer or invoked with two args as a transducing context.

destructuring-pair? clj/s

drop-last clj/s

(drop-last)

(drop-last n)

ensure-kvrf clj/s

(ensure-kvrf rf)

fast-satisfies?-fn clj

(fast-satisfies?-fn protocol-var)

Ported from https://github.com/clj-commons/manifold/blob/37658e91f836047a630586a909a2e22debfbbfc6/src/manifold/utils.clj#L77-L89

for clj/s macro

(for [binding %or_ & seq-exprs] body-expr)

Like clojure.core/for with the first expression being replaced by % (or _). Returns a transducer. When the first expression is not % (or _) returns an eduction.

into clj/s

(into to)

(into to from)

(into to xform from)

Like clojure.core/into but with a 1-arg arity returning a transducer which accumulate every input in a collection and outputs only the accumulated collection.

into-by-key clj/s

(into-by-key coll & by-key-args)

A shorthand for the common case (comp (x/by-key ...) (x/into coll)).

iterator clj

(iterator xform src-iterator)

Iterator transducing context, returns an iterator on the transformed data. Equivalent to (.iterator (eduction xform (iterator-seq src-iterator))) except there's is no buffering on values (as in iterator-seq), This buffering may cause problems when mutable objects are returned by the src-iterator.

keys clj/s

(keys rf)

kvreducible? clj/s≠

clj

(kvreducible? _)

Clojure 1.11 makes everything satisfy IKVReduce, so we can short-circuit

cljs

(kvreducible? coll)

kvrf clj/s macro

(kvrf name? & fn-bodies)

KvRfable clj/s protocol

Protocol for reducing fns that accept key and val as separate arguments.

some-kvrf clj/s

(some-kvrf f)

Returns a kvrf or nil

last clj/s

max clj/s

maximum clj/s

(maximum comparator)

(maximum comparator absolute-minimum)

min clj/s

minimum clj/s

(minimum comparator)

(minimum comparator absolute-maximum)

multiplex clj/s

(multiplex xforms)

Returns a transducer that runs several transducers (sepcified by xforms) in parallel. If xforms is a map, values of the map are transducers and keys are used to tag each transducer output: => (into [] (x/multiplex [(map inc) (map dec)]) (range 3)) [1 -1 2 0 3 1] ; no map, no tag => (into [] (x/multiplex {:up (map inc) :down (map dec)}) (range 3)) [[:up 1] [:down -1] [:up 2] [:down 0] [:up 3] [:down 1]]

partition clj/s

(partition n)

(partition n step-or-xform)

(partition n step pad-or-xform)

(partition n step pad xform)

Returns a partitioning transducer. Each partition is independently transformed using the xform transducer.

reduce clj/s

(reduce f)

(reduce f init)

A transducer that reduces a collection to a 1-item collection consisting of only the reduced result. Unlike reduce but like transduce it does call the completing arity (1) of the reducing fn.

reductions clj/s

(reductions f)

(reductions f init)

Transducer version of reductions. There's a difference in behavior when init is not provided: (f) is used. So x/reductions works like x/reduce or transduce, not like reduce and reductions when no init and 1-item input.

sd clj/s

some clj/s

(some xform coll)

Process coll through the specified xform and returns the first local true value.

sort clj/s

(sort)

(sort cmp)

sort-by clj/s

(sort-by kfn)

(sort-by kfn cmp)

str clj/s

(str xform coll)

When used as a value, it's an aggregating transducer that concatenates input values into a single output value. When used as a function of two args (xform and coll) it's a transducing context that concatenates all values in a string.

take-last clj/s

(take-last n)

time clj/s

(time xform)

(time tag-or-f xform)

Measures the time spent in this transformation and prints the measured time. tag-or-f may be either a function of 1 argument (measured time in ms) in which case this function will be called instead of printing, or tag-or-f will be print before the measured time.

transjuxt clj/s

(transjuxt xforms-map)

(transjuxt xforms-map coll)

Performs several transductions over coll at once. xforms-map can be a map or a sequential collection. When xforms-map is a map, returns a map with the same keyset as xforms-map. When xforms-map is a sequential collection returns a vector of same length as xforms-map. Returns a transducer when coll is omitted.

unreduced-> clj/s macro

(unreduced-> x)

(unreduced-> x expr & exprs)

Thread first while threaded value is not reduced. Doesn't unreduce the final value.

vals clj/s

(vals rf)

window clj/s

(window n f invf)

Returns a transducer which computes an accumulator over the last n items using two functions: f and its inverse invf.

The accumulator is initialized with (f). It is updated to (f (invf acc out) in) where "acc" is the current value, "in" the new item entering the window, "out" the item exiting the window. The value passed to the dowstream reducing function is (f acc) enabling acc to be mutable and 1-arity f to project its state to a value.

If you don't want to see the accumulator until the window is full then you need to use (drop (dec n)) to remove them.

If you don't have an inverse function, consider using partition and reduce: (x/partition 4 (x/reduce rf))

window-by-time clj

(window-by-time timef n f)

(window-by-time timef n f invf)

ALPHA Returns a transducer which computes a windowed accumulator over chronologically sorted items.

timef is a function from one item to its scaled timestamp (as a double). The window length is always 1.0 so timef must normalize timestamps. For example if timestamps are in seconds (and under the :ts key), to get a 1-hour window you have to use (fn [x] (/ (:ts x) 3600.0)) as timef.

n is the integral number of steps by which the window slides. With a 1-hour window, 4 means that the window slides every 15 minutes.

f and invf work like in #'window.

without clj/s

(without target)

(without target keys)

(without target xform keys)

The opposite of x/into: dissociate or disjoin from the target.

wrap clj/s

(wrap open close)

(wrap open close delim)

Transducer. Adds open as the first item, and close as the last. Optionally inserts delim between each input item.