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(