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

FieldWrapper

interface FieldWrapper<T> : MutableField<T>

This interface extends MutableField, but adds the possibility to mirror another Field.

When a Field is attached using setField, the value of this FieldWrapper will mirror the one of the Field until detachField is called, or value is externally changed.

To create a new FieldWrapper, you can use the function fieldWrapperOf or FieldWrapper.of.

Functions

detachField

Stops mirroring the Field attached via setField.

abstract fun detachField(): Unit

setField

Tells this FieldWrapper to mirror the value of field until detachField is called, or value is externally changed.

abstract fun setField(field: Field<T>): Unit

Companion Object Functions

of

Creates a new FieldWrapper with the given initial value.

fun <T> of(value: T): FieldWrapper<T>

Constructs a new FieldWrapper, which initially mirrors the given field.

fun <T> of(field: Field<T>): FieldWrapper<T>

ofNull

Constructs a new FieldWrapper that initially holds null.

fun <T> ofNull(): FieldWrapper<T?>

Extension Functions

abs

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

fun Field<BigDecimal>.abs(mc: Field<MathContext>): Field<BigDecimal>
fun Field<BigDecimal>.abs(mc: MathContext): Field<BigDecimal>

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(predicate: (T) -> Boolean): 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(predicate: (T) -> Boolean): Field<Boolean>

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

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>

asReversed

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

fun <T> Field<List<T>>.asReversed(): Field<List<T>>

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>

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

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

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

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 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 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 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 <T> Field<Comparable<T>>.compareTo(other: T): Field<Int>
fun <T> Field<Comparable<T>>.compareTo(other: Field<T>): Field<Int>

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<Iterable<T>>.count(predicate: (T) -> Boolean): 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(predicate: (T) -> Boolean): Field<Int>

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

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>

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>

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>

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<Char>.downTo(to: Field<Char>): Field<CharProgression>
infix fun Field<Char>.downTo(to: Char): Field<CharProgression>

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

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>

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

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

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<Sequence<*>>.filterIsInstanceToSet(klass: Field<Class<R>>): Field<Set<R>>
fun <R> Field<Sequence<*>>.filterIsInstanceToSet(klass: Class<R>): 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>>

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 accepts Field and returns a new Field.

fun <T> Field<Iterable<T>>.first(predicate: (T) -> Boolean): Field<T>

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

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(predicate: (Char) -> Boolean): Field<Char>

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(predicate: (T) -> Boolean): Field<T?>

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

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

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 <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<MatchNamedGroupCollection>.get(name: Field<String>): Field<MatchGroup?>
operator fun Field<MatchNamedGroupCollection>.get(name: String): Field<MatchGroup?>

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>

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

hasSurrogatePairAt

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

fun Field<String>.hasSurrogatePairAt(index: Field<Int>): Field<Boolean>
fun Field<String>.hasSurrogatePairAt(index: Int): Field<Boolean>

IEEErem

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

fun Field<Double>.IEEErem(divisor: Field<Double>): Field<Double>
fun Field<Double>.IEEErem(divisor: Double): Field<Double>
fun Field<Float>.IEEErem(divisor: Field<Float>): Field<Float>
fun Field<Float>.IEEErem(divisor: Float): Field<Float>

ifEmpty

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

fun <T> Field<Sequence<T>>.ifEmpty(defaultValue: () -> Sequence<T>): Field<Sequence<T>>

increment

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

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

index

Same as index, but returns a new Field

fun Field<IndexedValue<*>>.index(): Field<Int>

indexOf

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

fun <T> Field<Iterable<T>>.indexOf(element: T): Field<Int>
fun <T> Field<Iterable<T>>.indexOf(element: Field<T>): Field<Int>

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

fun <T> Field<Sequence<T>>.indexOf(element: T): Field<Int>
fun <T> Field<Sequence<T>>.indexOf(element: Field<T>): Field<Int>

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

fun Field<String>.indexOf(string: Field<String>, startIndex: Field<Int> = com.femastudios.dataflow.util.fieldOf(0), ignoreCase: Field<Boolean> = com.femastudios.dataflow.util.fieldOf(false)): Field<Int>
fun Field<String>.indexOf(string: String, startIndex: Int = 0, ignoreCase: Boolean = false): Field<Int>
fun Field<String>.indexOf(char: Field<Char>, startIndex: Field<Int> = com.femastudios.dataflow.util.fieldOf(0), ignoreCase: Field<Boolean> = com.femastudios.dataflow.util.fieldOf(false)): Field<Int>
fun Field<String>.indexOf(char: Char, startIndex: Int = 0, ignoreCase: Boolean = false): Field<Int>

