com.cognitect.transducers

Class Fns

java.lang.Object

com.cognitect.transducers.Fns

public class Fns
extends Object

Constructor Summary

Constructors

Constructor and Description
Fns()

Method Summary

Methods

Modifier and Type	Method and Description
static <A,B extends Iterable<A>> ITransducer<A,B>	cat() Creates a transducer that transforms a reducing function by accepting an iterable of the expected input type and reducing it
static <R,T> IReducingFunction<R,? super T>	completing(IStepFunction<R,? super T> sf) Converts an step function into a complete reducing function.
static <A,B,C> ITransducer<A,C>	compose(ITransducer<B,C> left, ITransducer<A,B> right) Composes a transducer with another transducer, yielding a new transducer that
static <A> ITransducer<A,A>	dedupe() Creates a transducer that transforms a reducing function such that consecutive identical input values are removed, only a single value is processed.
static <A> ITransducer<A,A>	drop(long n) Creates a transducer that transforms a reducing function such that it skips n inputs, then processes the rest of the inputs.
static <A> ITransducer<A,A>	dropWhile(Predicate<A> p) Creates a transducer that transforms a reducing function such that it skips inputs as long as the provided predicate returns true.
static <A> ITransducer<A,A>	filter(Predicate<A> p) Creates a transducer that transforms a reducing function by applying a predicate to each input and processing only those inputs for which the predicate is true.
static <R extends Collection<A>,A,B> R	into(ITransducer<A,B> xf, R init, Iterable<B> input) Transduces input into collection using built-in reducing function.
static <A> ITransducer<A,A>	keep(Function<A,A> f) Creates a transducer that transforms a reducing function by applying a function to each input and processing the resulting value, ignoring values that are null.
static <A> ITransducer<A,A>	keepIndexed(BiFunction<Long,A,A> f) Creates a transducer that transforms a reducing function by applying a function to each input and processing the resulting value, ignoring values that are null.
static <A,B> ITransducer<A,B>	map(Function<B,A> f) Creates a transducer that transforms a reducing function by applying a mapping function to each input.
static <A,B extends Iterable<A>,C> ITransducer<A,C>	mapcat(Function<C,B> f) Creates a transducer that transforms a reducing function using a composition of map and cat.
static <A> ITransducer<Iterable<A>,A>	partitionAll(int n) Creates a transducer that transforms a reducing function that processes iterables of input into a reducing function that processes individual inputs by gathering series of inputs into partitions of a given size, only forwarding them to the next reducing function when enough inputs have been accrued.
static <A,P> ITransducer<Iterable<A>,A>	partitionBy(Function<A,P> f) Creates a transducer that transforms a reducing function that processes iterables of input into a reducing function that processes individual inputs by gathering series of inputs for which the provided partitioning function returns the same value, only forwarding them to the next reducing function when the value the partitioning function returns for a given input is different from the value returned for the previous input.
static <A> ITransducer<A,A>	randomSample(Double prob) Creates a transducer that transforms a reducing function such that it has the specified probability of processing each input.
static <A> ITransducer<A,A>	remove(Predicate<A> p) Creates a transducer that transforms a reducing function by applying a predicate to each input and not processing those inputs for which the predicate is true.
static <A> ITransducer<A,A>	replace(Map<A,A> smap) Creates a transducer that transforms a reducing function such that inputs that are keys in the provided map are replaced by the corresponding value in the map.
static <A> ITransducer<A,A>	take(long n) Creates a transducer that transforms a reducing function such that it only processes n inputs, then the reducing process stops.
static <A> ITransducer<A,A>	takeNth(long n) Creates a transducer that transforms a reducing function such that it processes every nth input.
static <A> ITransducer<A,A>	takeWhile(Predicate<A> p) Creates a transducer that transforms a reducing function such that it processes inputs as long as the provided predicate returns true.
static <R,A,B> R	transduce(ITransducer<A,B> xf, IReducingFunction<R,? super A> rf, Iterable<B> input) Reduces input using transformed reducing function.
static <R,A,B> R	transduce(ITransducer<A,B> xf, IStepFunction<R,? super A> rf, R init, Iterable<B> input) Reduces input using transformed reducing function.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

Fns

public Fns()

Method Detail

completing

