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

MutableField

interface MutableField<T> : Field<T>

This interface extends Field, but allows to change the value.

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

Properties

value

The current value of this Field. You can register callbacks for data changes using the ListenersManager exposed through listeners.

abstract var value: T

Functions

pair

Merges two MutableField in a single MutableField<Pair>.

open infix fun <O> pair(another: MutableField<O>): MutableField<Pair<T, O>>

setValue

Allows to atomically change the value using the given valueComputer.

abstract fun setValue(valueComputer: (oldValue: T) -> T): Unit

twoWayTransform

Returns a new Field<O>, whose value is transformToOther applied to the value of this Field.

open fun <O> twoWayTransform(transformToOther: (T) -> O, transformToMe: (O) -> T): MutableField<O>

As twoWayTransform, but with a single transformation function.

open fun twoWayTransform(transform: (T) -> T): MutableField<T>

Companion Object Functions

of

Constructs a new MutableField with the given initial value.

fun <T> of(value: T): MutableField<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

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

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>

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

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

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>

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