indexOfAny

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

fun Field<String>.indexOfAny(strings: Field<Collection<String>>, startIndex: Field<Int> = com.femastudios.dataflow.util.fieldOf(0), ignoreCase: Field<Boolean> = com.femastudios.dataflow.util.fieldOf(false)): Field<Int>
fun Field<String>.indexOfAny(strings: Collection<String>, startIndex: Int = 0, ignoreCase: Boolean = false): Field<Int>
fun Field<String>.indexOfAny(chars: Field<CharArray>, startIndex: Field<Int> = com.femastudios.dataflow.util.fieldOf(0), ignoreCase: Field<Boolean> = com.femastudios.dataflow.util.fieldOf(false)): Field<Int>
fun Field<String>.indexOfAny(chars: CharArray, startIndex: Int = 0, ignoreCase: Boolean = false): Field<Int>

indexOfFirst

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

fun <T> Field<Iterable<T>>.indexOfFirst(predicate: (T) -> Boolean): Field<Int>
fun <T> Field<List<T>>.indexOfFirst(predicate: (T) -> Boolean): Field<Int>

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

fun <T> Field<Sequence<T>>.indexOfFirst(predicate: (T) -> Boolean): Field<Int>

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

fun Field<String>.indexOfFirst(predicate: (Char) -> Boolean): Field<Int>

indexOfFirstF

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

fun <T> Field<Iterable<T>>.indexOfFirstF(predicate: (T) -> Field<Boolean>): Field<Int>
fun <T> Field<List<T>>.indexOfFirstF(predicate: (T) -> Field<Boolean>): Field<Int>

indexOfLast

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

fun <T> Field<Iterable<T>>.indexOfLast(predicate: (T) -> Boolean): Field<Int>
fun <T> Field<List<T>>.indexOfLast(predicate: (T) -> Boolean): Field<Int>

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

fun <T> Field<Sequence<T>>.indexOfLast(predicate: (T) -> Boolean): Field<Int>

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

fun Field<String>.indexOfLast(predicate: (Char) -> Boolean): Field<Int>

indexOfLastF

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

fun <T> Field<Iterable<T>>.indexOfLastF(predicate: (T) -> Field<Boolean>): Field<Int>
fun <T> Field<List<T>>.indexOfLastF(predicate: (T) -> Field<Boolean>): Field<Int>

interpolate

Returns a Field whose value is a T obtained by interpolating the values of the Map at index ⌊position⌋ and ⌊position⌋ + 1.

fun <T> Field<Map<Int, Field<T>>>.interpolate(position: Field<Float>, fallback: Field<T>, interpolator: (firstIndex: T, secondIndex: T, interpolation: Float) -> T): Field<T>

Returns a Field whose value is a Float obtained by interpolating the values of the Map at index ⌊position⌋ and ⌊position⌋ + 1.

fun Field<Map<Int, Field<Float>>>.interpolate(position: Field<Float>, fallback: Float = 0f, interpolator: (firstIndex: Float, secondIndex: Float, Float) -> Float = { a, b, p -> a + p * (b - a) }): Field<Float>

intersect

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

infix fun <T> Field<Iterable<T>>.intersect(other: Field<Iterable<T>>): Field<Set<T>>
infix fun <T> Field<Iterable<T>>.intersect(other: Iterable<T>): Field<Set<T>>

isBlank

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

fun Field<String>.isBlank(): Field<Boolean>

isDefined

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

fun Field<Char>.isDefined(): Field<Boolean>

isDigit

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

fun Field<Char>.isDigit(): Field<Boolean>

isHighSurrogate

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

fun Field<Char>.isHighSurrogate(): Field<Boolean>

isIdentifierIgnorable

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

fun Field<Char>.isIdentifierIgnorable(): Field<Boolean>

isISOControl

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

fun Field<Char>.isISOControl(): Field<Boolean>

isJavaIdentifierPart

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

fun Field<Char>.isJavaIdentifierPart(): Field<Boolean>

isJavaIdentifierStart

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

