Documentation / dataflow / com.femastudios.dataflow / Field
Go to reference

Field

interface Field<out T>

A Field is an object that holds a value (of type T), and allows to register (and cancel) callbacks for data changes.

Methods in this interface support only read-only access to the value; read-write access is supported through the MutableField interface.

To access the value, you can use the property value.

To register (or cancel) callbacks, you can use the ListenersManager exposed through listeners.

To create a new constant Field, you can use the function fieldOf or Field.of. To create a new MutableField, you can use the function mutableFieldOf or MutableField.of.

Properties

listeners	Returns the ListenersManager associated with this Field. `open val listeners: ListenersManager<FieldListener<T>>`
value	The current value of this Field. `abstract val value: T`

Functions

getValueWithoutComputing	Returns the current value without triggering any computation. For some Fields, this is equivalent to calling value. For others, this method will return an old value. `open fun getValueWithoutComputing(): T`
hashCodeF	Returns a new Field whose value is the hash code of value, according to hashCode. `open fun hashCodeF(): Field<Int>`
isChangedSince	Returns whether the content of this field has changed since the provided tick `abstract fun isChangedSince(tick: Long): Boolean`
isNotNull	Returns a new Field whose value is true if and only if the value of this Field is not `null`. `open fun isNotNull(): Field<Boolean>`
isNull	Returns a new Field whose value is true if and only if the value of this Field is `null`. `open fun isNull(): Field<Boolean>`
listeners	Returns the ListenersManager associated with this Field. `abstract fun listeners(): ListenersManager<FieldListener<T>>`
pair	Returns a new Field, whose value is a Pair having as first element the value of this Field and as second element the value of another. `open infix fun <O> pair(another: Field<O>): Field<Pair<T, O>>`
then	Returns a new Field<O> that mirrors the Field returned by transform applied to the value of this Field. `open fun <O> then(transform: (T) -> Field<O>): Field<O>`
toStringF	Returns a new Field whose value is the string representation of value, according to toString. `open fun toStringF(): Field<String>`
transform	Returns a new Field<O>, whose value is the transform applied to the value of this Field. `open fun <O> transform(transform: (T) -> O): Field<O>`
transformWithPrevious	Like Field.transform, but the transform function also accepts the previous transformed value. `open fun <O> transformWithPrevious(transform: (previous: O?, T) -> O): Field<O>` `open fun <O> transformWithPrevious(transform: (previous: O?, T) -> O, allowLaziness: Boolean): Field<O>`

Companion Object Functions

of	Construct a constant Field with the given value `fun <T> of(value: T): Field<T>`
ofLazy	Constructs a constant lazy Field whose value is computed using initialValueComputer. `fun <T> ofLazy(initialValueComputer: () -> T): Field<T>`
ofNull	Returns a constant Field that holds `null` `fun <T> ofNull(): Field<T?>`

Extension Functions