public static <R,T> IReducingFunction<R,? super T> completing(IStepFunction<R,? super T> sf)

Converts an step function into a complete reducing function. If passed an IReducingFunction, which is an IStepFunction, returns it; otherwise returns a new instance of IReducingFunction with a step function that forwards to the given IStepFunction, a single-arity apply method (used for completing reduction) that returns its argument (it's an identity function), and a zero-arity apply method (used for initializing a new return value for a reduction if one is not provided) that throws an IllegalStateException.

Type Parameters:

R - the return type of the step function and reducing function

T - the input type of the step function and the reducing function

Parameters:

sf - The step function to convert to an IReducingFunction, if it is not one already

Returns:

a new reducing function, or the input step function if it is already a reducing function

transduce

public static <R,A,B> R transduce(ITransducer<A,B> xf,
                  IReducingFunction<R,? super A> rf,
                  Iterable<B> input)

Reduces input using transformed reducing function. Transforms reducing function by applying transducer. Reducing function must implement zero-arity apply that returns initial result to start reducing process.

Type Parameters:

R - return type

A - type of input expected by reducing function

B - type of input and type accepted by reducing function returned by transducer

Parameters:

xf - a transducer (or composed transducers) that transforms the reducing function

rf - a reducing function

input - the input to reduce

Returns:

result of reducing transformed input

transduce

public static <R,A,B> R transduce(ITransducer<A,B> xf,
                  IStepFunction<R,? super A> rf,
                  R init,
                  Iterable<B> input)

Reduces input using transformed reducing function. Transforms reducing function by applying transducer. Step function is converted to reducing function if necessary. Accepts initial value for reducing process as argument.

Type Parameters:

R - return type

A - type expected by reducing function

B - type of input and type accepted by reducing function returned by transducer

Parameters:

xf - a transducer (or composed transducers) that transforms the reducing function

rf - a reducing function

init - an initial value to start reducing process

input - the input to reduce

Returns:

result of reducing transformed input

into

public static <R extends Collection<A>,A,B> R into(ITransducer<A,B> xf,
                                   R init,
                                   Iterable<B> input)

Transduces input into collection using built-in reducing function.

Type Parameters:

R - return type

A - type the collection contains

B - type of input and type accepted by reducing function returned by transducer

Parameters:

xf - a transducer (or composed transducers) that transforms the reducing function

init - an initial collection to start reducing process

input - the input to put into the collection

Returns:

compose

public static <A,B,C> ITransducer<A,C> compose(ITransducer<B,C> left,
                               ITransducer<A,B> right)

Composes a transducer with another transducer, yielding a new transducer that

Type Parameters:

A - reducing function input type

B - reducing function input type

C - reducing function input type

Parameters:

left - left hand transducer

right - right hand transducer

Returns:

map

public static <A,B> ITransducer<A,B> map(Function<B,A> f)

Creates a transducer that transforms a reducing function by applying a mapping function to each input.

Type Parameters:

A - input type of input reducing function

B - input type of output reducing function

Parameters:

f - a mapping function from one type to another (can be the same type)

Returns:

a new transducer

filter

public static <A> ITransducer<A,A> filter(Predicate<A> p)

Creates a transducer that transforms a reducing function by applying a predicate to each input and processing only those inputs for which the predicate is true.

Type Parameters:

A - input type of input and output reducing functions

Parameters:

p - a predicate function

Returns:

a new transducer

cat

public static <A,B extends Iterable<A>> ITransducer<A,B> cat()

Creates a transducer that transforms a reducing function by accepting an iterable of the expected input type and reducing it

Type Parameters:

A - input type of input reducing function

B - input type of output reducing function

Returns:

a new transducer

mapcat

public static <A,B extends Iterable<A>,C> ITransducer<A,C> mapcat(Function<C,B> f)

Creates a transducer that transforms a reducing function using a composition of map and cat.

Type Parameters:

A - input type of input reducing function

B - output type of output reducing function and iterable of input type of input reducing function

C - input type of output reducing function

Parameters:

f - a mapping function from one type to another (can be the same type)

Returns:

a new transducer

remove

public static <A> ITransducer<A,A> remove(Predicate<A> p)

Creates a transducer that transforms a reducing function by applying a predicate to each input and not processing those inputs for which the predicate is true.

Type Parameters:

A - input type of input and output reducing functions

Parameters:

p - a predicate function

Returns:

a new transducer

take

public static <A> ITransducer<A,A> take(long n)

Creates a transducer that transforms a reducing function such that it only processes n inputs, then the reducing process stops.

Type Parameters:

A - input type of input and output reducing functions

Parameters:

n - the number of inputs to process

Returns:

a new transducer

takeWhile

public static <A> ITransducer<A,A> takeWhile(Predicate<A> p)

Creates a transducer that transforms a reducing function such that it processes inputs as long as the provided predicate returns true. If the predicate returns false, the reducing process stops.

Type Parameters:

A - input type of input and output reducing functions

Parameters:

p - a predicate used to test inputs

Returns:

a new transducer

drop

public static <A> ITransducer<A,A> drop(long n)

Creates a transducer that transforms a reducing function such that it skips n inputs, then processes the rest of the inputs.

Type Parameters:

A - input type of input and output reducing functions

Parameters:

n - the number of inputs to skip

Returns:

a new transducer

dropWhile

public static <A> ITransducer<A,A> dropWhile(Predicate<A> p)

Creates a transducer that transforms a reducing function such that it skips inputs as long as the provided predicate returns true. Once the predicate returns false, the rest of the inputs are processed.

Type Parameters:

A - input type of input and output reducing functions

Parameters:

p - a predicate used to test inputs

Returns:

a new transducer

takeNth

public static <A> ITransducer<A,A> takeNth(long n)

Creates a transducer that transforms a reducing function such that it processes every nth input.

Type Parameters:

A - The input type of the input and output reducing functions

Parameters:

n - The frequence of inputs to process (e.g., 3 processes every third input).

Returns:

a new transducer

replace

public static <A> ITransducer<A,A> replace(Map<A,A> smap)

Creates a transducer that transforms a reducing function such that inputs that are keys in the provided map are replaced by the corresponding value in the map.

Type Parameters:

A - the input type of the input and output reducing functions

Parameters:

smap - a map of replacement values

Returns:

a new transducer

keep

public static <A> ITransducer<A,A> keep(Function<A,A> f)

Creates a transducer that transforms a reducing function by applying a function to each input and processing the resulting value, ignoring values that are null.

Type Parameters:

A - the input type of the input and output reducing functions

Parameters:

f - a function for processing inputs

Returns:

a new transducer

keepIndexed

public static <A> ITransducer<A,A> keepIndexed(BiFunction<Long,A,A> f)

Creates a transducer that transforms a reducing function by applying a function to each input and processing the resulting value, ignoring values that are null.

Type Parameters:

A - the input type of the input and output reducing functions

Parameters:

f - a function for processing inputs

Returns:

a new transducer

dedupe

public static <A> ITransducer<A,A> dedupe()

Creates a transducer that transforms a reducing function such that consecutive identical input values are removed, only a single value is processed.

Type Parameters:

A - the input type of the input and output reducing functions

Returns:

a new transducer

randomSample

public static <A> ITransducer<A,A> randomSample(Double prob)

Creates a transducer that transforms a reducing function such that it has the specified probability of processing each input.

Type Parameters:

A - the input type of the input and output reducing functions

Parameters:

prob - the probability between expressed as a value between 0 and 1.

Returns:

a new transducer

partitionBy

public static <A,P> ITransducer<Iterable<A>,A> partitionBy(Function<A,P> f)

Creates a transducer that transforms a reducing function that processes iterables of input into a reducing function that processes individual inputs by gathering series of inputs for which the provided partitioning function returns the same value, only forwarding them to the next reducing function when the value the partitioning function returns for a given input is different from the value returned for the previous input.

Type Parameters:

A - the input type of the input and output reducing functions

P - the type returned by the partitioning function

Parameters:

f - the partitioning function

Returns:

a new transducer

partitionAll

public static <A> ITransducer<Iterable<A>,A> partitionAll(int n)

Creates a transducer that transforms a reducing function that processes iterables of input into a reducing function that processes individual inputs by gathering series of inputs into partitions of a given size, only forwarding them to the next reducing function when enough inputs have been accrued. Processes any remaining buffered inputs when the reducing process completes.

Type Parameters:

A - the input type of the input and output reducing functions

Parameters:

n - the size of each partition

Returns:

a new transducer