fun Field<Char>.isJavaIdentifierStart(): Field<Boolean>

isLetter

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

fun Field<Char>.isLetter(): Field<Boolean>

isLetterOrDigit

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

fun Field<Char>.isLetterOrDigit(): Field<Boolean>

isLowerCase

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

fun Field<Char>.isLowerCase(): Field<Boolean>

isLowSurrogate

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

fun Field<Char>.isLowSurrogate(): Field<Boolean>

isNotBlank

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

fun Field<String>.isNotBlank(): Field<Boolean>

isNullOrBlank

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

fun Field<String?>?.isNullOrBlank(): Field<Boolean>

isProbablePrime

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

fun Field<BigInteger>.isProbablePrime(certainty: Field<Int>): Field<Boolean>
fun Field<BigInteger>.isProbablePrime(certainty: Int): Field<Boolean>

isSurrogate

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

fun Field<Char>.isSurrogate(): Field<Boolean>

isTitleCase

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

fun Field<Char>.isTitleCase(): Field<Boolean>

isUpperCase

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

fun Field<Char>.isUpperCase(): Field<Boolean>

isWhitespace

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

fun Field<Char>.isWhitespace(): Field<Boolean>

joinToString

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

fun <T> Field<Iterable<T>>.joinToString(separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: ((T) -> CharSequence)? = null): Field<String>
fun <T> Field<Iterable<T>>.joinToString(separator: Field<CharSequence>, prefix: Field<CharSequence> = com.femastudios.dataflow.util.fieldOf(""), postfix: Field<CharSequence> = com.femastudios.dataflow.util.fieldOf(""), limit: Field<Int> = com.femastudios.dataflow.util.fieldOf(-1), truncated: Field<CharSequence> = com.femastudios.dataflow.util.fieldOf("..."), transform: ((T) -> CharSequence)? = null): Field<String>

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

fun <T> Field<Sequence<T>>.joinToString(separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: ((T) -> CharSequence)? = null): Field<String>
fun <T> Field<Sequence<T>>.joinToString(separator: Field<CharSequence>, prefix: Field<CharSequence> = com.femastudios.dataflow.util.fieldOf(""), postfix: Field<CharSequence> = com.femastudios.dataflow.util.fieldOf(""), limit: Field<Int> = com.femastudios.dataflow.util.fieldOf(-1), truncated: Field<CharSequence> = com.femastudios.dataflow.util.fieldOf("..."), transform: ((T) -> CharSequence)? = null): Field<String>

joinToStringF

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

fun <T> Field<Iterable<T>>.joinToStringF(separator: Field<CharSequence>, prefix: Field<CharSequence> = com.femastudios.dataflow.util.fieldOf(""), postfix: Field<CharSequence> = com.femastudios.dataflow.util.fieldOf(""), limit: Field<Int> = com.femastudios.dataflow.util.fieldOf(-1), truncated: Field<CharSequence> = com.femastudios.dataflow.util.fieldOf("..."), transform: (T) -> Field<CharSequence>): Field<String>
fun <T> Field<Iterable<T>>.joinToStringF(separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: (T) -> Field<CharSequence>): Field<String>

key

Same as key, but returns a new Field

fun <K> Field<Entry<K, *>>.key(): Field<K>

keyOf

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

fun <T, K> Field<Grouping<in T, K>>.keyOf(element: T): Field<K>
fun <T, K> Field<Grouping<in T, K>>.keyOf(element: Field<T>): Field<K>

keys

Same as keys, but returns a new Field

fun <K> Field<Map<out K, *>>.keys(): Field<Set<K>>

last

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

fun <T> Field<Iterable<T>>.last(predicate: (T) -> Boolean): Field<T>
fun <T> Field<List<T>>.last(predicate: (T) -> Boolean): Field<T>

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

fun <T> Field<Sequence<T>>.last(predicate: (T) -> Boolean): Field<T>

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

fun Field<String>.last(predicate: (Char) -> Boolean): Field<Char>

lastF

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

fun <T> Field<Iterable<T>>.lastF(predicate: (T) -> Field<Boolean>): Field<T>
fun <T> Field<List<T>>.lastF(predicate: (T) -> Field<Boolean>): Field<T>

lastIndexOf

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

fun <T> Field<Iterable<T>>.lastIndexOf(element: T): Field<Int>
fun <T> Field<Iterable<T>>.lastIndexOf(element: Field<T>): Field<Int>

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

