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

Package com.femastudios.dataflow.extensions

Package that contains extensions to both Field and MutableField.

A function is provided as extension function when the behavior depends on the enclosed data. For example, only on a Field<Boolean> it's possible to call .not().

val f = fieldOf(true)
val notF /*: Field<Boolean>*/ = f.not()
notF.value //yields false

Extension functions are particularly useful in Kotlin, since on Java you have to call them statically, for example: Field<Boolean> f2 = BooleanFieldUtils.not(f);

Extensions for External Classes

java.math.BigDecimal

java.math.BigInteger

kotlin.Boolean

kotlin.Byte

kotlin.Char

kotlin.collections.Collection

kotlin.collections.Grouping

kotlin.collections.Iterable

kotlin.collections.List

kotlin.collections.Map

kotlin.collections.Set

kotlin.Comparable

kotlin.Double

kotlin.Float

kotlin.Int

kotlin.Long

kotlin.ranges.CharProgression

kotlin.ranges.ClosedFloatingPointRange

kotlin.ranges.ClosedRange

kotlin.ranges.IntProgression

kotlin.ranges.LongProgression

kotlin.sequences.Sequence

kotlin.Short

kotlin.String

kotlin.text.CharCategory

kotlin.text.MatchGroupCollection

kotlin.text.MatchNamedGroupCollection

kotlin.text.Regex

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>

acos

Same as acos, but accepts Field and returns a new Field.

fun acos(x: Field<Float>): Field<Float>
fun acos(x: Field<Double>): Field<Double>

acosh

Same as acosh, but accepts Field and returns a new Field.

fun acosh(x: Field<Float>): Field<Float>
fun acosh(x: Field<Double>): Field<Double>

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>

Adds the given element to the collection. The operation is atomic and thread-safe.

fun <T> MutableField<Collection<T>>.add(element: T): Boolean
fun <T> MutableField<List<T>>.add(element: T): Unit
fun <T> MutableField<Set<T>>.add(element: T): Boolean

addIf

Adds the given element to the collection if the condition is satisfied. The operation is atomic and thread-safe.

fun <T> MutableField<Collection<T>>.addIf(element: T, condition: (Collection<T>) -> Boolean): Boolean
fun <T> MutableField<List<T>>.addIf(element: T, condition: (List<T>) -> Boolean): Boolean
fun <T> MutableField<Set<T>>.addIf(element: T, condition: (Set<T>) -> Boolean): Boolean

addIfNotContains

Adds the given element to the collection if not already present. The operation is atomic and thread-safe.

fun <T> MutableField<Collection<T>>.addIfNotContains(element: T): Boolean
fun <T> MutableField<List<T>>.addIfNotContains(element: T): Boolean

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>

asin

Same as asin, but accepts Field and returns a new Field.

fun asin(x: Field<Float>): Field<Float>
fun asin(x: Field<Double>): Field<Double>

asinh

Same as asinh, but accepts Field and returns a new Field.

fun asinh(x: Field<Float>): Field<Float>
fun asinh(x: Field<Double>): Field<Double>

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>>

asStringF

Returns a new MutableField whose value is the string representation of the value of this MutableField.

fun MutableField<Double>.asStringF(fallbackOnError: (String) -> Double = { 0.0 }): MutableField<String>
fun MutableField<Float>.asStringF(fallbackOnError: (String) -> Float = { 0F }): MutableField<String>
fun MutableField<Int>.asStringF(fallbackOnError: (String) -> Int = { 0 }): MutableField<String>
fun MutableField<Long>.asStringF(fallbackOnError: (String) -> Long = { 0L }): MutableField<String>

atan

Same as atan, but accepts Field and returns a new Field.

fun atan(x: Field<Float>): Field<Float>
fun atan(x: Field<Double>): Field<Double>

atan2

Same as atan2, but accepts Field and returns a new Field.