abs	Same as abs, but accepts Field and returns a new Field. `fun Field<BigDecimal>.abs(): Field<BigDecimal>` `fun Field<BigDecimal>.abs(mc: Field<MathContext>): Field<BigDecimal>` `fun Field<BigDecimal>.abs(mc: MathContext): Field<BigDecimal>` Same as abs, but accepts Field and returns a new Field. `fun Field<BigInteger>.abs(): Field<BigInteger>` Same as absoluteValue, but returns a new Field `fun Field<Double>.abs(): Field<Double>` `fun Field<Float>.abs(): Field<Float>` `fun Field<Int>.abs(): Field<Int>` `fun Field<Long>.abs(): Field<Long>`
add	Same as add, but accepts Field and returns a new Field. `fun Field<BigDecimal>.add(augend: Field<BigDecimal>, mc: Field<MathContext>): Field<BigDecimal>` `fun Field<BigDecimal>.add(augend: Field<BigDecimal>, mc: MathContext): Field<BigDecimal>` `fun Field<BigDecimal>.add(augend: BigDecimal, mc: Field<MathContext>): Field<BigDecimal>` `fun Field<BigDecimal>.add(augend: BigDecimal, mc: MathContext): Field<BigDecimal>`
aggregate	Same as aggregate, but accepts Field and returns a new Field. `fun <T, K, R> Field<Grouping<T, K>>.aggregate(operation: (key: K, accumulator: R?, element: T, first: Boolean) -> R): Field<Map<K, R>>`
all	Same as all, but accepts Field and returns a new Field. `fun <T> Field<Iterable<T>>.all(predicate: (T) -> Boolean): Field<Boolean>` `fun <K, V> Field<Map<K, V>>.all(predicate: (Entry<K, V>) -> Boolean): Field<Boolean>` Same as all, but accepts Field and returns a new Field. `fun <T> Field<Sequence<T>>.all(predicate: (T) -> Boolean): Field<Boolean>` Same as all, but accepts Field and returns a new Field. `fun Field<String>.all(predicate: (Char) -> Boolean): Field<Boolean>`
allF	Same as all, but accepts Field and returns a new Field. `fun <T> Field<Iterable<T>>.allF(predicate: (T) -> Field<Boolean>): Field<Boolean>` `fun <K, V> Field<Map<K, V>>.allF(predicate: (Entry<K, V>) -> Field<Boolean>): Field<Boolean>`
and	Same as and, but accepts Field and returns a new Field. `infix fun Field<BigInteger>.and(other: Field<BigInteger>): Field<BigInteger>` `infix fun Field<BigInteger>.and(other: BigInteger): Field<BigInteger>` Same as and, but accepts Field and returns a new Field. `infix fun Field<Boolean>.and(other: Field<Boolean>): Field<Boolean>` `infix fun Field<Boolean>.and(other: Boolean): Field<Boolean>` Same as and, but accepts Field and returns a new Field. `infix fun Field<Int>.and(other: Field<Int>): Field<Int>` `infix fun Field<Int>.and(other: Int): Field<Int>` Same as and, but accepts Field and returns a new Field. `infix fun Field<Long>.and(other: Field<Long>): Field<Long>` `infix fun Field<Long>.and(other: Long): Field<Long>`
andNot	Same as andNot, but accepts Field and returns a new Field. `fun Field<BigInteger>.andNot(val: Field<BigInteger>): Field<BigInteger>` `fun Field<BigInteger>.andNot(val: BigInteger): Field<BigInteger>`
any	Same as any, but accepts Field and returns a new Field. `fun <T> Field<Iterable<T>>.any(): Field<Boolean>` `fun <T> Field<Iterable<T>>.any(predicate: (T) -> Boolean): Field<Boolean>` `fun <K, V> Field<Map<K, V>>.any(): Field<Boolean>` `fun <K, V> Field<Map<K, V>>.any(predicate: (Entry<K, V>) -> Boolean): Field<Boolean>` Same as any, but accepts Field and returns a new Field. `fun <T> Field<Sequence<T>>.any(): Field<Boolean>` `fun <T> Field<Sequence<T>>.any(predicate: (T) -> Boolean): Field<Boolean>` Same as any, but accepts Field and returns a new Field. `fun Field<String>.any(): Field<Boolean>` `fun Field<String>.any(predicate: (Char) -> Boolean): Field<Boolean>`
anyF	Same as any, but accepts Field and returns a new Field. `fun <T> Field<Iterable<T>>.anyF(predicate: (T) -> Field<Boolean>): Field<Boolean>` `fun <K, V> Field<Map<K, V>>.anyF(predicate: (Entry<K, V>) -> Field<Boolean>): Field<Boolean>`
asIterable	Same as asIterable, but accepts Field and returns a new Field. `fun <T> Field<Iterable<T>>.asIterable(): Field<Iterable<T>>` `fun <K, V> Field<Map<K, V>>.asIterable(): Field<Iterable<Entry<K, V>>>` Same as asIterable, but accepts Field and returns a new Field. `fun <T> Field<Sequence<T>>.asIterable(): Field<Iterable<T>>` Same as asIterable, but accepts Field and returns a new Field. `fun Field<String>.asIterable(): Field<Iterable<Char>>`
asReversed	Same as asReversed, but accepts Field and returns a new Field. `fun <T> Field<List<T>>.asReversed(): Field<List<T>>`
asSequence	Same as asSequence, but accepts Field and returns a new Field. `fun <T> Field<Iterable<T>>.asSequence(): Field<Sequence<T>>` `fun <K, V> Field<Map<K, V>>.asSequence(): Field<Sequence<Entry<K, V>>>` Same as asSequence, but accepts Field and returns a new Field. `fun <T> Field<Sequence<T>>.asSequence(): Field<Sequence<T>>` Same as asSequence, but accepts Field and returns a new Field. `fun Field<String>.asSequence(): Field<Sequence<Char>>`
associate	Same as associate, but accepts Field and returns a new Field. `fun <T, K, V> Field<Iterable<T>>.associate(transform: (T) -> Pair<K, V>): Field<Map<K, V>>` Same as associate, but accepts Field and returns a new Field. `fun <T, K, V> Field<Sequence<T>>.associate(transform: (T) -> Pair<K, V>): Field<Map<K, V>>` Same as associate, but accepts Field and returns a new Field. `fun <K, V> Field<String>.associate(transform: (Char) -> Pair<K, V>): Field<Map<K, V>>`
associateBy	Same as associateBy, but accepts Field and returns a new Field. `fun <T, K, V> Field<Iterable<T>>.associateBy(keySelector: (T) -> K, valueTransform: (T) -> V): Field<Map<K, V>>` `fun <T, K> Field<Iterable<T>>.associateBy(keySelector: (T) -> K): Field<Map<K, T>>` Same as associateBy, but accepts Field and returns a new Field. `fun <T, K, V> Field<Sequence<T>>.associateBy(keySelector: (T) -> K, valueTransform: (T) -> V): Field<Map<K, V>>` `fun <T, K> Field<Sequence<T>>.associateBy(keySelector: (T) -> K): Field<Map<K, T>>` Same as associateBy, but accepts Field and returns a new Field. `fun <K, V> Field<String>.associateBy(keySelector: (Char) -> K, valueTransform: (Char) -> V): Field<Map<K, V>>` `fun <K> Field<String>.associateBy(keySelector: (Char) -> K): Field<Map<K, Char>>`
associateByF	Same as associateBy, but accepts Field and returns a new Field. `fun <T, K, V> Field<Iterable<T>>.associateByF(keySelector: (T) -> Field<K>, valueTransform: (T) -> Field<V>): Field<Map<K, V>>` `fun <T, K> Field<Iterable<T>>.associateByF(keySelector: (T) -> Field<K>): Field<Map<K, T>>`
associateF	Same as associate, but accepts Field and returns a new Field. `fun <T, K, V> Field<Iterable<T>>.associateF(transform: (T) -> Field<Pair<K, V>>): Field<Map<K, V>>`
associateWith	Same as associateWith, but accepts Field and returns a new Field. `fun <K, V> Field<Iterable<K>>.associateWith(valueSelector: (K) -> V): Field<Map<K, V>>` Same as associateWith, but accepts Field and returns a new Field. `fun <K, V> Field<Sequence<K>>.associateWith(valueSelector: (K) -> V): Field<Map<K, V>>` Same as associateWith, but accepts Field and returns a new Field. `fun <V> Field<String>.associateWith(valueSelector: (Char) -> V): Field<Map<Char, V>>`
associateWithF	Same as associateWith, but accepts Field and returns a new Field. `fun <K, V> Field<Iterable<K>>.associateWithF(valueSelector: (K) -> Field<V>): Field<Map<K, V>>`
average	Same as average, but accepts Field and returns a new Field. `fun Field<Iterable<Byte>>.average(): Field<Double>` `fun Field<Iterable<out Double>>.average(): Field<Double>` `fun Field<Iterable<Float>>.average(): Field<Double>` `fun Field<Iterable<Int>>.average(): Field<Double>` `fun Field<Iterable<Long>>.average(): Field<Double>` `fun Field<Iterable<Short>>.average(): Field<Double>` Same as average, but accepts Field and returns a new Field. `fun Field<Sequence<Byte>>.average(): Field<Double>` `fun Field<Sequence<out Double>>.average(): Field<Double>` `fun Field<Sequence<Float>>.average(): Field<Double>` `fun Field<Sequence<Int>>.average(): Field<Double>` `fun Field<Sequence<Long>>.average(): Field<Double>` `fun Field<Sequence<Short>>.average(): Field<Double>`
bitCount	Same as bitCount, but accepts Field and returns a new Field. `fun Field<BigInteger>.bitCount(): Field<Int>`
bitLength	Same as bitLength, but accepts Field and returns a new Field. `fun Field<BigInteger>.bitLength(): Field<Int>`
category	Same as category, but returns a new Field `fun Field<Char>.category(): Field<CharCategory>`
chunked	Same as chunked, but accepts Field and returns a new Field. `fun <T, R> Field<Iterable<T>>.chunked(size: Field<Int>, transform: (List<T>) -> R): Field<List<R>>` `fun <T, R> Field<Iterable<T>>.chunked(size: Int, transform: (List<T>) -> R): Field<List<R>>` `fun <T> Field<Iterable<T>>.chunked(size: Field<Int>): Field<List<List<T>>>` `fun <T> Field<Iterable<T>>.chunked(size: Int): Field<List<List<T>>>` Same as chunked, but accepts Field and returns a new Field. `fun <T, R> Field<Sequence<T>>.chunked(size: Field<Int>, transform: (List<T>) -> R): Field<Sequence<R>>` `fun <T, R> Field<Sequence<T>>.chunked(size: Int, transform: (List<T>) -> R): Field<Sequence<R>>` `fun <T> Field<Sequence<T>>.chunked(size: Field<Int>): Field<Sequence<List<T>>>` `fun <T> Field<Sequence<T>>.chunked(size: Int): Field<Sequence<List<T>>>` Same as chunked, but accepts Field and returns a new Field. `fun <R> Field<String>.chunked(size: Field<Int>, transform: (CharSequence) -> R): Field<List<R>>` `fun <R> Field<String>.chunked(size: Int, transform: (CharSequence) -> R): Field<List<R>>` `fun Field<String>.chunked(size: Field<Int>): Field<List<String>>` `fun Field<String>.chunked(size: Int): Field<List<String>>`
chunkedSequence	Same as chunkedSequence, but accepts Field and returns a new Field. `fun <R> Field<String>.chunkedSequence(size: Field<Int>, transform: (CharSequence) -> R): Field<Sequence<R>>` `fun <R> Field<String>.chunkedSequence(size: Int, transform: (CharSequence) -> R): Field<Sequence<R>>` `fun Field<String>.chunkedSequence(size: Field<Int>): Field<Sequence<String>>` `fun Field<String>.chunkedSequence(size: Int): Field<Sequence<String>>`
clearBit	Same as clearBit, but accepts Field and returns a new Field. `fun Field<BigInteger>.clearBit(n: Field<Int>): Field<BigInteger>` `fun Field<BigInteger>.clearBit(n: Int): Field<BigInteger>`
code	Same as code, but returns a new Field `fun Field<CharCategory>.code(): Field<String>`
codePointAt	Same as codePointAt, but accepts Field and returns a new Field. `fun Field<String>.codePointAt(index: Field<Int>): Field<Int>` `fun Field<String>.codePointAt(index: Int): Field<Int>`
codePointBefore	Same as codePointBefore, but accepts Field and returns a new Field. `fun Field<String>.codePointBefore(index: Field<Int>): Field<Int>` `fun Field<String>.codePointBefore(index: Int): Field<Int>`
codePointCount	Same as codePointCount, but accepts Field and returns a new Field. `fun Field<String>.codePointCount(beginIndex: Field<Int>, endIndex: Field<Int>): Field<Int>` `fun Field<String>.codePointCount(beginIndex: Field<Int>, endIndex: Int): Field<Int>` `fun Field<String>.codePointCount(beginIndex: Int, endIndex: Field<Int>): Field<Int>` `fun Field<String>.codePointCount(beginIndex: Int, endIndex: Int): Field<Int>`
coerceAtLeast	Same as coerceAtLeast, but accepts Field and returns a new Field. `fun Field<Byte>.coerceAtLeast(minimumValue: Field<Byte>): Field<Byte>` `fun Field<Byte>.coerceAtLeast(minimumValue: Byte): Field<Byte>` `fun <T : Comparable<T>> Field<T>.coerceAtLeast(minimumValue: T): Field<T>` `fun <T : Comparable<T>> Field<T>.coerceAtLeast(minimumValue: Field<T>): Field<T>` `fun Field<Double>.coerceAtLeast(minimumValue: Field<Double>): Field<Double>` `fun Field<Double>.coerceAtLeast(minimumValue: Double): Field<Double>` `fun Field<Float>.coerceAtLeast(minimumValue: Field<Float>): Field<Float>` `fun Field<Float>.coerceAtLeast(minimumValue: Float): Field<Float>` `fun Field<Int>.coerceAtLeast(minimumValue: Field<Int>): Field<Int>` `fun Field<Int>.coerceAtLeast(minimumValue: Int): Field<Int>` `fun Field<Long>.coerceAtLeast(minimumValue: Field<Long>): Field<Long>` `fun Field<Long>.coerceAtLeast(minimumValue: Long): Field<Long>` `fun Field<Short>.coerceAtLeast(minimumValue: Field<Short>): Field<Short>` `fun Field<Short>.coerceAtLeast(minimumValue: Short): Field<Short>`
coerceAtMost	Same as coerceAtMost, but accepts Field and returns a new Field. `fun Field<Byte>.coerceAtMost(maximumValue: Field<Byte>): Field<Byte>` `fun Field<Byte>.coerceAtMost(maximumValue: Byte): Field<Byte>` `fun <T : Comparable<T>> Field<T>.coerceAtMost(maximumValue: T): Field<T>` `fun <T : Comparable<T>> Field<T>.coerceAtMost(maximumValue: Field<T>): Field<T>` `fun Field<Double>.coerceAtMost(maximumValue: Field<Double>): Field<Double>` `fun Field<Double>.coerceAtMost(maximumValue: Double): Field<Double>` `fun Field<Float>.coerceAtMost(maximumValue: Field<Float>): Field<Float>` `fun Field<Float>.coerceAtMost(maximumValue: Float): Field<Float>` `fun Field<Int>.coerceAtMost(maximumValue: Field<Int>): Field<Int>` `fun Field<Int>.coerceAtMost(maximumValue: Int): Field<Int>` `fun Field<Long>.coerceAtMost(maximumValue: Field<Long>): Field<Long>` `fun Field<Long>.coerceAtMost(maximumValue: Long): Field<Long>` `fun Field<Short>.coerceAtMost(maximumValue: Field<Short>): Field<Short>` `fun Field<Short>.coerceAtMost(maximumValue: Short): Field<Short>`
coerceIn	Same as coerceIn, but accepts Field and returns a new Field. `fun Field<Byte>.coerceIn(minimumValue: Field<Byte>, maximumValue: Field<Byte>): Field<Byte>` `fun Field<Byte>.coerceIn(minimumValue: Field<Byte>, maximumValue: Byte): Field<Byte>` `fun Field<Byte>.coerceIn(minimumValue: Byte, maximumValue: Field<Byte>): Field<Byte>` `fun Field<Byte>.coerceIn(minimumValue: Byte, maximumValue: Byte): Field<Byte>` `fun <T : Comparable<T>> Field<T>.coerceIn(minimumValue: T?, maximumValue: T?): Field<T>` `fun <T : Comparable<T>> Field<T>.coerceIn(minimumValue: T?, maximumValue: Field<T?>?): Field<T>` `fun <T : Comparable<T>> Field<T>.coerceIn(minimumValue: Field<T?>?, maximumValue: T?): Field<T>` `fun <T : Comparable<T>> Field<T>.coerceIn(minimumValue: Field<T?>?, maximumValue: Field<T?>?): Field<T>` `fun <T : Comparable<T>> Field<T>.coerceIn(range: Field<ClosedRange<T>>): Field<T>` `fun <T : Comparable<T>> Field<T>.coerceIn(range: ClosedRange<T>): Field<T>` `fun <T : Comparable<T>> Field<T>.coerceIn(range: Field<ClosedFloatingPointRange<T>>): Field<T>` `fun <T : Comparable<T>> Field<T>.coerceIn(range: ClosedFloatingPointRange<T>): Field<T>` `fun Field<Double>.coerceIn(minimumValue: Field<Double>, maximumValue: Field<Double>): Field<Double>` `fun Field<Double>.coerceIn(minimumValue: Field<Double>, maximumValue: Double): Field<Double>` `fun Field<Double>.coerceIn(minimumValue: Double, maximumValue: Field<Double>): Field<Double>` `fun Field<Double>.coerceIn(minimumValue: Double, maximumValue: Double): Field<Double>` `fun Field<Float>.coerceIn(minimumValue: Field<Float>, maximumValue: Field<Float>): Field<Float>` `fun Field<Float>.coerceIn(minimumValue: Field<Float>, maximumValue: Float): Field<Float>` `fun Field<Float>.coerceIn(minimumValue: Float, maximumValue: Field<Float>): Field<Float>` `fun Field<Float>.coerceIn(minimumValue: Float, maximumValue: Float): Field<Float>` `fun Field<Int>.coerceIn(minimumValue: Field<Int>, maximumValue: Field<Int>): Field<Int>` `fun Field<Int>.coerceIn(minimumValue: Field<Int>, maximumValue: Int): Field<Int>` `fun Field<Int>.coerceIn(minimumValue: Int, maximumValue: Field<Int>): Field<Int>` `fun Field<Int>.coerceIn(minimumValue: Int, maximumValue: Int): Field<Int>` `fun Field<Int>.coerceIn(range: Field<ClosedRange<Int>>): Field<Int>` `fun Field<Int>.coerceIn(range: ClosedRange<Int>): Field<Int>` `fun Field<Long>.coerceIn(minimumValue: Field<Long>, maximumValue: Field<Long>): Field<Long>` `fun Field<Long>.coerceIn(minimumValue: Field<Long>, maximumValue: Long): Field<Long>` `fun Field<Long>.coerceIn(minimumValue: Long, maximumValue: Field<Long>): Field<Long>` `fun Field<Long>.coerceIn(minimumValue: Long, maximumValue: Long): Field<Long>` `fun Field<Long>.coerceIn(range: Field<ClosedRange<Long>>): Field<Long>` `fun Field<Long>.coerceIn(range: ClosedRange<Long>): Field<Long>` `fun Field<Short>.coerceIn(minimumValue: Field<Short>, maximumValue: Field<Short>): Field<Short>` `fun Field<Short>.coerceIn(minimumValue: Field<Short>, maximumValue: Short): Field<Short>` `fun Field<Short>.coerceIn(minimumValue: Short, maximumValue: Field<Short>): Field<Short>` `fun Field<Short>.coerceIn(minimumValue: Short, maximumValue: Short): Field<Short>`
commonPrefixWith	Same as commonPrefixWith, but accepts Field and returns a new Field. `fun Field<String>.commonPrefixWith(other: Field<String>, ignoreCase: Field<Boolean> = com.femastudios.dataflow.util.fieldOf(false)): Field<String>` `fun Field<String>.commonPrefixWith(other: String, ignoreCase: Boolean = false): Field<String>` `fun Field<String>.commonPrefixWith(other: Field<String>, ignoreCase: Boolean = false): Field<String>` `fun Field<String>.commonPrefixWith(other: String, ignoreCase: Field<Boolean>): Field<String>`
commonSuffixWith	Same as commonSuffixWith, but accepts Field and returns a new Field. `fun Field<String>.commonSuffixWith(other: Field<String>, ignoreCase: Field<Boolean> = com.femastudios.dataflow.util.fieldOf(false)): Field<String>` `fun Field<String>.commonSuffixWith(other: String, ignoreCase: Boolean = false): Field<String>` `fun Field<String>.commonSuffixWith(other: Field<String>, ignoreCase: Boolean = false): Field<String>` `fun Field<String>.commonSuffixWith(other: String, ignoreCase: Field<Boolean>): Field<String>`
compareTo	Same as compareTo, but accepts Field and returns a new Field. `fun Field<Byte>.compareTo(other: Field<Double>): Field<Int>` `fun Field<Byte>.compareTo(other: Field<Float>): Field<Int>` `fun Field<Byte>.compareTo(other: Field<Int>): Field<Int>` `fun Field<Byte>.compareTo(other: Field<Long>): Field<Int>` `fun Field<Byte>.compareTo(other: Field<Short>): Field<Int>` `fun Field<Byte>.compareTo(other: Field<Byte>): Field<Int>` `fun Field<Byte>.compareTo(other: Byte): Field<Int>` `fun Field<Byte>.compareTo(other: Double): Field<Int>` `fun Field<Byte>.compareTo(other: Float): Field<Int>` `fun Field<Byte>.compareTo(other: Int): Field<Int>` `fun Field<Byte>.compareTo(other: Long): Field<Int>` `fun Field<Byte>.compareTo(other: Short): Field<Int>` Same as compareTo, but accepts Field and returns a new Field. `fun <T> Field<Comparable<T>>.compareTo(other: T): Field<Int>` `fun <T> Field<Comparable<T>>.compareTo(other: Field<T>): Field<Int>` Same as compareTo, but accepts Field and returns a new Field. `fun Field<Double>.compareTo(other: Field<Byte>): Field<Int>` `fun Field<Double>.compareTo(other: Field<Float>): Field<Int>` `fun Field<Double>.compareTo(other: Field<Int>): Field<Int>` `fun Field<Double>.compareTo(other: Field<Long>): Field<Int>` `fun Field<Double>.compareTo(other: Field<Short>): Field<Int>` `fun Field<Double>.compareTo(other: Field<Double>): Field<Int>` `fun Field<Double>.compareTo(other: Byte): Field<Int>` `fun Field<Double>.compareTo(other: Double): Field<Int>` `fun Field<Double>.compareTo(other: Float): Field<Int>` `fun Field<Double>.compareTo(other: Int): Field<Int>` `fun Field<Double>.compareTo(other: Long): Field<Int>` `fun Field<Double>.compareTo(other: Short): Field<Int>` Same as compareTo, but accepts Field and returns a new Field. `fun Field<Float>.compareTo(other: Field<Byte>): Field<Int>` `fun Field<Float>.compareTo(other: Field<Double>): Field<Int>` `fun Field<Float>.compareTo(other: Field<Int>): Field<Int>` `fun Field<Float>.compareTo(other: Field<Long>): Field<Int>` `fun Field<Float>.compareTo(other: Field<Short>): Field<Int>` `fun Field<Float>.compareTo(other: Field<Float>): Field<Int>` `fun Field<Float>.compareTo(other: Byte): Field<Int>` `fun Field<Float>.compareTo(other: Double): Field<Int>` `fun Field<Float>.compareTo(other: Float): Field<Int>` `fun Field<Float>.compareTo(other: Int): Field<Int>` `fun Field<Float>.compareTo(other: Long): Field<Int>` `fun Field<Float>.compareTo(other: Short): Field<Int>` Same as compareTo, but accepts Field and returns a new Field. `fun Field<Int>.compareTo(other: Field<Byte>): Field<Int>` `fun Field<Int>.compareTo(other: Field<Double>): Field<Int>` `fun Field<Int>.compareTo(other: Field<Float>): Field<Int>` `fun Field<Int>.compareTo(other: Field<Long>): Field<Int>` `fun Field<Int>.compareTo(other: Field<Short>): Field<Int>` `fun Field<Int>.compareTo(other: Field<Int>): Field<Int>` `fun Field<Int>.compareTo(other: Byte): Field<Int>` `fun Field<Int>.compareTo(other: Double): Field<Int>` `fun Field<Int>.compareTo(other: Float): Field<Int>` `fun Field<Int>.compareTo(other: Int): Field<Int>` `fun Field<Int>.compareTo(other: Long): Field<Int>` `fun Field<Int>.compareTo(other: Short): Field<Int>` Same as compareTo, but accepts Field and returns a new Field. `fun Field<Long>.compareTo(other: Field<Byte>): Field<Int>` `fun Field<Long>.compareTo(other: Field<Double>): Field<Int>` `fun Field<Long>.compareTo(other: Field<Float>): Field<Int>` `fun Field<Long>.compareTo(other: Field<Int>): Field<Int>` `fun Field<Long>.compareTo(other: Field<Short>): Field<Int>` `fun Field<Long>.compareTo(other: Field<Long>): Field<Int>` `fun Field<Long>.compareTo(other: Byte): Field<Int>` `fun Field<Long>.compareTo(other: Double): Field<Int>` `fun Field<Long>.compareTo(other: Float): Field<Int>` `fun Field<Long>.compareTo(other: Int): Field<Int>` `fun Field<Long>.compareTo(other: Long): Field<Int>` `fun Field<Long>.compareTo(other: Short): Field<Int>` Same as compareTo, but accepts Field and returns a new Field. `fun Field<Short>.compareTo(other: Field<Byte>): Field<Int>` `fun Field<Short>.compareTo(other: Field<Double>): Field<Int>` `fun Field<Short>.compareTo(other: Field<Float>): Field<Int>` `fun Field<Short>.compareTo(other: Field<Int>): Field<Int>` `fun Field<Short>.compareTo(other: Field<Long>): Field<Int>` `fun Field<Short>.compareTo(other: Field<Short>): Field<Int>` `fun Field<Short>.compareTo(other: Byte): Field<Int>` `fun Field<Short>.compareTo(other: Double): Field<Int>` `fun Field<Short>.compareTo(other: Float): Field<Int>` `fun Field<Short>.compareTo(other: Int): Field<Int>` `fun Field<Short>.compareTo(other: Long): Field<Int>` `fun Field<Short>.compareTo(other: Short): Field<Int>`
component1	Same as component1, but accepts Field and returns a new Field. `operator fun <T> Field<List<T>>.component1(): Field<T>` `operator fun <K, V> Field<Entry<K, V>>.component1(): Field<K>`
component2	Same as component2, but accepts Field and returns a new Field. `operator fun <T> Field<List<T>>.component2(): Field<T>` `operator fun <K, V> Field<Entry<K, V>>.component2(): Field<V>`
component3	Same as component3, but accepts Field and returns a new Field. `operator fun <T> Field<List<T>>.component3(): Field<T>`
component4	Same as component4, but accepts Field and returns a new Field. `operator fun <T> Field<List<T>>.component4(): Field<T>`
component5	Same as component5, but accepts Field and returns a new Field. `operator fun <T> Field<List<T>>.component5(): Field<T>`
contains	Same as contains, but accepts Field and returns a new Field. `fun Field<CharCategory>.contains(char: Field<Char>): Field<Boolean>` `fun Field<CharCategory>.contains(char: Char): Field<Boolean>` Same as contains, but accepts Field and returns a new Field. `fun <T : Comparable<T>> Field<ClosedFloatingPointRange<in T>>.contains(value: T): Field<Boolean>` `fun <T : Comparable<T>> Field<ClosedFloatingPointRange<in T>>.contains(value: Field<T>): Field<Boolean>` Same as contains, but accepts Field and returns a new Field. `fun <T : Comparable<T>> Field<ClosedRange<in T>>.contains(value: T): Field<Boolean>` `fun <T : Comparable<T>> Field<ClosedRange<in T>>.contains(value: Field<T>): Field<Boolean>` Same as contains, but accepts Field and returns a new Field. `fun <E> Field<Collection<E>>.contains(element: E): Field<Boolean>` `fun <E> Field<Collection<E>>.contains(element: Field<E>): Field<Boolean>` Same as contains, but accepts Field and returns a new Field. `fun <T> Field<Iterable<T>>.contains(element: T): Field<Boolean>` `fun <T> Field<Iterable<T>>.contains(element: Field<T>): Field<Boolean>` `fun <K, V> Field<Map<K, V>>.contains(key: K): Field<Boolean>` `fun <K, V> Field<Map<K, V>>.contains(key: Field<K>): Field<Boolean>` Same as contains, but accepts Field and returns a new Field. `fun <T> Field<Sequence<T>>.contains(element: T): Field<Boolean>` `fun <T> Field<Sequence<T>>.contains(element: Field<T>): Field<Boolean>` Same as contains, but accepts Field and returns a new Field. `fun <E> Field<Set<E>>.contains(element: E): Field<Boolean>` `fun <E> Field<Set<E>>.contains(element: Field<E>): Field<Boolean>` Same as contains, but accepts Field and returns a new Field. `fun Field<String>.contains(other: Field<String>, ignoreCase: Field<Boolean> = com.femastudios.dataflow.util.fieldOf(false)): Field<Boolean>` `fun Field<String>.contains(other: String, ignoreCase: Boolean = false): Field<Boolean>` `fun Field<String>.contains(char: Field<Char>, ignoreCase: Field<Boolean> = com.femastudios.dataflow.util.fieldOf(false)): Field<Boolean>` `fun Field<String>.contains(char: Char, ignoreCase: Boolean = false): Field<Boolean>` `fun Field<String>.contains(other: Field<String>, ignoreCase: Boolean = false): Field<Boolean>` `fun Field<String>.contains(other: String, ignoreCase: Field<Boolean>): Field<Boolean>` `fun Field<String>.contains(char: Field<Char>, ignoreCase: Boolean = false): Field<Boolean>` `fun Field<String>.contains(char: Char, ignoreCase: Field<Boolean>): Field<Boolean>` `fun Field<String>.contains(regex: Field<Regex>): Field<Boolean>` `fun Field<String>.contains(regex: Regex): Field<Boolean>`
containsAll	Same as containsAll, but accepts Field and returns a new Field. `fun <E> Field<Collection<E>>.containsAll(elements: Field<Collection<E>>): Field<Boolean>` `fun <E> Field<Collection<E>>.containsAll(elements: Collection<E>): Field<Boolean>` Same as containsAll, but accepts Field and returns a new Field. `fun <E> Field<Set<E>>.containsAll(elements: Field<Collection<E>>): Field<Boolean>` `fun <E> Field<Set<E>>.containsAll(elements: Collection<E>): Field<Boolean>`
containsKey	Same as containsKey, but accepts Field and returns a new Field. `fun <K> Field<Map<in K, >>.containsKey(key: K): Field<Boolean>` `fun <K> Field<Map<in K, >>.containsKey(key: Field<K>): Field<Boolean>`
containsMatchIn	Same as containsMatchIn, but accepts Field and returns a new Field. `fun Field<Regex>.containsMatchIn(input: Field<CharSequence>): Field<Boolean>` `fun Field<Regex>.containsMatchIn(input: CharSequence): Field<Boolean>`
containsValue	Same as containsValue, but accepts Field and returns a new Field. `fun <V> Field<Map<, V>>.containsValue(value: V): Field<Boolean>` `fun <V> Field<Map<, V>>.containsValue(value: Field<V>): Field<Boolean>`
contentEquals	Same as contentEquals, but accepts Field and returns a new Field. `fun Field<String>.contentEquals(stringBuilder: Field<StringBuffer>): Field<Boolean>` `fun Field<String>.contentEquals(charSequence: Field<String>): Field<Boolean>` `fun Field<String>.contentEquals(charSequence: String): Field<Boolean>` `fun Field<String>.contentEquals(stringBuilder: StringBuffer): Field<Boolean>`
count	Same as count, but accepts Field and returns a new Field. `fun <T> Field<Collection<T>>.count(): Field<Int>` `fun <T> Field<Iterable<T>>.count(): Field<Int>` `fun <T> Field<Iterable<T>>.count(predicate: (T) -> Boolean): Field<Int>` `fun <K, V> Field<Map<K, V>>.count(): Field<Int>` `fun <K, V> Field<Map<K, V>>.count(predicate: (Entry<K, V>) -> Boolean): Field<Int>` Same as count, but accepts Field and returns a new Field. `fun <T> Field<Sequence<T>>.count(): Field<Int>` `fun <T> Field<Sequence<T>>.count(predicate: (T) -> Boolean): Field<Int>` Same as count, but accepts Field and returns a new Field. `fun Field<String>.count(): Field<Int>` `fun Field<String>.count(predicate: (Char) -> Boolean): Field<Int>`
countF	Same as count, but accepts Field and returns a new Field. `fun <T> Field<Iterable<T>>.countF(predicate: (T) -> Field<Boolean>): Field<Int>` `fun <K, V> Field<Map<K, V>>.countF(predicate: (Entry<K, V>) -> Field<Boolean>): Field<Int>`
dec	Same as dec, but accepts Field and returns a new Field. `operator fun Field<BigDecimal>.dec(): Field<BigDecimal>` `operator fun Field<BigInteger>.dec(): Field<BigInteger>` Same as dec, but accepts Field and returns a new Field. `operator fun Field<Byte>.dec(): Field<Byte>` Same as dec, but accepts Field and returns a new Field. `operator fun Field<Char>.dec(): Field<Char>` Same as dec, but accepts Field and returns a new Field. `operator fun Field<Double>.dec(): Field<Double>` Same as dec, but accepts Field and returns a new Field. `operator fun Field<Float>.dec(): Field<Float>` Same as dec, but accepts Field and returns a new Field. `operator fun Field<Int>.dec(): Field<Int>` Same as dec, but accepts Field and returns a new Field. `operator fun Field<Long>.dec(): Field<Long>` Same as dec, but accepts Field and returns a new Field. `operator fun Field<Short>.dec(): Field<Short>`
destructured	Same as destructured, but returns a new Field `fun Field<MatchResult>.destructured(): Field<Destructured>`
directionality	Same as directionality, but returns a new Field `fun Field<Char>.directionality(): Field<CharDirectionality>`
distinct	Same as distinct, but accepts Field and returns a new Field. `fun <T> Field<Iterable<T>>.distinct(): Field<List<T>>` Same as distinct, but accepts Field and returns a new Field. `fun <T> Field<Sequence<T>>.distinct(): Field<Sequence<T>>`
distinctBy	Same as distinctBy, but accepts Field and returns a new Field. `fun <T, K> Field<Iterable<T>>.distinctBy(selector: (T) -> K): Field<List<T>>` Same as distinctBy, but accepts Field and returns a new Field. `fun <T, K> Field<Sequence<T>>.distinctBy(selector: (T) -> K): Field<Sequence<T>>`
distinctByF	Same as distinctBy, but accepts Field and returns a new Field. `fun <T, K> Field<Iterable<T>>.distinctByF(selector: (T) -> Field<K>): Field<List<T>>`
div	Same as div, but accepts Field and returns a new Field. `operator fun Field<BigDecimal>.div(other: Field<BigDecimal>): Field<BigDecimal>` `operator fun Field<BigDecimal>.div(other: BigDecimal): Field<BigDecimal>` `operator fun Field<BigInteger>.div(other: Field<BigInteger>): Field<BigInteger>` `operator fun Field<BigInteger>.div(other: BigInteger): Field<BigInteger>` Same as div, but accepts Field and returns a new Field. `operator fun Field<Byte>.div(other: Field<Double>): Field<Double>` `operator fun Field<Byte>.div(other: Field<Float>): Field<Float>` `operator fun Field<Byte>.div(other: Field<Int>): Field<Int>` `operator fun Field<Byte>.div(other: Field<Long>): Field<Long>` `operator fun Field<Byte>.div(other: Field<Short>): Field<Int>` `operator fun Field<Byte>.div(other: Field<Byte>): Field<Int>` `operator fun Field<Byte>.div(other: Byte): Field<Int>` `operator fun Field<Byte>.div(other: Double): Field<Double>` `operator fun Field<Byte>.div(other: Float): Field<Float>` `operator fun Field<Byte>.div(other: Int): Field<Int>` `operator fun Field<Byte>.div(other: Long): Field<Long>` `operator fun Field<Byte>.div(other: Short): Field<Int>` Same as div, but accepts Field and returns a new Field. `operator fun Field<Double>.div(other: Field<Byte>): Field<Double>` `operator fun Field<Double>.div(other: Field<Float>): Field<Double>` `operator fun Field<Double>.div(other: Field<Int>): Field<Double>` `operator fun Field<Double>.div(other: Field<Long>): Field<Double>` `operator fun Field<Double>.div(other: Field<Short>): Field<Double>` `operator fun Field<Double>.div(other: Field<Double>): Field<Double>` `operator fun Field<Double>.div(other: Byte): Field<Double>` `operator fun Field<Double>.div(other: Double): Field<Double>` `operator fun Field<Double>.div(other: Float): Field<Double>` `operator fun Field<Double>.div(other: Int): Field<Double>` `operator fun Field<Double>.div(other: Long): Field<Double>` `operator fun Field<Double>.div(other: Short): Field<Double>` Same as div, but accepts Field and returns a new Field. `operator fun Field<Float>.div(other: Field<Byte>): Field<Float>` `operator fun Field<Float>.div(other: Field<Double>): Field<Double>` `operator fun Field<Float>.div(other: Field<Int>): Field<Float>` `operator fun Field<Float>.div(other: Field<Long>): Field<Float>` `operator fun Field<Float>.div(other: Field<Short>): Field<Float>` `operator fun Field<Float>.div(other: Field<Float>): Field<Float>` `operator fun Field<Float>.div(other: Byte): Field<Float>` `operator fun Field<Float>.div(other: Double): Field<Double>` `operator fun Field<Float>.div(other: Float): Field<Float>` `operator fun Field<Float>.div(other: Int): Field<Float>` `operator fun Field<Float>.div(other: Long): Field<Float>` `operator fun Field<Float>.div(other: Short): Field<Float>` Same as div, but accepts Field and returns a new Field. `operator fun Field<Int>.div(other: Field<Byte>): Field<Int>` `operator fun Field<Int>.div(other: Field<Double>): Field<Double>` `operator fun Field<Int>.div(other: Field<Float>): Field<Float>` `operator fun Field<Int>.div(other: Field<Long>): Field<Long>` `operator fun Field<Int>.div(other: Field<Short>): Field<Int>` `operator fun Field<Int>.div(other: Field<Int>): Field<Int>` `operator fun Field<Int>.div(other: Byte): Field<Int>` `operator fun Field<Int>.div(other: Double): Field<Double>` `operator fun Field<Int>.div(other: Float): Field<Float>` `operator fun Field<Int>.div(other: Int): Field<Int>` `operator fun Field<Int>.div(other: Long): Field<Long>` `operator fun Field<Int>.div(other: Short): Field<Int>` Same as div, but accepts Field and returns a new Field. `operator fun Field<Long>.div(other: Field<Byte>): Field<Long>` `operator fun Field<Long>.div(other: Field<Double>): Field<Double>` `operator fun Field<Long>.div(other: Field<Float>): Field<Float>` `operator fun Field<Long>.div(other: Field<Int>): Field<Long>` `operator fun Field<Long>.div(other: Field<Short>): Field<Long>` `operator fun Field<Long>.div(other: Field<Long>): Field<Long>` `operator fun Field<Long>.div(other: Byte): Field<Long>` `operator fun Field<Long>.div(other: Double): Field<Double>` `operator fun Field<Long>.div(other: Float): Field<Float>` `operator fun Field<Long>.div(other: Int): Field<Long>` `operator fun Field<Long>.div(other: Long): Field<Long>` `operator fun Field<Long>.div(other: Short): Field<Long>` Same as div, but accepts Field and returns a new Field. `operator fun Field<Short>.div(other: Field<Byte>): Field<Int>` `operator fun Field<Short>.div(other: Field<Double>): Field<Double>` `operator fun Field<Short>.div(other: Field<Float>): Field<Float>` `operator fun Field<Short>.div(other: Field<Int>): Field<Int>` `operator fun Field<Short>.div(other: Field<Long>): Field<Long>` `operator fun Field<Short>.div(other: Field<Short>): Field<Int>` `operator fun Field<Short>.div(other: Byte): Field<Int>` `operator fun Field<Short>.div(other: Double): Field<Double>` `operator fun Field<Short>.div(other: Float): Field<Float>` `operator fun Field<Short>.div(other: Int): Field<Int>` `operator fun Field<Short>.div(other: Long): Field<Long>` `operator fun Field<Short>.div(other: Short): Field<Int>`
divide	Same as divide, but accepts Field and returns a new Field. `fun Field<BigDecimal>.divide(divisor: Field<BigDecimal>, roundingMode: Field<RoundingMode>): Field<BigDecimal>` `fun Field<BigDecimal>.divide(divisor: Field<BigDecimal>, roundingMode: RoundingMode): Field<BigDecimal>` `fun Field<BigDecimal>.divide(divisor: Field<BigDecimal>, scale: Field<Int>, roundingMode: Field<RoundingMode>): Field<BigDecimal>` `fun Field<BigDecimal>.divide(divisor: BigDecimal, roundingMode: Field<RoundingMode>): Field<BigDecimal>` `fun Field<BigDecimal>.divide(divisor: BigDecimal, roundingMode: RoundingMode): Field<BigDecimal>` `fun Field<BigDecimal>.divide(divisor: BigDecimal, scale: Int, roundingMode: RoundingMode): Field<BigDecimal>` `fun Field<BigDecimal>.divide(divisor: Field<BigDecimal>, mc: Field<MathContext>): Field<BigDecimal>` `fun Field<BigDecimal>.divide(divisor: Field<BigDecimal>, mc: MathContext): Field<BigDecimal>` `fun Field<BigDecimal>.divide(divisor: BigDecimal, mc: Field<MathContext>): Field<BigDecimal>` `fun Field<BigDecimal>.divide(divisor: BigDecimal, mc: MathContext): Field<BigDecimal>`
divideToIntegralValue	Same as divideToIntegralValue, but accepts Field and returns a new Field. `fun Field<BigDecimal>.divideToIntegralValue(divisor: Field<BigDecimal>): Field<BigDecimal>` `fun Field<BigDecimal>.divideToIntegralValue(divisor: Field<BigDecimal>, mc: Field<MathContext>): Field<BigDecimal>` `fun Field<BigDecimal>.divideToIntegralValue(divisor: Field<BigDecimal>, mc: MathContext): Field<BigDecimal>` `fun Field<BigDecimal>.divideToIntegralValue(divisor: BigDecimal): Field<BigDecimal>` `fun Field<BigDecimal>.divideToIntegralValue(divisor: BigDecimal, mc: Field<MathContext>): Field<BigDecimal>` `fun Field<BigDecimal>.divideToIntegralValue(divisor: BigDecimal, mc: MathContext): Field<BigDecimal>`
downTo	Same as downTo, but accepts Field and returns a new Field. `infix fun Field<Byte>.downTo(to: Field<Int>): Field<IntProgression>` `infix fun Field<Byte>.downTo(to: Field<Long>): Field<LongProgression>` `infix fun Field<Byte>.downTo(to: Field<Short>): Field<IntProgression>` `infix fun Field<Byte>.downTo(to: Field<Byte>): Field<IntProgression>` `infix fun Field<Byte>.downTo(to: Byte): Field<IntProgression>` `infix fun Field<Byte>.downTo(to: Int): Field<IntProgression>` `infix fun Field<Byte>.downTo(to: Long): Field<LongProgression>` `infix fun Field<Byte>.downTo(to: Short): Field<IntProgression>` `infix fun Field<Char>.downTo(to: Field<Char>): Field<CharProgression>` `infix fun Field<Char>.downTo(to: Char): Field<CharProgression>` `infix fun Field<Int>.downTo(to: Field<Byte>): Field<IntProgression>` `infix fun Field<Int>.downTo(to: Field<Long>): Field<LongProgression>` `infix fun Field<Int>.downTo(to: Field<Short>): Field<IntProgression>` `infix fun Field<Int>.downTo(to: Field<Int>): Field<IntProgression>` `infix fun Field<Int>.downTo(to: Byte): Field<IntProgression>` `infix fun Field<Int>.downTo(to: Int): Field<IntProgression>` `infix fun Field<Int>.downTo(to: Long): Field<LongProgression>` `infix fun Field<Int>.downTo(to: Short): Field<IntProgression>` `infix fun Field<Long>.downTo(to: Field<Byte>): Field<LongProgression>` `infix fun Field<Long>.downTo(to: Field<Int>): Field<LongProgression>` `infix fun Field<Long>.downTo(to: Field<Short>): Field<LongProgression>` `infix fun Field<Long>.downTo(to: Field<Long>): Field<LongProgression>` `infix fun Field<Long>.downTo(to: Byte): Field<LongProgression>` `infix fun Field<Long>.downTo(to: Int): Field<LongProgression>` `infix fun Field<Long>.downTo(to: Long): Field<LongProgression>` `infix fun Field<Long>.downTo(to: Short): Field<LongProgression>` `infix fun Field<Short>.downTo(to: Field<Byte>): Field<IntProgression>` `infix fun Field<Short>.downTo(to: Field<Int>): Field<IntProgression>` `infix fun Field<Short>.downTo(to: Field<Long>): Field<LongProgression>` `infix fun Field<Short>.downTo(to: Field<Short>): Field<IntProgression>` `infix fun Field<Short>.downTo(to: Byte): Field<IntProgression>` `infix fun Field<Short>.downTo(to: Int): Field<IntProgression>` `infix fun Field<Short>.downTo(to: Long): Field<LongProgression>` `infix fun Field<Short>.downTo(to: Short): Field<IntProgression>`
drop	Same as drop, but accepts Field and returns a new Field. `fun <T> Field<Iterable<T>>.drop(n: Field<Int>): Field<List<T>>` `fun <T> Field<Iterable<T>>.drop(n: Int): Field<List<T>>` Same as drop, but accepts Field and returns a new Field. `fun <T> Field<Sequence<T>>.drop(n: Field<Int>): Field<Sequence<T>>` `fun <T> Field<Sequence<T>>.drop(n: Int): Field<Sequence<T>>` Same as drop, but accepts Field and returns a new Field. `fun Field<String>.drop(n: Field<Int>): Field<String>` `fun Field<String>.drop(n: Int): Field<String>`
dropLast	Same as dropLast, but accepts Field and returns a new Field. `fun <T> Field<List<T>>.dropLast(n: Field<Int>): Field<List<T>>` `fun <T> Field<List<T>>.dropLast(n: Int): Field<List<T>>` Same as dropLast, but accepts Field and returns a new Field. `fun Field<String>.dropLast(n: Field<Int>): Field<String>` `fun Field<String>.dropLast(n: Int): Field<String>`
dropLastWhile	Same as dropLastWhile, but accepts Field and returns a new Field. `fun <T> Field<List<T>>.dropLastWhile(predicate: (T) -> Boolean): Field<List<T>>` Same as dropLastWhile, but accepts Field and returns a new Field. `fun Field<String>.dropLastWhile(predicate: (Char) -> Boolean): Field<String>`
dropLastWhileF	Same as dropLastWhile, but accepts Field and returns a new Field. `fun <T> Field<List<T>>.dropLastWhileF(predicate: (T) -> Field<Boolean>): Field<List<T>>`
dropWhile	Same as dropWhile, but accepts Field and returns a new Field. `fun <T> Field<Iterable<T>>.dropWhile(predicate: (T) -> Boolean): Field<List<T>>` Same as dropWhile, but accepts Field and returns a new Field. `fun <T> Field<Sequence<T>>.dropWhile(predicate: (T) -> Boolean): Field<Sequence<T>>` Same as dropWhile, but accepts Field and returns a new Field. `fun Field<String>.dropWhile(predicate: (Char) -> Boolean): Field<String>`
dropWhileF	Same as dropWhile, but accepts Field and returns a new Field. `fun <T> Field<Iterable<T>>.dropWhileF(predicate: (T) -> Field<Boolean>): Field<List<T>>`
elementAt	Same as elementAt, but accepts Field and returns a new Field. `fun <T> Field<Iterable<T>>.elementAt(index: Field<Int>): Field<T>` `fun <T> Field<Iterable<T>>.elementAt(index: Int): Field<T>` `fun <T> Field<List<T>>.elementAt(index: Field<Int>): Field<T>` `fun <T> Field<List<T>>.elementAt(index: Int): Field<T>` Same as elementAt, but accepts Field and returns a new Field. `fun <T> Field<Sequence<T>>.elementAt(index: Field<Int>): Field<T>` `fun <T> Field<Sequence<T>>.elementAt(index: Int): Field<T>` Same as elementAt, but accepts Field and returns a new Field. `fun Field<String>.elementAt(index: Field<Int>): Field<Char>` `fun Field<String>.elementAt(index: Int): Field<Char>`
elementAtOrElse	Same as elementAtOrElse, but accepts Field and returns a new Field. `fun <T> Field<Iterable<T>>.elementAtOrElse(index: Field<Int>, defaultValue: (Int) -> T): Field<T>` `fun <T> Field<Iterable<T>>.elementAtOrElse(index: Int, defaultValue: (Int) -> T): Field<T>` `fun <T> Field<List<T>>.elementAtOrElse(index: Field<Int>, defaultValue: (Int) -> T): Field<T>` `fun <T> Field<List<T>>.elementAtOrElse(index: Int, defaultValue: (Int) -> T): Field<T>` Same as elementAtOrElse, but accepts Field and returns a new Field. `fun <T> Field<Sequence<T>>.elementAtOrElse(index: Field<Int>, defaultValue: (Int) -> T): Field<T>` `fun <T> Field<Sequence<T>>.elementAtOrElse(index: Int, defaultValue: (Int) -> T): Field<T>` Same as elementAtOrElse, but accepts Field and returns a new Field. `fun Field<String>.elementAtOrElse(index: Field<Int>, defaultValue: (Int) -> Char): Field<Char>` `fun Field<String>.elementAtOrElse(index: Int, defaultValue: (Int) -> Char): Field<Char>`
elementAtOrNull	Same as elementAtOrNull, but accepts Field and returns a new Field. `fun <T> Field<Iterable<T>>.elementAtOrNull(index: Field<Int>): Field<T?>` `fun <T> Field<Iterable<T>>.elementAtOrNull(index: Int): Field<T?>` `fun <T> Field<List<T>>.elementAtOrNull(index: Field<Int>): Field<T?>` `fun <T> Field<List<T>>.elementAtOrNull(index: Int): Field<T?>` Same as elementAtOrNull, but accepts Field and returns a new Field. `fun <T> Field<Sequence<T>>.elementAtOrNull(index: Field<Int>): Field<T?>` `fun <T> Field<Sequence<T>>.elementAtOrNull(index: Int): Field<T?>` Same as elementAtOrNull, but accepts Field and returns a new Field. `fun Field<String>.elementAtOrNull(index: Field<Int>): Field<Char?>` `fun Field<String>.elementAtOrNull(index: Int): Field<Char?>`
endInclusive	Same as endInclusive, but returns a new Field `fun <T : Comparable<T>> Field<ClosedRange<out T>>.endInclusive(): Field<T>`
endsWith	Same as endsWith, but accepts Field and returns a new Field. `fun Field<String>.endsWith(char: Field<Char>, ignoreCase: Field<Boolean> = com.femastudios.dataflow.util.fieldOf(false)): Field<Boolean>` `fun Field<String>.endsWith(char: Char, ignoreCase: Boolean = false): Field<Boolean>` `fun Field<String>.endsWith(suffix: Field<String>, ignoreCase: Field<Boolean> = com.femastudios.dataflow.util.fieldOf(false)): Field<Boolean>` `fun Field<String>.endsWith(suffix: String, ignoreCase: Boolean = false): Field<Boolean>` `fun Field<String>.endsWith(char: Field<Char>, ignoreCase: Boolean = false): Field<Boolean>` `fun Field<String>.endsWith(char: Char, ignoreCase: Field<Boolean>): Field<Boolean>` `fun Field<String>.endsWith(suffix: Field<String>, ignoreCase: Boolean = false): Field<Boolean>` `fun Field<String>.endsWith(suffix: String, ignoreCase: Field<Boolean>): Field<Boolean>`
entries	Same as entries, but returns a new Field `fun <K, V> Field<Map<out K, V>>.entries(): Field<Set<Entry<K, V>>>`
eq	Returns a Field whose value is `true` if the two values are equal `infix fun <T> Field<T>.eq(another: Field<T>): Field<Boolean>` `infix fun <T> Field<T>.eq(another: T): Field<Boolean>`
filter	Same as filter, but accepts Field and returns a new Field. `fun <T> Field<Iterable<T>>.filter(predicate: (T) -> Boolean): Field<List<T>>` `fun <K, V> Field<Map<K, V>>.filter(predicate: (Entry<K, V>) -> Boolean): Field<Map<K, V>>` Same as filter, but accepts Field and returns a new Field. `fun <T> Field<Sequence<T>>.filter(predicate: (T) -> Boolean): Field<Sequence<T>>` Same as filter, but accepts Field and returns a new Field. `fun Field<String>.filter(predicate: (Char) -> Boolean): Field<String>`
filterF	Same as filter, but accepts Field and returns a new Field. `fun <T> Field<Iterable<T>>.filterF(predicate: (T) -> Field<Boolean>): Field<List<T>>` `fun <K, V> Field<Map<K, V>>.filterF(predicate: (Entry<K, V>) -> Field<Boolean>): Field<Map<K, V>>`
filterIndexed	Same as filterIndexed, but accepts Field and returns a new Field. `fun <T> Field<Iterable<T>>.filterIndexed(predicate: (index: Int, T) -> Boolean): Field<List<T>>` Same as filterIndexed, but accepts Field and returns a new Field. `fun <T> Field<Sequence<T>>.filterIndexed(predicate: (index: Int, T) -> Boolean): Field<Sequence<T>>` Same as filterIndexed, but accepts Field and returns a new Field. `fun Field<String>.filterIndexed(predicate: (index: Int, Char) -> Boolean): Field<String>`
filterIndexedToSet	Same as filterIndexedToSet, but accepts Field and returns a new Field. `fun <T> Field<Iterable<T>>.filterIndexedToSet(predicate: (index: Int, T) -> Boolean): Field<Set<T>>` `fun <T> Field<Sequence<T>>.filterIndexedToSet(predicate: (index: Int, T) -> Boolean): Field<Set<T>>`
filterIsInstance	Same as filterIsInstance, but accepts Field and returns a new Field. `fun <R> Field<Iterable<>>.filterIsInstance(klass: Field<Class<R>>): Field<List<R>>` `fun <R> Field<Iterable<>>.filterIsInstance(klass: Class<R>): Field<List<R>>` `fun <R> Field<Iterable<>>.filterIsInstance(): Field<List<R>>` Same as filterIsInstance, but accepts Field and returns a new Field. `fun <R> Field<Sequence<>>.filterIsInstance(klass: Field<Class<R>>): Field<Sequence<R>>` `fun <R> Field<Sequence<>>.filterIsInstance(klass: Class<R>): Field<Sequence<R>>` `fun <R> Field<Sequence<>>.filterIsInstance(): Field<Sequence<R>>`
filterIsInstanceToSet	Same as filterIsInstanceToSet, but accepts Field and returns a new Field. `fun <R> Field<Iterable<>>.filterIsInstanceToSet(klass: Field<Class<R>>): Field<Set<R>>` `fun <R> Field<Iterable<>>.filterIsInstanceToSet(klass: Class<R>): Field<Set<R>>` `fun <R> Field<Iterable<>>.filterIsInstanceToSet(): Field<Set<R>>` `fun <R> Field<Sequence<>>.filterIsInstanceToSet(klass: Field<Class<R>>): Field<Set<R>>` `fun <R> Field<Sequence<>>.filterIsInstanceToSet(klass: Class<R>): Field<Set<R>>` `fun <R> Field<Sequence<>>.filterIsInstanceToSet(): Field<Set<R>>`
filterKeys	Same as filterKeys, but accepts Field and returns a new Field. `fun <K, V> Field<Map<K, V>>.filterKeys(predicate: (K) -> Boolean): Field<Map<K, V>>`
filterKeysF	Same as filterKeys, but accepts Field and returns a new Field. `fun <K, V> Field<Map<K, V>>.filterKeysF(predicate: (K) -> Field<Boolean>): Field<Map<K, V>>`
filterNot	Same as filterNot, but accepts Field and returns a new Field. `fun <T> Field<Iterable<T>>.filterNot(predicate: (T) -> Boolean): Field<List<T>>` `fun <K, V> Field<Map<K, V>>.filterNot(predicate: (Entry<K, V>) -> Boolean): Field<Map<K, V>>` Same as filterNot, but accepts Field and returns a new Field. `fun <T> Field<Sequence<T>>.filterNot(predicate: (T) -> Boolean): Field<Sequence<T>>` Same as filterNot, but accepts Field and returns a new Field. `fun Field<String>.filterNot(predicate: (Char) -> Boolean): Field<String>`
filterNotF	Same as filterNot, but accepts Field and returns a new Field. `fun <T> Field<Iterable<T>>.filterNotF(predicate: (T) -> Field<Boolean>): Field<List<T>>` `fun <K, V> Field<Map<K, V>>.filterNotF(predicate: (Entry<K, V>) -> Field<Boolean>): Field<Map<K, V>>`
filterNotNull	Same as filterNotNull, but accepts Field and returns a new Field. `fun <T : Any> Field<Iterable<T?>>.filterNotNull(): Field<List<T>>` Same as filterNotNull, but accepts Field and returns a new Field. `fun <T : Any> Field<Sequence<T?>>.filterNotNull(): Field<Sequence<T>>`
filterNotNullToSet	Same as filterNotNullToSet, but accepts Field and returns a new Field. `fun <T : Any> Field<Iterable<T?>>.filterNotNullToSet(): Field<Set<T>>` `fun <T : Any> Field<Sequence<T?>>.filterNotNullToSet(): Field<Set<T>>`
filterNotToSet	Same as filterNotToSet, but accepts Field and returns a new Field. `fun <T> Field<Iterable<T>>.filterNotToSet(predicate: (T) -> Boolean): Field<Set<T>>` `fun <T> Field<Sequence<T>>.filterNotToSet(predicate: (T) -> Boolean): Field<Set<T>>`
filterNotToSetF	Same as filterNotToSet, but accepts Field and returns a new Field. `fun <T> Field<Iterable<T>>.filterNotToSetF(predicate: (T) -> Field<Boolean>): Field<Set<T>>`
filterToSet	Same as filterToSet, but accepts Field and returns a new Field. `fun <T> Field<Iterable<T>>.filterToSet(predicate: (T) -> Boolean): Field<Set<T>>` `fun <T> Field<Sequence<T>>.filterToSet(predicate: (T) -> Boolean): Field<Set<T>>`
filterToSetF	Same as filterToSet, but accepts Field and returns a new Field. `fun <T> Field<Iterable<T>>.filterToSetF(predicate: (T) -> Field<Boolean>): Field<Set<T>>`
filterValues	Same as filterValues, but accepts Field and returns a new Field. `fun <K, V> Field<Map<K, V>>.filterValues(predicate: (V) -> Boolean): Field<Map<K, V>>`
filterValuesF	Same as filterValues, but accepts Field and returns a new Field. `fun <K, V> Field<Map<K, V>>.filterValuesF(predicate: (V) -> Field<Boolean>): Field<Map<K, V>>`
find	Same as find, but accepts Field and returns a new Field. `fun <T> Field<Iterable<T>>.find(predicate: (T) -> Boolean): Field<T?>` Same as find, but accepts Field and returns a new Field. `fun Field<Regex>.find(input: Field<CharSequence>, startIndex: Field<Int> = com.femastudios.dataflow.util.fieldOf(0)): Field<MatchResult?>` `fun Field<Regex>.find(input: CharSequence, startIndex: Int = 0): Field<MatchResult?>` `fun Field<Regex>.find(input: Field<CharSequence>, startIndex: Int = 0): Field<MatchResult?>` `fun Field<Regex>.find(input: CharSequence, startIndex: Field<Int>): Field<MatchResult?>` Same as find, but accepts Field and returns a new Field. `fun <T> Field<Sequence<T>>.find(predicate: (T) -> Boolean): Field<T?>` Same as find, but accepts Field and returns a new Field. `fun Field<String>.find(predicate: (Char) -> Boolean): Field<Char?>`
findAll	Same as findAll, but accepts Field and returns a new Field. `fun Field<Regex>.findAll(input: Field<CharSequence>, startIndex: Field<Int> = com.femastudios.dataflow.util.fieldOf(0)): Field<Sequence<MatchResult>>` `fun Field<Regex>.findAll(input: CharSequence, startIndex: Int = 0): Field<Sequence<MatchResult>>` `fun Field<Regex>.findAll(input: Field<CharSequence>, startIndex: Int = 0): Field<Sequence<MatchResult>>` `fun Field<Regex>.findAll(input: CharSequence, startIndex: Field<Int>): Field<Sequence<MatchResult>>`
findAnyOf	Same as findAnyOf, but accepts Field and returns a new Field. `fun Field<String>.findAnyOf(strings: Field<Collection<String>>, startIndex: Field<Int> = com.femastudios.dataflow.util.fieldOf(0), ignoreCase: Field<Boolean> = com.femastudios.dataflow.util.fieldOf(false)): Field<Pair<Int, String>?>` `fun Field<String>.findAnyOf(strings: Collection<String>, startIndex: Int = 0, ignoreCase: Boolean = false): Field<Pair<Int, String>?>`
findF	Same as find, but accepts Field and returns a new Field. `fun <T> Field<Iterable<T>>.findF(predicate: (T) -> Field<Boolean>): Field<T?>`
findLast	Same as findLast, but accepts Field and returns a new Field. `fun <T> Field<Iterable<T>>.findLast(predicate: (T) -> Boolean): Field<T?>` `fun <T> Field<List<T>>.findLast(predicate: (T) -> Boolean): Field<T?>` Same as findLast, but accepts Field and returns a new Field. `fun <T> Field<Sequence<T>>.findLast(predicate: (T) -> Boolean): Field<T?>` Same as findLast, but accepts Field and returns a new Field. `fun Field<String>.findLast(predicate: (Char) -> Boolean): Field<Char?>`
findLastAnyOf	Same as findLastAnyOf, but accepts Field and returns a new Field. `fun Field<String>.findLastAnyOf(strings: Field<Collection<String>>, startIndex: Field<Int> = com.femastudios.dataflow.util.fieldOf(0), ignoreCase: Field<Boolean> = com.femastudios.dataflow.util.fieldOf(false)): Field<Pair<Int, String>?>` `fun Field<String>.findLastAnyOf(strings: Collection<String>, startIndex: Int = 0, ignoreCase: Boolean = false): Field<Pair<Int, String>?>`
findLastF	Same as findLast, but accepts Field and returns a new Field. `fun <T> Field<Iterable<T>>.findLastF(predicate: (T) -> Field<Boolean>): Field<T?>` `fun <T> Field<List<T>>.findLastF(predicate: (T) -> Field<Boolean>): Field<T?>`
first	Same as first, but returns a new Field `fun Field<CharProgression>.first(): Field<Char>` `fun Field<IntProgression>.first(): Field<Int>` `fun Field<LongProgression>.first(): Field<Long>` Same as first, but accepts Field and returns a new Field. `fun <T> Field<Iterable<T>>.first(): Field<T>` `fun <T> Field<Iterable<T>>.first(predicate: (T) -> Boolean): Field<T>` `fun <T> Field<List<T>>.first(): Field<T>` Same as first, but returns a new Field `fun <A> Field<Pair<A, >>.first(): Field<A>` Same as first, but accepts Field and returns a new Field. `fun <T> Field<Sequence<T>>.first(): Field<T>` `fun <T> Field<Sequence<T>>.first(predicate: (T) -> Boolean): Field<T>` Same as first, but accepts Field and returns a new Field. `fun Field<String>.first(): Field<Char>` `fun Field<String>.first(predicate: (Char) -> Boolean): Field<Char>` Same as first, but returns a new Field `fun <A> Field<Triple<A, , *>>.first(): Field<A>`
firstF	Same as first, but accepts Field and returns a new Field. `fun <T> Field<Iterable<T>>.firstF(predicate: (T) -> Field<Boolean>): Field<T>`
firstOrNull	Same as firstOrNull, but accepts Field and returns a new Field. `fun <T> Field<Iterable<T>>.firstOrNull(): Field<T?>` `fun <T> Field<Iterable<T>>.firstOrNull(predicate: (T) -> Boolean): Field<T?>` `fun <T> Field<List<T>>.firstOrNull(): Field<T?>` Same as firstOrNull, but accepts Field and returns a new Field. `fun <T> Field<Sequence<T>>.firstOrNull(): Field<T?>` `fun <T> Field<Sequence<T>>.firstOrNull(predicate: (T) -> Boolean): Field<T?>` Same as firstOrNull, but accepts Field and returns a new Field. `fun Field<String>.firstOrNull(): Field<Char?>` `fun Field<String>.firstOrNull(predicate: (Char) -> Boolean): Field<Char?>`
firstOrNullF	Same as firstOrNull, but accepts Field and returns a new Field. `fun <T> Field<Iterable<T>>.firstOrNullF(predicate: (T) -> Field<Boolean>): Field<T?>`
flatMap	Same as flatMap, but accepts Field and returns a new Field. `fun <T, R> Field<Iterable<T>>.flatMap(transform: (T) -> Iterable<R>): Field<List<R>>` `fun <K, V, R> Field<Map<K, V>>.flatMap(transform: (Entry<K, V>) -> Iterable<R>): Field<List<R>>` Same as flatMap, but accepts Field and returns a new Field. `fun <T, R> Field<Sequence<T>>.flatMap(transform: (T) -> Sequence<R>): Field<Sequence<R>>` Same as flatMap, but accepts Field and returns a new Field. `fun <R> Field<String>.flatMap(transform: (Char) -> Iterable<R>): Field<List<R>>`
flatMapF	Same as flatMap, but accepts Field and returns a new Field. `fun <T, R> Field<Iterable<T>>.flatMapF(transform: (T) -> Field<Iterable<R>>): Field<List<R>>` `fun <K, V, R> Field<Map<K, V>>.flatMapF(transform: (Entry<K, V>) -> Field<Iterable<R>>): Field<List<R>>`
flatMapToSet	Same as flatMapToSet, but accepts Field and returns a new Field. `fun <T, R> Field<Iterable<T>>.flatMapToSet(transform: (T) -> Iterable<R>): Field<Set<R>>` `fun <K, V, R> Field<Map<K, V>>.flatMapToSet(transform: (Entry<K, V>) -> Iterable<R>): Field<Set<R>>` `fun <T, R> Field<Sequence<T>>.flatMapToSet(transform: (T) -> Sequence<R>): Field<Set<R>>` `fun <R> Field<String>.flatMapToSet(transform: (Char) -> Iterable<R>): Field<Set<R>>`
flatMapToSetF	Same as flatMapToSet, but accepts Field and returns a new Field. `fun <T, R> Field<Iterable<T>>.flatMapToSetF(transform: (T) -> Field<Iterable<R>>): Field<Set<R>>` `fun <K, V, R> Field<Map<K, V>>.flatMapToSetF(transform: (Entry<K, V>) -> Field<Iterable<R>>): Field<Set<R>>`
flatten	Same as flatten, but accepts Field and returns a new Field. `fun <T> Field<Iterable<Iterable<T>>>.flatten(): Field<List<T>>` Same as flatten, but accepts Field and returns a new Field. `fun <T> Field<Sequence<Iterable<T>>>.flatten(): Field<Sequence<T>>` `fun <T> Field<Sequence<out Sequence<T>>>.flatten(): Field<Sequence<T>>`
flipBit	Same as flipBit, but accepts Field and returns a new Field. `fun Field<BigInteger>.flipBit(n: Field<Int>): Field<BigInteger>` `fun Field<BigInteger>.flipBit(n: Int): Field<BigInteger>`
fold	Same as fold, but accepts Field and returns a new Field. `fun <T, K, R> Field<Grouping<T, K>>.fold(initialValue: R, operation: (accumulator: R, element: T) -> R): Field<Map<K, R>>` `fun <T, K, R> Field<Grouping<T, K>>.fold(initialValue: Field<R>, operation: (accumulator: R, element: T) -> R): Field<Map<K, R>>` `fun <T, K, R> Field<Grouping<T, K>>.fold(initialValueSelector: (key: K, element: T) -> R, operation: (key: K, accumulator: R, element: T) -> R): Field<Map<K, R>>` `fun <T, R> Field<Iterable<T>>.fold(initial: R, operation: (acc: R, T) -> R): Field<R>` `fun <T, R> Field<Iterable<T>>.fold(initial: Field<R>, operation: (acc: R, T) -> R): Field<R>` Same as fold, but accepts Field and returns a new Field. `fun <T, R> Field<Sequence<T>>.fold(initial: R, operation: (acc: R, T) -> R): Field<R>` `fun <T, R> Field<Sequence<T>>.fold(initial: Field<R>, operation: (acc: R, T) -> R): Field<R>` Same as fold, but accepts Field and returns a new Field. `fun <R> Field<String>.fold(initial: R, operation: (acc: R, Char) -> R): Field<R>` `fun <R> Field<String>.fold(initial: Field<R>, operation: (acc: R, Char) -> R): Field<R>`
foldIndexed	Same as foldIndexed, but accepts Field and returns a new Field. `fun <T, R> Field<Iterable<T>>.foldIndexed(initial: R, operation: (index: Int, acc: R, T) -> R): Field<R>` `fun <T, R> Field<Iterable<T>>.foldIndexed(initial: Field<R>, operation: (index: Int, acc: R, T) -> R): Field<R>` Same as foldIndexed, but accepts Field and returns a new Field. `fun <T, R> Field<Sequence<T>>.foldIndexed(initial: R, operation: (index: Int, acc: R, T) -> R): Field<R>` `fun <T, R> Field<Sequence<T>>.foldIndexed(initial: Field<R>, operation: (index: Int, acc: R, T) -> R): Field<R>` Same as foldIndexed, but accepts Field and returns a new Field. `fun <R> Field<String>.foldIndexed(initial: R, operation: (index: Int, acc: R, Char) -> R): Field<R>` `fun <R> Field<String>.foldIndexed(initial: Field<R>, operation: (index: Int, acc: R, Char) -> R): Field<R>`
foldRight	Same as foldRight, but accepts Field and returns a new Field. `fun <T, R> Field<List<T>>.foldRight(initial: R, operation: (T, acc: R) -> R): Field<R>` `fun <T, R> Field<List<T>>.foldRight(initial: Field<R>, operation: (T, acc: R) -> R): Field<R>` Same as foldRight, but accepts Field and returns a new Field. `fun <R> Field<String>.foldRight(initial: R, operation: (Char, acc: R) -> R): Field<R>` `fun <R> Field<String>.foldRight(initial: Field<R>, operation: (Char, acc: R) -> R): Field<R>`
foldRightIndexed	Same as foldRightIndexed, but accepts Field and returns a new Field. `fun <T, R> Field<List<T>>.foldRightIndexed(initial: R, operation: (index: Int, T, acc: R) -> R): Field<R>` `fun <T, R> Field<List<T>>.foldRightIndexed(initial: Field<R>, operation: (index: Int, T, acc: R) -> R): Field<R>` Same as foldRightIndexed, but accepts Field and returns a new Field. `fun <R> Field<String>.foldRightIndexed(initial: R, operation: (index: Int, Char, acc: R) -> R): Field<R>` `fun <R> Field<String>.foldRightIndexed(initial: Field<R>, operation: (index: Int, Char, acc: R) -> R): Field<R>`
format	Same as format, but accepts Field and returns a new Field. `fun Field<String>.format(locale: Field<Locale>, vararg args: Field<Any?>): Field<String>` `fun Field<String>.format(locale: Field<Locale>, vararg args: Any?): Field<String>` `fun Field<String>.format(locale: Locale, vararg args: Field<Any?>): Field<String>` `fun Field<String>.format(locale: Locale, vararg args: Any?): Field<String>` `fun Field<String>.format(vararg args: Field<Any?>): Field<String>` `fun Field<String>.format(vararg args: Any?): Field<String>`
gcd	Same as gcd, but accepts Field and returns a new Field. `fun Field<BigInteger>.gcd(val: Field<BigInteger>): Field<BigInteger>` `fun Field<BigInteger>.gcd(val: BigInteger): Field<BigInteger>`
get	Same as get, but accepts Field and returns a new Field. `operator fun <E> Field<List<E>>.get(index: Field<Int>): Field<E>` `operator fun <E> Field<List<E>>.get(index: Int): Field<E>` Same as get, but accepts Field and returns a new Field. `operator fun <K, V> Field<Map<in K, V>>.get(key: K): Field<V?>` `operator fun <K, V> Field<Map<in K, V>>.get(key: Field<K>): Field<V?>` Same as get, but accepts Field and returns a new Field. `operator fun Field<MatchGroupCollection>.get(index: Field<Int>): Field<MatchGroup?>` `operator fun Field<MatchGroupCollection>.get(index: Int): Field<MatchGroup?>` Same as get, but accepts Field and returns a new Field. `operator fun Field<MatchNamedGroupCollection>.get(name: Field<String>): Field<MatchGroup?>` `operator fun Field<MatchNamedGroupCollection>.get(name: String): Field<MatchGroup?>` Same as get, but accepts Field and returns a new Field. `operator fun Field<String>.get(index: Field<Int>): Field<Char>` `operator fun Field<String>.get(index: Int): Field<Char>`
getLowestSetBit	Same as getLowestSetBit, but accepts Field and returns a new Field. `fun Field<BigInteger>.getLowestSetBit(): Field<Int>`
getOrDefault	Same as getOrDefault, but accepts Field and returns a new Field. `fun <K, V> Field<Map<in K, V>>.getOrDefault(key: K, defaultValue: V): Field<V>` `fun <K, V> Field<Map<in K, V>>.getOrDefault(key: K, defaultValue: Field<V>): Field<V>` `fun <K, V> Field<Map<in K, V>>.getOrDefault(key: Field<K>, defaultValue: V): Field<V>` `fun <K, V> Field<Map<in K, V>>.getOrDefault(key: Field<K>, defaultValue: Field<V>): Field<V>`
getOrElse	Same as getOrElse, but accepts Field and returns a new Field. `fun <T> Field<List<T>>.getOrElse(index: Field<Int>, defaultValue: (Int) -> T): Field<T>` `fun <T> Field<List<T>>.getOrElse(index: Int, defaultValue: (Int) -> T): Field<T>` `fun <K, V> Field<Map<K, V>>.getOrElse(key: K, defaultValue: () -> V): Field<V>` `fun <K, V> Field<Map<K, V>>.getOrElse(key: Field<K>, defaultValue: () -> V): Field<V>` Same as getOrElse, but accepts Field and returns a new Field. `fun Field<String>.getOrElse(index: Field<Int>, defaultValue: (Int) -> Char): Field<Char>` `fun Field<String>.getOrElse(index: Int, defaultValue: (Int) -> Char): Field<Char>`
getOrElseF	Same as getOrElse, but accepts Field and returns a new Field. `fun <K, V> Field<Map<K, V>>.getOrElseF(key: Field<K>, defaultValue: (key: K) -> Field<V>): Field<V>` `fun <K, V> Field<Map<K, V>>.getOrElseF(key: K, defaultValue: () -> Field<V>): Field<V>`
getOrNull	Same as getOrNull, but accepts Field and returns a new Field. `fun <T> Field<List<T>>.getOrNull(index: Field<Int>): Field<T?>` `fun <T> Field<List<T>>.getOrNull(index: Int): Field<T?>` Same as getOrNull, but accepts Field and returns a new Field. `fun Field<String>.getOrNull(index: Field<Int>): Field<Char?>` `fun Field<String>.getOrNull(index: Int): Field<Char?>`
getPrecision	Same as getPrecision, but accepts Field and returns a new Field. `fun Field<MathContext>.getPrecision(): Field<Int>`
getRoundingMode	Same as getRoundingMode, but accepts Field and returns a new Field. `fun Field<MathContext>.getRoundingMode(): Field<RoundingMode>`
getValue	Same as getValue, but accepts Field and returns a new Field. `fun <K, V> Field<Map<K, V>>.getValue(key: K): Field<V>` `fun <K, V> Field<Map<K, V>>.getValue(key: Field<K>): Field<V>`
groupBy	Same as groupBy, but accepts Field and returns a new Field. `fun <T, K, V> Field<Iterable<T>>.groupBy(keySelector: (T) -> K, valueTransform: (T) -> V): Field<Map<K, List<V>>>` `fun <T, K> Field<Iterable<T>>.groupBy(keySelector: (T) -> K): Field<Map<K, List<T>>>` Same as groupBy, but accepts Field and returns a new Field. `fun <T, K, V> Field<Sequence<T>>.groupBy(keySelector: (T) -> K, valueTransform: (T) -> V): Field<Map<K, List<V>>>` `fun <T, K> Field<Sequence<T>>.groupBy(keySelector: (T) -> K): Field<Map<K, List<T>>>` Same as groupBy, but accepts Field and returns a new Field. `fun <K, V> Field<String>.groupBy(keySelector: (Char) -> K, valueTransform: (Char) -> V): Field<Map<K, List<V>>>` `fun <K> Field<String>.groupBy(keySelector: (Char) -> K): Field<Map<K, List<Char>>>`
groupByF	Same as groupBy, but accepts Field and returns a new Field. `fun <T, K, V> Field<Iterable<T>>.groupByF(keySelector: (T) -> Field<K>, valueTransform: (T) -> Field<V>): Field<Map<K, List<V>>>` `fun <T, K> Field<Iterable<T>>.groupByF(keySelector: (T) -> Field<K>): Field<Map<K, List<T>>>`
groupingBy	Same as groupingBy, but accepts Field and returns a new Field. `fun <T, K> Field<Iterable<T>>.groupingBy(keySelector: (T) -> K): Field<Grouping<T, K>>` Same as groupingBy, but accepts Field and returns a new Field. `fun <T, K> Field<Sequence<T>>.groupingBy(keySelector: (T) -> K): Field<Grouping<T, K>>` Same as groupingBy, but accepts Field and returns a new Field. `fun <K> Field<String>.groupingBy(keySelector: (Char) -> K): Field<Grouping<Char, K>>`
groupingByF	Same as groupingBy, but accepts Field and returns a new Field. `fun <T, K> Field<Iterable<T>>.groupingByF(keySelector: (T) -> Field<K>): Field<Grouping<T, K>>`
groups	Same as groups, but returns a new Field `fun Field<MatchResult>.groups(): Field<MatchGroupCollection>`
groupValues	Same as groupValues, but returns a new Field `fun Field<MatchResult>.groupValues(): Field<List<String>>`
gt	Returns a Field whose value is `true` when the first value is greater than the second one `infix fun <T : Comparable<T>> Field<T>.gt(another: Field<T>): Field<Boolean>` `infix fun <T : Comparable<T>> Field<T>.gt(another: T): Field<Boolean>`
gte	Returns a Field whose value is `true` when the first value is greater than or equal to second one `infix fun <T : Comparable<T>> Field<T>.gte(another: Field<T>): Field<Boolean>` `infix fun <T : Comparable<T>> Field<T>.gte(another: T): Field<Boolean>`
hasSurrogatePairAt	Same as hasSurrogatePairAt, but accepts Field and returns a new Field. `fun Field<String>.hasSurrogatePairAt(`