fun <T> Field<Sequence<T>>.lastIndexOf(element: T): Field<Int>
fun <T> Field<Sequence<T>>.lastIndexOf(element: Field<T>): Field<Int>

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

fun Field<String>.lastIndexOf(string: Field<String>, startIndex: Field<Int> = com.femastudios.dataflow.util.fieldOf(0), ignoreCase: Field<Boolean> = com.femastudios.dataflow.util.fieldOf(false)): Field<Int>
fun Field<String>.lastIndexOf(string: String, startIndex: Int = 0, ignoreCase: Boolean = false): Field<Int>
fun Field<String>.lastIndexOf(char: Field<Char>, startIndex: Field<Int> = com.femastudios.dataflow.util.fieldOf(0), ignoreCase: Field<Boolean> = com.femastudios.dataflow.util.fieldOf(false)): Field<Int>
fun Field<String>.lastIndexOf(char: Char, startIndex: Int = 0, ignoreCase: Boolean = false): Field<Int>

lastIndexOfAny

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

fun Field<String>.lastIndexOfAny(strings: Field<Collection<String>>, startIndex: Field<Int> = com.femastudios.dataflow.util.fieldOf(0), ignoreCase: Field<Boolean> = com.femastudios.dataflow.util.fieldOf(false)): Field<Int>
fun Field<String>.lastIndexOfAny(strings: Collection<String>, startIndex: Int = 0, ignoreCase: Boolean = false): Field<Int>
fun Field<String>.lastIndexOfAny(chars: Field<CharArray>, startIndex: Field<Int> = com.femastudios.dataflow.util.fieldOf(0), ignoreCase: Field<Boolean> = com.femastudios.dataflow.util.fieldOf(false)): Field<Int>
fun Field<String>.lastIndexOfAny(chars: CharArray, startIndex: Int = 0, ignoreCase: Boolean = false): Field<Int>

lastOrNull

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

fun <T> Field<Iterable<T>>.lastOrNull(predicate: (T) -> Boolean): Field<T?>
fun <T> Field<List<T>>.lastOrNull(predicate: (T) -> Boolean): Field<T?>

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

fun <T> Field<Sequence<T>>.lastOrNull(predicate: (T) -> Boolean): Field<T?>

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

fun Field<String>.lastOrNull(predicate: (Char) -> Boolean): Field<Char?>

lastOrNullF

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

fun <T> Field<Iterable<T>>.lastOrNullF(predicate: (T) -> Field<Boolean>): Field<T?>
fun <T> Field<List<T>>.lastOrNullF(predicate: (T) -> Field<Boolean>): Field<T?>

length

Same as length, but returns a new Field

fun Field<String>.length(): Field<Int>

lessThanOrEquals

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

fun <T : Comparable<T>> Field<ClosedFloatingPointRange<in T>>.lessThanOrEquals(a: T, b: T): Field<Boolean>
fun <T : Comparable<T>> Field<ClosedFloatingPointRange<in T>>.lessThanOrEquals(a: T, b: Field<T>): Field<Boolean>
fun <T : Comparable<T>> Field<ClosedFloatingPointRange<in T>>.lessThanOrEquals(a: Field<T>, b: T): Field<Boolean>
fun <T : Comparable<T>> Field<ClosedFloatingPointRange<in T>>.lessThanOrEquals(a: Field<T>, b: Field<T>): Field<Boolean>

lines

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

fun Field<String>.lines(): Field<List<String>>

lineSequence

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

fun Field<String>.lineSequence(): Field<Sequence<String>>

map

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

fun <T, R> Field<Iterable<T>>.map(transform: (T) -> R): Field<List<R>>
fun <K, V, R> Field<Map<K, V>>.map(transform: (Entry<K, V>) -> R): Field<List<R>>

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

fun <T, R> Field<Sequence<T>>.map(transform: (T) -> R): Field<Sequence<R>>

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

fun <R> Field<String>.map(transform: (Char) -> R): Field<List<R>>

mapF

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

fun <T, R> Field<Iterable<T>>.mapF(transform: (T) -> Field<R>): Field<List<R>>
fun <K, V, R> Field<Map<K, V>>.mapF(transform: (Entry<K, V>) -> Field<R>): Field<List<R>>