fun atan2(y: Field<Float>, x: Field<Float>): Field<Float>
fun atan2(y: Field<Float>, x: Float): Field<Float>
fun atan2(y: Float, x: Field<Float>): Field<Float>
fun atan2(y: Field<Double>, x: Field<Double>): Field<Double>
fun atan2(y: Field<Double>, x: Double): Field<Double>
fun atan2(y: Double, x: Field<Double>): Field<Double>

atanh

Same as atanh, but accepts Field and returns a new Field.

fun atanh(x: Field<Float>): Field<Float>
fun atanh(x: Field<Double>): Field<Double>

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>

ceil

Same as ceil, but accepts Field and returns a new Field.

fun ceil(x: Field<Float>): Field<Float>
fun ceil(x: Field<Double>): Field<Double>

charset

Same as charset, but accepts Field and returns a new Field.

fun charset(charsetName: Field<String>): Field<Charset>

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>>

clear

Removes all the elements in the collection. The operation is atomic and thread-safe.

fun <T> MutableField<Collection<T>>.clear(): Unit
fun <T> MutableField<Iterable<T>>.clear(): Unit
fun <T> MutableField<List<T>>.clear(): Unit
fun <K, V> MutableField<Map<K, V>>.clear(): Unit
fun <T> MutableField<Set<T>>.clear(): Unit

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 <T : Comparable<T>> 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 <T : Comparable<T>> 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 <T : Comparable<T>> T.coerceIn(minimumValue: T?, maximumValue: Field<T?>?): Field<T>
fun <T : Comparable<T>> T.coerceIn(minimumValue: Field<T?>?, maximumValue: T?): Field<T>
fun <T : Comparable<T>> T.coerceIn(minimumValue: Field<T?>?, maximumValue: Field<T?>?): Field<T>
fun <T : Comparable<T>> T.coerceIn(range: Field<ClosedRange<T>>): Field<T>
fun <T : Comparable<T>> T.coerceIn(range: Field<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>

compareValues

Same as compareValues, but accepts Field and returns a new Field.

fun <T : Comparable<*>> compareValues(a: T?, b: Field<T?>?): Field<Int>
fun <T : Comparable<*>> compareValues(a: Field<T?>?, b: T?): Field<Int>
fun <T : Comparable<*>> compareValues(a: Field<T?>?, b: Field<T?>?): Field<Int>

compareValuesBy

Same as compareValuesBy, but accepts Field and returns a new Field.

fun <T> compareValuesBy(a: Field<T>, b: Field<T>, vararg selectors: Field<(T) -> Comparable<*>?>): 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>

cos

Same as cos, but accepts Field and returns a new Field.

fun cos(x: Field<Float>): Field<Float>
fun cos(x: Field<Double>): Field<Double>

cosh

Same as cosh, but accepts Field and returns a new Field.

fun cosh(x: Field<Float>): Field<Float>
fun cosh(x: Field<Double>): Field<Double>

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>

decrement

Decrements the MutableField by the given quantity (1 by default).

fun MutableField<Double>.decrement(by: Double = 1.0): Unit
fun MutableField<Float>.decrement(by: Float = 1F): Unit
fun MutableField<Int>.decrement(by: Int = 1): Unit
fun MutableField<Long>.decrement(by: Long = 1): Unit

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>
infix fun <T> T.eq(another: Field<T>): Field<Boolean>

exp

Same as exp, but accepts Field and returns a new Field.

fun exp(x: Field<Float>): Field<Float>
fun exp(x: Field<Double>): Field<Double>

expm1

Same as expm1, but accepts Field and returns a new Field.

fun expm1(x: Field<Float>): Field<Float>
fun expm1(x: Field<Double>): Field<Double>

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>

Returns a MutableField that represents the first item of the pair contained in this MutableField. When changing the value of the returned field, a new pair will be created and set on this field.

fun <A, B> MutableField<Pair<A, B>>.first(): MutableField<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>

floor

Same as floor, but accepts Field and returns a new Field.

fun floor(x: Field<Float>): Field<Float>
fun floor(x: Field<Double>): Field<Double>

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(