mapIndexed

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

fun <T, R> Field<Iterable<T>>.mapIndexed(transform: (index: Int, T) -> R): Field<List<R>>

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

fun <T, R> Field<Sequence<T>>.mapIndexed(transform: (index: Int, T) -> R): Field<Sequence<R>>

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

fun <R> Field<String>.mapIndexed(transform: (index: Int, Char) -> R): Field<List<R>>

mapIndexedNotNull

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

fun <T, R : Any> Field<Iterable<T>>.mapIndexedNotNull(transform: (index: Int, T) -> R?): Field<List<R>>

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

fun <T, R : Any> Field<Sequence<T>>.mapIndexedNotNull(transform: (index: Int, T) -> R?): Field<Sequence<R>>

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

fun <R : Any> Field<String>.mapIndexedNotNull(transform: (index: Int, Char) -> R?): Field<List<R>>

mapIndexedNotNullToSet

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

fun <T, R : Any> Field<Iterable<T>>.mapIndexedNotNullToSet(transform: (index: Int, T) -> R?): Field<Set<R>>
fun <T, R : Any> Field<Sequence<T>>.mapIndexedNotNullToSet(transform: (index: Int, T) -> R?): Field<Set<R>>
fun <R : Any> Field<String>.mapIndexedNotNullToSet(transform: (index: Int, Char) -> R?): Field<Set<R>>

mapIndexedToSet

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

fun <T, R> Field<Iterable<T>>.mapIndexedToSet(transform: (index: Int, T) -> R): Field<Set<R>>
fun <T, R> Field<Sequence<T>>.mapIndexedToSet(transform: (index: Int, T) -> R): Field<Set<R>>
fun <R> Field<String>.mapIndexedToSet(transform: (index: Int, Char) -> R): Field<Set<R>>

mapKeys

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

fun <K, V, R> Field<Map<K, V>>.mapKeys(transform: (Entry<K, V>) -> R): Field<Map<R, V>>

mapKeysF

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

fun <K, V, R> Field<Map<K, V>>.mapKeysF(transform: (Entry<K, V>) -> Field<R>): Field<Map<R, V>>

mapNotNull

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

fun <T, R : Any> Field<Iterable<T>>.mapNotNull(transform: (T) -> R?): Field<List<R>>
fun <K, V, R : Any> Field<Map<K, V>>.mapNotNull(transform: (Entry<K, V>) -> R?): Field<List<R>>

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

fun <T, R : Any> Field<Sequence<T>>.mapNotNull(transform: (T) -> R?): Field<Sequence<R>>

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

fun <R : Any> Field<String>.mapNotNull(transform: (Char) -> R?): Field<List<R>>

mapNotNullF

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

fun <T, R : Any> Field<Iterable<T>>.mapNotNullF(transform: (T) -> Field<R?>): Field<List<R>>
fun <K, V, R : Any> Field<Map<K, V>>.mapNotNullF(transform: (Entry<K, V>) -> Field<R?>): Field<List<R>>

mapNotNullToSet

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

fun <T, R : Any> Field<Iterable<T>>.mapNotNullToSet(transform: (T) -> R?): Field<Set<R>>
fun <K, V, R : Any> Field<Map<K, V>>.mapNotNullToSet(transform: (Entry<K, V>) -> R?): Field<Set<R>>
fun <T, R : Any> Field<Sequence<T>>.mapNotNullToSet(transform: (T) -> R?): Field<Set<R>>
fun <R : Any> Field<String>.mapNotNullToSet(transform: (Char) -> R?): Field<Set<R>>

mapNotNullToSetF

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

fun <T, R : Any> Field<Iterable<T>>.mapNotNullToSetF(transform: (T) -> Field<R?>): Field<Set<R>>
fun <K, V, R : Any> Field<Map<K, V>>.mapNotNullToSetF(transform: (Entry<K, V>) -> Field<R?>): Field<Set<R>>

mapToSet

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

fun <T, R> Field<Iterable<T>>.mapToSet(transform: (T) -> R): Field<Set<R>>
fun <K, V, R> Field<Map<K, V>>.mapToSet(transform: (Entry<K, V>) -> R): Field<Set<R>>
fun <T, R> Field<Sequence<T>>.mapToSet(transform: (T) -> R): Field<Set<R>>
fun <R> Field<String>.mapToSet(transform: (Char) -> R): Field<Set<R>>

mapToSetF

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

fun <T, R> Field<Iterable<T>>.mapToSetF(transform: (T) -> Field<R>): Field<Set<R>>
fun <K, V, R> Field<Map<K, V>>.mapToSetF(transform: (Entry<K, V>) -> Field<R>): Field<Set<R>>

mapValues

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

fun <K, V, R> Field<Map<K, V>>.mapValues(transform: (Entry<K, V>) -> R): Field<Map<K, R>>

mapValuesF

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

fun <K, V, R> Field<Map<K, V>>.mapValuesF(transform: (Entry<K, V>) -> Field<R>): Field<Map<K, R>>

mask

Same as mask, but returns a new Field

fun Field<RegexOption>.mask(): Field<Int>

matchEntire

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

fun Field<Regex>.matchEntire(input: Field<CharSequence>): Field<MatchResult?>
fun Field<Regex>.matchEntire(input: CharSequence): Field<MatchResult?>

matches

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

infix fun Field<Regex>.matches(input: Field<CharSequence>): Field<Boolean>
infix fun Field<Regex>.matches(input: CharSequence): Field<Boolean>

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

infix fun Field<String>.matches(regex: Field<Regex>): Field<Boolean>
infix fun Field<String>.matches(regex: Regex): Field<Boolean>

maxBy

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

fun <T, R : Comparable<R>> Field<Iterable<T>>.maxBy(selector: (T) -> R): Field<T?>
fun <K, V, R : Comparable<R>> Field<Map<K, V>>.maxBy(selector: (Entry<K, V>) -> R): Field<Entry<K, V>?>

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

fun <T, R : Comparable<R>> Field<Sequence<T>>.maxBy(selector: (T) -> R): Field<T?>

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

fun <R : Comparable<R>> Field<String>.maxBy(selector: (Char) -> R): Field<Char?>

maxByF

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

fun <T, R : Comparable<R>> Field<Iterable<T>>.maxByF(selector: (T) -> Field<R>): Field<T?>
fun <K, V, R : Comparable<R>> Field<Map<K, V>>.maxByF(selector: (Entry<K, V>) -> Field<R>): Field<Entry<K, V>?>

maxWith

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

fun <T> Field<Iterable<T>>.maxWith(comparator: Comparator<in T>): Field<T?>
fun <K, V> Field<Map<K, V>>.maxWith(comparator: Comparator<in Entry<K, V>>): Field<Entry<K, V>?>

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

fun <T> Field<Sequence<T>>.maxWith(comparator: Comparator<in T>): Field<T?>

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

fun Field<String>.maxWith(comparator: Comparator<in Char>): Field<Char?>

minBy

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

fun <T, R : Comparable<R>> Field<Iterable<T>>.minBy(selector: (T) -> R): Field<T?>
fun <K, V, R : Comparable<R>> Field<Map<K, V>>.minBy(selector: (Entry<K, V>) -> R): Field<Entry<K, V>?>

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

fun <T, R : Comparable<R>> Field<Sequence<T>>.minBy(selector: (T) -> R): Field<T?>

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

fun <R : Comparable<R>> Field<String>.minBy(selector: (Char) -> R): Field<Char?>

minByF

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

fun <T, R : Comparable<R>> Field<Iterable<T>>.minByF(selector: (T) -> Field<R>): Field<T?>
fun <K, V, R : Comparable<R>> Field<Map<K, V>>.minByF(selector: (Entry<K, V>) -> Field<R>): Field<Entry<K, V>?>

minus

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

operator fun Field<BigDecimal>.minus(other: Field<BigDecimal>): Field<BigDecimal>
operator fun Field<BigDecimal>.minus(other: BigDecimal): Field<BigDecimal>
operator fun Field<BigInteger>.minus(other: Field<BigInteger>): Field<BigInteger>
operator fun Field<BigInteger>.minus(other: BigInteger): Field<BigInteger>

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

operator fun Field<Char>.minus(other: Field<Char>): Field<Int>
operator fun Field<Char>.minus(other: Char): Field<Int>

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

operator fun <T> Field<Iterable<T>>.minus(elements: Field<Array<out T>>): Field<List<T>>
operator fun <T> Field<Iterable<T>>.minus(element: Field<T>): Field<List<T>>
operator fun <T> Field<Iterable