Documentation / dataflow-async / com.femastudios.dataflow.async / TimeShiftedAttribute
Go to reference

TimeShiftedAttribute

interface TimeShiftedAttribute<out T> : Attribute<T>

This interface represents a Attribute whose value is the value of another Attribute in a previous point in time.

Examples of time shifting are debouncing and delaying

See Also

Attribute.debounced

Attribute.delayed

Functions

synchronize

Sets the value of this Attribute to the latest available value.

abstract fun synchronize(): Unit

Extension Functions

abs

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

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

add

Same as add, but accepts Attribute and returns a new Attribute.

fun Attribute<BigDecimal>.add(augend: Attribute<BigDecimal>, mc: Attribute<MathContext>): Attribute<BigDecimal>
fun Attribute<BigDecimal>.add(augend: Attribute<BigDecimal>, mc: MathContext): Attribute<BigDecimal>
fun Attribute<BigDecimal>.add(augend: BigDecimal, mc: Attribute<MathContext>): Attribute<BigDecimal>
fun Attribute<BigDecimal>.add(augend: BigDecimal, mc: MathContext): Attribute<BigDecimal>

aggregate

Same as aggregate, but accepts Attribute and returns a new Attribute.

fun <T, K, R> Attribute<Grouping<T, K>>.aggregate(operation: (key: K, accumulator: R?, element: T, first: Boolean) -> R): Attribute<Map<K, R>>

all

Same as all, but accepts Attribute and returns a new Attribute.

fun <T> Attribute<Iterable<T>>.all(predicate: (T) -> Boolean): Attribute<Boolean>
fun <K, V> Attribute<Map<K, V>>.all(predicate: (Entry<K, V>) -> Boolean): Attribute<Boolean>

Same as all, but accepts Attribute and returns a new Attribute.

fun <T> Attribute<Sequence<T>>.all(predicate: (T) -> Boolean): Attribute<Boolean>

Same as all, but accepts Attribute and returns a new Attribute.

fun Attribute<String>.all(predicate: (Char) -> Boolean): Attribute<Boolean>

allA

Same as all, but accepts Attribute and returns a new Attribute.

fun <T> Attribute<Iterable<T>>.allA(predicate: (T) -> Attribute<Boolean>): Attribute<Boolean>
fun <K, V> Attribute<Map<K, V>>.allA(predicate: (Entry<K, V>) -> Attribute<Boolean>): Attribute<Boolean>

and

Same as and, but accepts Attribute and returns a new Attribute.

infix fun Attribute<BigInteger>.and(other: Attribute<BigInteger>): Attribute<BigInteger>
infix fun Attribute<BigInteger>.and(other: BigInteger): Attribute<BigInteger>

Same as and, but accepts Attribute and returns a new Attribute.

infix fun Attribute<Boolean>.and(other: Attribute<Boolean>): Attribute<Boolean>
infix fun Attribute<Boolean>.and(other: Boolean): Attribute<Boolean>

Same as and, but accepts Attribute and returns a new Attribute.

infix fun Attribute<Int>.and(other: Attribute<Int>): Attribute<Int>
infix fun Attribute<Int>.and(other: Int): Attribute<Int>

Same as and, but accepts Attribute and returns a new Attribute.

infix fun Attribute<Long>.and(other: Attribute<Long>): Attribute<Long>
infix fun Attribute<Long>.and(other: Long): Attribute<Long>

andNot

Same as andNot, but accepts Attribute and returns a new Attribute.

fun Attribute<BigInteger>.andNot(val: Attribute<BigInteger>): Attribute<BigInteger>
fun Attribute<BigInteger>.andNot(val: BigInteger): Attribute<BigInteger>

any

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

fun <T> Attribute<Iterable<T>>.any(predicate: (T) -> Boolean): Attribute<Boolean>
fun <K, V> Attribute<Map<K, V>>.any(predicate: (Entry<K, V>) -> Boolean): Attribute<Boolean>

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

fun <T> Attribute<Sequence<T>>.any(predicate: (T) -> Boolean): Attribute<Boolean>

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

fun Attribute<String>.any(predicate: (Char) -> Boolean): Attribute<Boolean>

anyA

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

fun <T> Attribute<Iterable<T>>.anyA(predicate: (T) -> Attribute<Boolean>): Attribute<Boolean>
fun <K, V> Attribute<Map<K, V>>.anyA(predicate: (Entry<K, V>) -> Attribute<Boolean>): Attribute<Boolean>

asReversed

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

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

associate

Same as associate, but accepts Attribute and returns a new Attribute.

fun <T, K, V> Attribute<Iterable<T>>.associate(transform: (T) -> Pair<K, V>): Attribute<Map<K, V>>

Same as associate, but accepts Attribute and returns a new Attribute.

fun <T, K, V> Attribute<Sequence<T>>.associate(transform: (T) -> Pair<K, V>): Attribute<Map<K, V>>

Same as associate, but accepts Attribute and returns a new Attribute.

fun <K, V> Attribute<String>.associate(transform: (Char) -> Pair<K, V>): Attribute<Map<K, V>>

associateA

Same as associate, but accepts Attribute and returns a new Attribute.

fun <T, K, V> Attribute<Iterable<T>>.associateA(transform: (T) -> Attribute<Pair<K, V>>): Attribute<Map<K, V>>

associateBy

Same as associateBy, but accepts Attribute and returns a new Attribute.

fun <T, K, V> Attribute<Iterable<T>>.associateBy(keySelector: (T) -> K, valueTransform: (T) -> V): Attribute<Map<K, V>>
fun <T, K> Attribute<Iterable<T>>.associateBy(keySelector: (T) -> K): Attribute<Map<K, T>>

Same as associateBy, but accepts Attribute and returns a new Attribute.

fun <T, K, V> Attribute<Sequence<T>>.associateBy(keySelector: (T) -> K, valueTransform: (T) -> V): Attribute<Map<K, V>>
fun <T, K> Attribute<Sequence<T>>.associateBy(keySelector: (T) -> K): Attribute<Map<K, T>>

Same as associateBy, but accepts Attribute and returns a new Attribute.

fun <K, V> Attribute<String>.associateBy(keySelector: (Char) -> K, valueTransform: (Char) -> V): Attribute<Map<K, V>>
fun <K> Attribute<String>.associateBy(keySelector: (Char) -> K): Attribute<Map<K, Char>>

associateByA

Same as associateBy, but accepts Attribute and returns a new Attribute.

fun <T, K, V> Attribute<Iterable<T>>.associateByA(keySelector: (T) -> Attribute<K>, valueTransform: (T) -> Attribute<V>): Attribute<Map<K, V>>
fun <T, K> Attribute<Iterable<T>>.associateByA(keySelector: (T) -> Attribute<K>): Attribute<Map<K, T>>

associateWith

Same as associateWith, but accepts Attribute and returns a new Attribute.

fun <K, V> Attribute<Iterable<K>>.associateWith(valueSelector: (K) -> V): Attribute<Map<K, V>>

Same as associateWith, but accepts Attribute and returns a new Attribute.

fun <K, V> Attribute<Sequence<K>>.associateWith(valueSelector: (K) -> V): Attribute<Map<K, V>>

Same as associateWith, but accepts Attribute and returns a new Attribute.

fun <V> Attribute<String>.associateWith(valueSelector: (Char) -> V): Attribute<Map<Char, V>>

associateWithA

Same as associateWith, but accepts Attribute and returns a new Attribute.

fun <K, V> Attribute<Iterable<K>>.associateWithA(valueSelector: (K) -> Attribute<V>): Attribute<Map<K, V>>

bitCount

Same as bitCount, but accepts Attribute and returns a new Attribute.

fun Attribute<BigInteger>.bitCount(): Attribute<Int>

bitLength

Same as bitLength, but accepts Attribute and returns a new Attribute.

fun Attribute<BigInteger>.bitLength(): Attribute<Int>

category

Same as category, but returns a new Attribute

fun Attribute<Char>.category(): Attribute<CharCategory>

chunked

Same as chunked, but accepts Attribute and returns a new Attribute.

fun <T, R> Attribute<Iterable<T>>.chunked(size: Attribute<Int>, transform: (List<T>) -> R): Attribute<List<R>>
fun <T, R> Attribute<Iterable<T>>.chunked(size: Int, transform: (List<T>) -> R): Attribute<List<R>>

Same as chunked, but accepts Attribute and returns a new Attribute.

fun <T, R> Attribute<Sequence<T>>.chunked(size: Attribute<Int>, transform: (List<T>) -> R): Attribute<Sequence<R>>
fun <T, R> Attribute<Sequence<T>>.chunked(size: Int, transform: (List<T>) -> R): Attribute<Sequence<R>>

Same as chunked, but accepts Attribute and returns a new Attribute.

fun <R> Attribute<String>.chunked(size: Attribute<Int>, transform: (CharSequence) -> R): Attribute<List<R>>
fun <R> Attribute<String>.chunked(size: Int, transform: (CharSequence) -> R): Attribute<List<R>>

chunkedSequence

Same as chunkedSequence, but accepts Attribute and returns a new Attribute.

fun <R> Attribute<String>.chunkedSequence(size: Attribute<Int>, transform: (CharSequence) -> R): Attribute<Sequence<R>>
fun <R> Attribute<String>.chunkedSequence(size: Int, transform: (CharSequence) -> R): Attribute<Sequence<R>>
fun Attribute<String>.chunkedSequence(size: Attribute<Int>): Attribute<Sequence<String>>
fun Attribute<String>.chunkedSequence(size: Int): Attribute<Sequence<String>>

clearBit

Same as clearBit, but accepts Attribute and returns a new Attribute.

fun Attribute<BigInteger>.clearBit(n: Attribute<Int>): Attribute<BigInteger>
fun Attribute<BigInteger>.clearBit(n: Int): Attribute<BigInteger>

code

Same as code, but returns a new Attribute

fun Attribute<CharCategory>.code(): Attribute<String>

codePointAt

Same as codePointAt, but accepts Attribute and returns a new Attribute.

fun Attribute<String>.codePointAt(index: Attribute<Int>): Attribute<Int>
fun Attribute<String>.codePointAt(index: Int): Attribute<Int>

codePointBefore

Same as codePointBefore, but accepts Attribute and returns a new Attribute.

fun Attribute<String>.codePointBefore(index: Attribute<Int>): Attribute<Int>
fun Attribute<String>.codePointBefore(index: Int): Attribute<Int>

codePointCount

Same as codePointCount, but accepts Attribute and returns a new Attribute.

fun Attribute<String>.codePointCount(beginIndex: Attribute<Int>, endIndex: Attribute<Int>): Attribute<Int>
fun Attribute<String>.codePointCount(beginIndex: Attribute<Int>, endIndex: Int): Attribute<Int>
fun Attribute<String>.codePointCount(beginIndex: Int, endIndex: Attribute<Int>): Attribute<Int>
fun Attribute<String>.codePointCount(beginIndex: Int, endIndex: Int): Attribute<Int>

coerceAtLeast

Same as coerceAtLeast, but accepts Attribute and returns a new Attribute.

fun Attribute<Byte>.coerceAtLeast(minimumValue: Attribute<Byte>): Attribute<Byte>
fun Attribute<Byte>.coerceAtLeast(minimumValue: Byte): Attribute<Byte>
fun Attribute<Double>.coerceAtLeast(minimumValue: Attribute<Double>): Attribute<Double>
fun Attribute<Double>.coerceAtLeast(minimumValue: Double): Attribute<Double>
fun Attribute<Float>.coerceAtLeast(minimumValue: Attribute<Float>): Attribute<Float>
fun Attribute<Float>.coerceAtLeast(minimumValue: Float): Attribute<Float>
fun Attribute<Int>.coerceAtLeast(minimumValue: Attribute<Int>): Attribute<Int>
fun Attribute<Int>.coerceAtLeast(minimumValue: Int): Attribute<Int>
fun Attribute<Long>.coerceAtLeast(minimumValue: Attribute<Long>): Attribute<Long>
fun Attribute<Long>.coerceAtLeast(minimumValue: Long): Attribute<Long>
fun Attribute<Short>.coerceAtLeast(minimumValue: Attribute<Short>): Attribute<Short>
fun Attribute<Short>.coerceAtLeast(minimumValue: Short): Attribute<Short>

coerceAtMost

Same as coerceAtMost, but accepts Attribute and returns a new Attribute.

fun Attribute<Byte>.coerceAtMost(maximumValue: Attribute<Byte>): Attribute<Byte>
fun Attribute<Byte>.coerceAtMost(maximumValue: Byte): Attribute<Byte>
fun Attribute<Double>.coerceAtMost(maximumValue: Attribute<Double>): Attribute<Double>
fun Attribute<Double>.coerceAtMost(maximumValue: Double): Attribute<Double>
fun Attribute<Float>.coerceAtMost(maximumValue: Attribute<Float>): Attribute<Float>
fun Attribute<Float>.coerceAtMost(maximumValue: Float): Attribute<Float>
fun Attribute<Int>.coerceAtMost(maximumValue: Attribute<Int>): Attribute<Int>
fun Attribute<Int>.coerceAtMost(maximumValue: Int): Attribute<Int>
fun Attribute<Long>.coerceAtMost(maximumValue: Attribute<Long>): Attribute<Long>
fun Attribute<Long>.coerceAtMost(maximumValue: Long): Attribute<Long>
fun Attribute<Short>.coerceAtMost(maximumValue: Attribute<Short>): Attribute<Short>
fun Attribute<Short>.coerceAtMost(maximumValue: Short): Attribute<Short>

coerceIn

Same as coerceIn, but accepts Attribute and returns a new Attribute.

fun Attribute<Byte>.coerceIn(minimumValue: Attribute<Byte>, maximumValue: Attribute<Byte>): Attribute<Byte>
fun Attribute<Byte>.coerceIn(minimumValue: Attribute<Byte>, maximumValue: Byte): Attribute<Byte>
fun Attribute<Byte>.coerceIn(minimumValue: Byte, maximumValue: Attribute<Byte>): Attribute<Byte>
fun Attribute<Byte>.coerceIn(minimumValue: Byte, maximumValue: Byte): Attribute<Byte>
fun Attribute<Double>.coerceIn(minimumValue: Attribute<Double>, maximumValue: Attribute<Double>): Attribute<Double>
fun Attribute<Double>.coerceIn(minimumValue: Attribute<Double>, maximumValue: Double): Attribute<Double>
fun Attribute<Double>.coerceIn(minimumValue: Double, maximumValue: Attribute<Double>): Attribute<Double>
fun Attribute<Double>.coerceIn(minimumValue: Double, maximumValue: Double): Attribute<Double>
fun Attribute<Float>.coerceIn(minimumValue: Attribute<Float>, maximumValue: Attribute<Float>): Attribute<Float>
fun Attribute<Float>.coerceIn(minimumValue: Attribute<Float>, maximumValue: Float): Attribute<Float>
fun Attribute<Float>.coerceIn(minimumValue: Float, maximumValue: Attribute<Float>): Attribute<Float>
fun Attribute<Float>.coerceIn(minimumValue: Float, maximumValue: Float): Attribute<Float>
fun Attribute<Int>.coerceIn(minimumValue: Attribute<Int>, maximumValue: Attribute<Int>): Attribute<Int>
fun Attribute<Int>.coerceIn(minimumValue: Attribute<Int>, maximumValue: Int): Attribute<Int>
fun Attribute<Int>.coerceIn(minimumValue: Int, maximumValue: Attribute<Int>): Attribute<Int>
fun Attribute<Int>.coerceIn(minimumValue: Int, maximumValue: Int): Attribute<Int>
fun Attribute<Int>.coerceIn(range: Attribute<ClosedRange<Int>>): Attribute<Int>
fun Attribute<Int>.coerceIn(range: ClosedRange<Int>): Attribute<Int>
fun Attribute<Long>.coerceIn(minimumValue: Attribute<Long>, maximumValue: Attribute<Long>): Attribute<Long>
fun Attribute<Long>.coerceIn(minimumValue: Attribute<Long>, maximumValue: Long): Attribute<Long>
fun Attribute<Long>.coerceIn(minimumValue: Long, maximumValue: Attribute<Long>): Attribute<Long>
fun Attribute<Long>.coerceIn(minimumValue: Long, maximumValue: Long): Attribute<Long>
fun Attribute<Long>.coerceIn(range: Attribute<ClosedRange<Long>>): Attribute<Long>
fun Attribute<Long>.coerceIn(range: ClosedRange<Long>): Attribute<Long>
fun Attribute<Short>.coerceIn(minimumValue: Attribute<Short>, maximumValue: Attribute<Short>): Attribute<Short>
fun Attribute<Short>.coerceIn(minimumValue: Attribute<Short>, maximumValue: Short): Attribute<Short>
fun Attribute<Short>.coerceIn(minimumValue: Short, maximumValue: Attribute<Short>): Attribute<Short>
fun Attribute<Short>.coerceIn(minimumValue: Short, maximumValue: Short): Attribute<Short>

commonPrefixWith

Same as commonPrefixWith, but accepts Attribute and returns a new Attribute.

fun Attribute<String>.commonPrefixWith(other: Attribute<String>, ignoreCase: Attribute<Boolean> = com.femastudios.dataflow.async.util.attributeOf(false)): Attribute<String>
fun Attribute<String>.commonPrefixWith(other: String, ignoreCase: Boolean = false): Attribute<String>
fun Attribute<String>.commonPrefixWith(other: Attribute<String>, ignoreCase: Boolean = false): Attribute<String>
fun Attribute<String>.commonPrefixWith(other: String, ignoreCase: Attribute<Boolean>): Attribute<String>

commonSuffixWith

Same as commonSuffixWith, but accepts Attribute and returns a new Attribute.

fun Attribute<String>.commonSuffixWith(other: Attribute<String>, ignoreCase: Attribute<Boolean> = com.femastudios.dataflow.async.util.attributeOf(false)): Attribute<String>
fun Attribute<String>.commonSuffixWith(other: String, ignoreCase: Boolean = false): Attribute<String>
fun Attribute<String>.commonSuffixWith(other: Attribute<String>, ignoreCase: Boolean = false): Attribute<String>
fun Attribute<String>.commonSuffixWith(other: String, ignoreCase: Attribute<Boolean>): Attribute<String>

compareTo

Same as compareTo, but accepts Attribute and returns a new Attribute.

fun <T> Attribute<Comparable<T>>.compareTo(other: T): Attribute<Int>
fun <T> Attribute<Comparable<T>>.compareTo(other: Attribute<T>): Attribute<Int>

component3

Same as component3, but accepts Attribute and returns a new Attribute.

operator fun <T> Attribute<List<T>>.component3(): Attribute<T>

component4

Same as component4, but accepts Attribute and returns a new Attribute.

operator fun <T> Attribute<List<T>>.component4(): Attribute<T>

component5

Same as component5, but accepts Attribute and returns a new Attribute.

operator fun <T> Attribute<List<T>>.component5(): Attribute<T>

contains

Same as contains, but accepts Attribute and returns a new Attribute.

fun Attribute<CharCategory>.contains(char: Attribute<Char>): Attribute<Boolean>
fun Attribute<CharCategory>.contains(char: Char): Attribute<Boolean>

Same as contains, but accepts Attribute and returns a new Attribute.

fun <T : Comparable<T>> Attribute<ClosedFloatingPointRange<in T>>.contains(value: T): Attribute<Boolean>
fun <T : Comparable<T>> Attribute<ClosedFloatingPointRange<in T>>.contains(value: Attribute<T>): Attribute<Boolean>

Same as contains, but accepts Attribute and returns a new Attribute.

fun <T : Comparable<T>> Attribute<ClosedRange<in T>>.contains(value: T): Attribute<Boolean>
fun <T : Comparable<T>> Attribute<ClosedRange<in T>>.contains(value: Attribute<T>): Attribute<Boolean>

Same as contains, but accepts Attribute and returns a new Attribute.

fun <E> Attribute<Collection<E>>.contains(element: E): Attribute<Boolean>
fun <E> Attribute<Collection<E>>.contains(element: Attribute<E>): Attribute<Boolean>

Same as contains, but accepts Attribute and returns a new Attribute.

fun <T> Attribute<Iterable<T>>.contains(element: T): Attribute<Boolean>
fun <T> Attribute<Iterable<T>>.contains(element: Attribute<T>): Attribute<Boolean>
fun <K, V> Attribute<Map<K, V>>.contains(key: K): Attribute<Boolean>
fun <K, V> Attribute<Map<K, V>>.contains(key: Attribute<K>): Attribute<Boolean>

Same as contains, but accepts Attribute and returns a new Attribute.

fun <T> Attribute<Sequence<T>>.contains(element: T): Attribute<Boolean>
fun <T> Attribute<Sequence<T>>.contains(element: Attribute<T>): Attribute<Boolean>

Same as contains, but accepts Attribute and returns a new Attribute.

fun <E> Attribute<Set<E>>.contains(element: E): Attribute<Boolean>
fun <E> Attribute<Set<E>>.contains(element: Attribute<E>): Attribute<Boolean>

Same as contains, but accepts Attribute and returns a new Attribute.

fun Attribute<String>.contains(other: Attribute<String>, ignoreCase: Attribute<Boolean> = com.femastudios.dataflow.async.util.attributeOf(false)): Attribute<Boolean>
fun Attribute<String>.contains(other: String, ignoreCase: Boolean = false): Attribute<Boolean>
fun Attribute<String>.contains(char: Attribute<Char>, ignoreCase: Attribute<Boolean> = com.femastudios.dataflow.async.util.attributeOf(false)): Attribute<Boolean>
fun Attribute<String>.contains(char: Char, ignoreCase: Boolean = false): Attribute<Boolean>
fun Attribute<String>.contains(other: Attribute<String>, ignoreCase: Boolean = false): Attribute<Boolean>
fun Attribute<String>.contains(other: String, ignoreCase: Attribute<Boolean>): Attribute<Boolean>
fun Attribute<String>.contains(char: Attribute<Char>, ignoreCase: Boolean = false): Attribute<Boolean>
fun Attribute<String>.contains(char: Char, ignoreCase: Attribute<Boolean>): Attribute<Boolean>
fun Attribute<String>.contains(regex: Attribute<Regex>): Attribute<Boolean>
fun Attribute<String>.contains(regex: Regex): Attribute<Boolean>

containsAll

Same as containsAll, but accepts Attribute and returns a new Attribute.

fun <E> Attribute<Collection<E>>.containsAll(elements: Attribute<Collection<E>>): Attribute<Boolean>
fun <E> Attribute<Collection<E>>.containsAll(elements: Collection<E>): Attribute<Boolean>

Same as containsAll, but accepts Attribute and returns a new Attribute.

fun <E> Attribute<Set<E>>.containsAll(elements: Attribute<Collection<E>>): Attribute<Boolean>
fun <E> Attribute<Set<E>>.containsAll(elements: Collection<E>): Attribute<Boolean>

containsKey

Same as containsKey, but accepts Attribute and returns a new Attribute.

fun <K> Attribute<Map<in K, *>>.containsKey(key: K): Attribute<Boolean>
fun <K> Attribute<Map<in K, *>>.containsKey(key: Attribute<K>): Attribute<Boolean>

containsMatchIn

Same as containsMatchIn, but accepts Attribute and returns a new Attribute.

fun Attribute<Regex>.containsMatchIn(input: Attribute<CharSequence>): Attribute<Boolean>
fun Attribute<Regex>.containsMatchIn(input: CharSequence): Attribute<Boolean>

containsValue

Same as containsValue, but accepts Attribute and returns a new Attribute.

fun <V> Attribute<Map<*, V>>.containsValue(value: V): Attribute<Boolean>
fun <V> Attribute<Map<*, V>>.containsValue(value: Attribute<V>): Attribute<Boolean>

contentEquals

Same as contentEquals, but accepts Attribute and returns a new Attribute.

fun Attribute<String>.contentEquals(stringBuilder: Attribute<StringBuffer>): Attribute<Boolean>
fun Attribute<String>.contentEquals(charSequence: Attribute<String>): Attribute<Boolean>
fun Attribute<String>.contentEquals(charSequence: String): Attribute<Boolean>
fun Attribute<String>.contentEquals(stringBuilder: StringBuffer): Attribute<Boolean>

count

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

fun <T> Attribute<Iterable<T>>.count(predicate: (T) -> Boolean): Attribute<Int>
fun <K, V> Attribute<Map<K, V>>.count(predicate: (Entry<K, V>) -> Boolean): Attribute<Int>

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

fun <T> Attribute<Sequence<T>>.count(predicate: (T) -> Boolean): Attribute<Int>

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

fun Attribute<String>.count(predicate: (Char) -> Boolean): Attribute<Int>

countA

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

fun <T> Attribute<Iterable<T>>.countA(predicate: (T) -> Attribute<Boolean>): Attribute<Int>
fun <K, V> Attribute<Map<K, V>>.countA(predicate: (Entry<K, V>) -> Attribute<Boolean>): Attribute<Int>

currentValueOr

Returns the current value of this Attribute if it is loaded, or valueWhenNotLoaded

fun <T> Attribute<T>.currentValueOr(valueWhenNotLoaded: T): T

Returns the current value of this Attribute if it is loaded, or what valueWhenNotLoaded returns

fun <T> Attribute<T>.currentValueOr(valueWhenNotLoaded: (NotLoaded<T>) -> T): T

destructured

Same as destructured, but returns a new Attribute

fun Attribute<MatchResult>.destructured(): Attribute<Destructured>

directionality

Same as directionality, but returns a new Attribute

fun Attribute<Char>.directionality(): Attribute<CharDirectionality>

distinctBy

Same as distinctBy, but accepts Attribute and returns a new Attribute.

fun <T, K> Attribute<Iterable<T>>.distinctBy(selector: (T) -> K): Attribute<List<T>>

Same as distinctBy, but accepts Attribute and returns a new Attribute.

fun <T, K> Attribute<Sequence<T>>.distinctBy(selector: (T) -> K): Attribute<Sequence<T>>

distinctByA

Same as distinctBy, but accepts Attribute and returns a new Attribute.

fun <T, K> Attribute<Iterable<T>>.distinctByA(selector: (T) -> Attribute<K>): Attribute<List<T>>

div

Same as div, but accepts Attribute and returns a new Attribute.

operator fun Attribute<BigDecimal>.div(other: Attribute<BigDecimal>): Attribute<BigDecimal>
operator fun Attribute<BigDecimal>.div(other: BigDecimal): Attribute<BigDecimal>
operator fun Attribute<BigInteger>.div(other: Attribute<BigInteger>): Attribute<BigInteger>
operator fun Attribute<BigInteger>.div(other: BigInteger): Attribute<BigInteger>

divide

Same as divide, but accepts Attribute and returns a new Attribute.

fun Attribute<BigDecimal>.divide(divisor: Attribute<BigDecimal>, roundingMode: Attribute<RoundingMode>): Attribute<BigDecimal>
fun Attribute<BigDecimal>.divide(divisor: Attribute<BigDecimal>, roundingMode: RoundingMode): Attribute<BigDecimal>
fun Attribute<BigDecimal>.divide(divisor: Attribute<BigDecimal>, scale: Attribute<Int>, roundingMode: Attribute<RoundingMode>): Attribute<BigDecimal>
fun Attribute<BigDecimal>.divide(divisor: BigDecimal, roundingMode: Attribute<RoundingMode>): Attribute<BigDecimal>
fun Attribute<BigDecimal>.divide(divisor: BigDecimal, roundingMode: RoundingMode): Attribute<BigDecimal>
fun Attribute<BigDecimal>.divide(divisor: BigDecimal, scale: Int, roundingMode: RoundingMode): Attribute<BigDecimal>
fun Attribute<BigDecimal>.divide(divisor: Attribute<BigDecimal>, mc: Attribute<MathContext>): Attribute<BigDecimal>
fun Attribute<BigDecimal>.divide(divisor: Attribute<BigDecimal>, mc: MathContext): Attribute<BigDecimal>
fun Attribute<BigDecimal>.divide(divisor: BigDecimal, mc: Attribute<MathContext>): Attribute<BigDecimal>
fun Attribute<BigDecimal>.divide(divisor: BigDecimal, mc: MathContext): Attribute<BigDecimal>

divideToIntegralValue

Same as divideToIntegralValue, but accepts Attribute and returns a new Attribute.

fun Attribute<BigDecimal>.divideToIntegralValue(divisor: Attribute<BigDecimal>): Attribute<BigDecimal>
fun Attribute<BigDecimal>.divideToIntegralValue(divisor: Attribute<BigDecimal>, mc: Attribute<MathContext>): Attribute<BigDecimal>
fun Attribute<BigDecimal>.divideToIntegralValue(divisor: Attribute<BigDecimal>, mc: MathContext): Attribute<BigDecimal>
fun Attribute<BigDecimal>.divideToIntegralValue(divisor: BigDecimal): Attribute<BigDecimal>
fun Attribute<BigDecimal>.divideToIntegralValue(divisor: BigDecimal, mc: Attribute<MathContext>): Attribute<BigDecimal>
fun Attribute<BigDecimal>.divideToIntegralValue(divisor: BigDecimal, mc: MathContext): Attribute<BigDecimal>

downTo

Same as downTo, but accepts Attribute and returns a new Attribute.

infix fun Attribute<Char>.downTo(to: Attribute<Char>): Attribute<CharProgression>
infix fun Attribute<Char>.downTo(to: Char): Attribute<CharProgression>

dropLastWhile

Same as dropLastWhile, but accepts Attribute and returns a new Attribute.

fun <T> Attribute<List<T>>.dropLastWhile(predicate: (T) -> Boolean): Attribute<List<T>>

Same as dropLastWhile, but accepts Attribute and returns a new Attribute.

fun Attribute<String>.dropLastWhile(predicate: (Char) -> Boolean): Attribute<String>

dropLastWhileA

Same as dropLastWhile, but accepts Attribute and returns a new Attribute.

fun <T> Attribute<List<T>>.dropLastWhileA(predicate: (T) -> Attribute<Boolean>): Attribute<List<T>>

dropWhile

Same as dropWhile, but accepts Attribute and returns a new Attribute.

fun <T> Attribute<Iterable<T>>.dropWhile(predicate: (T) -> Boolean): Attribute<List<T>>

Same as dropWhile, but accepts Attribute and returns a new Attribute.

fun <T> Attribute<Sequence<T>>.dropWhile(predicate: (T) -> Boolean): Attribute<Sequence<T>>

Same as dropWhile, but accepts Attribute and returns a new Attribute.

fun Attribute<String>.dropWhile(predicate: (Char) -> Boolean): Attribute<String>

dropWhileA

Same as dropWhile, but accepts Attribute and returns a new Attribute.

fun <T> Attribute<Iterable<T>>.dropWhileA(predicate: (T) -> Attribute<Boolean>): Attribute<List<T>>

elementAtOrElse

Same as elementAtOrElse, but accepts Attribute and returns a new Attribute.

fun <T> Attribute<Iterable<T>>.elementAtOrElse(index: Attribute<Int>, defaultValue: (Int) -> T): Attribute<T>
fun <T> Attribute<Iterable<T>>.elementAtOrElse(index: Int, defaultValue: (Int) -> T): Attribute<T>
fun <T> Attribute<List<T>>.elementAtOrElse(index: Attribute<Int>, defaultValue: (Int) -> T): Attribute<T>
fun <T> Attribute<List<T>>.elementAtOrElse(index: Int, defaultValue: (Int) -> T): Attribute<T>

Same as elementAtOrElse, but accepts Attribute and returns a new Attribute.

fun <T> Attribute<Sequence<T>>.elementAtOrElse(index: Attribute<Int>, defaultValue: (Int) -> T): Attribute<T>
fun <T> Attribute<Sequence<T>>.elementAtOrElse(index: Int, defaultValue: (Int) -> T): Attribute<T>

Same as elementAtOrElse, but accepts Attribute and returns a new Attribute.

fun Attribute<String>.elementAtOrElse(index: Attribute<Int>, defaultValue: (Int) -> Char): Attribute<Char>
fun Attribute<String>.elementAtOrElse(index: Int, defaultValue: (Int) -> Char): Attribute<Char>

endInclusive

Same as endInclusive, but returns a new Attribute

fun <T : Comparable<T>> Attribute<ClosedRange<out T>>.endInclusive(): Attribute<T>

endsWith

Same as endsWith, but accepts Attribute and returns a new Attribute.

fun Attribute<String>.endsWith(char: Attribute<Char>, ignoreCase: Attribute<Boolean> = com.femastudios.dataflow.async.util.attributeOf(false)): Attribute<Boolean>
fun Attribute<String>.endsWith(char: Char, ignoreCase: Boolean = false): Attribute<Boolean>
fun Attribute<String>.endsWith(suffix: Attribute<String>, ignoreCase: Attribute<Boolean> = com.femastudios.dataflow.async.util.attributeOf(false)): Attribute<Boolean>
fun Attribute<String>.endsWith(suffix: String, ignoreCase: Boolean = false): Attribute<Boolean>
fun Attribute<String>.endsWith(char: Attribute<Char>, ignoreCase: Boolean = false): Attribute<Boolean>
fun Attribute<String>.endsWith(char: Char, ignoreCase: Attribute<Boolean>): Attribute<Boolean>
fun Attribute<String>.endsWith(suffix: Attribute<String>, ignoreCase: Boolean = false): Attribute<Boolean>
fun Attribute<String>.endsWith(suffix: String, ignoreCase: Attribute<Boolean>): Attribute<Boolean>

entries

Same as entries, but returns a new Attribute

fun <K, V> Attribute<Map<out K, V>>.entries(): Attribute<Set<Entry<K, V>>>

eq

Returns a Attribute whose value is true if the two values are equal

infix fun <T> Attribute<T>.eq(another: Attribute<T>): Attribute<Boolean>
infix fun <T> Attribute<T>.eq(another: T): Attribute<Boolean>

filter

Same as filter, but accepts Attribute and returns a new Attribute.

fun <T> Attribute<Iterable<T>>.filter(predicate: (T) -> Boolean): Attribute<List<T>>
fun <K, V> Attribute<Map<K, V>>.filter(predicate: (Entry<K, V>) -> Boolean): Attribute<Map<K, V>>

Same as filter, but accepts Attribute and returns a new Attribute.

fun <T> Attribute<Sequence<T>>.filter(predicate: (T) -> Boolean): Attribute<Sequence<T>>

Same as filter, but accepts Attribute and returns a new Attribute.

fun Attribute<String>.filter(predicate: (Char) -> Boolean): Attribute<String>

filterA

Same as filter, but accepts Attribute and returns a new Attribute.

fun <T> Attribute<Iterable<T>>.filterA(predicate: (T) -> Attribute<Boolean>): Attribute<List<T>>
fun <K, V> Attribute<Map<K, V>>.filterA(predicate: (Entry<K, V>) -> Attribute<Boolean>): Attribute<Map<K, V>>

filterIndexed

Same as filterIndexed, but accepts Attribute and returns a new Attribute.

fun <T> Attribute<Iterable<T>>.filterIndexed(predicate: (index: Int, T) -> Boolean): Attribute<List<T>>

Same as filterIndexed, but accepts Attribute and returns a new Attribute.

fun <T> Attribute<Sequence<T>>.filterIndexed(predicate: (index: Int, T) -> Boolean): Attribute<Sequence<T>>

Same as filterIndexed, but accepts Attribute and returns a new Attribute.

fun Attribute<String>.filterIndexed(predicate: (index: Int, Char) -> Boolean): Attribute<String>

filterIndexedToSet

Same as filterIndexedToSet, but accepts Attribute and returns a new Attribute.

fun <T> Attribute<Iterable<T>>.filterIndexedToSet(predicate: (index: Int, T) -> Boolean): Attribute<Set<T>>
fun <T> Attribute<Sequence<T>>.filterIndexedToSet(predicate: (index: Int, T) -> Boolean): Attribute<Set<T>>

filterIsInstance

Same as filterIsInstance, but accepts Attribute and returns a new Attribute.

fun <R> Attribute<Iterable<*>>.filterIsInstance(klass: Attribute<Class<R>>): Attribute<List<R>>
fun <R> Attribute<Iterable<*>>.filterIsInstance(klass: Class<R>): Attribute<List<R>>

Same as filterIsInstance, but accepts Attribute and returns a new Attribute.

fun <R> Attribute<Sequence<*>>.filterIsInstance(klass: Attribute<Class<R>>): Attribute<Sequence<R>>
fun <R> Attribute<Sequence<*>>.filterIsInstance(klass: Class<R>): Attribute<Sequence<R>>

filterIsInstanceToSet

Same as filterIsInstanceToSet, but accepts Attribute and returns a new Attribute.

fun <R> Attribute<Iterable<*>>.filterIsInstanceToSet(klass: Attribute<Class<R>>): Attribute<Set<R>>
fun <R> Attribute<Iterable<*>>.filterIsInstanceToSet(klass: Class<R>): Attribute<Set<R>>
fun <R> Attribute<Sequence<*>>.filterIsInstanceToSet(klass: Attribute<Class<R>>): Attribute<Set<R>>
fun <R> Attribute<Sequence<*>>.filterIsInstanceToSet(klass: Class<R>): Attribute<Set<R>>

filterKeys

Same as filterKeys, but accepts Attribute and returns a new Attribute.

fun <K, V> Attribute<Map<K, V>>.filterKeys(predicate: (K) -> Boolean): Attribute<Map<K, V>>

filterKeysA

Same as filterKeys, but accepts Attribute and returns a new Attribute.

fun <K, V> Attribute<Map<K, V>>.filterKeysA(predicate: (K) -> Attribute<Boolean>): Attribute<Map<K, V>>

filterNot

Same as filterNot, but accepts Attribute and returns a new Attribute.

fun <T> Attribute<Iterable<T>>.filterNot(predicate: (T) -> Boolean): Attribute<List<T>>
fun <K, V> Attribute<Map<K, V>>.filterNot(predicate: (Entry<K, V>) -> Boolean): Attribute<Map<K, V>>

Same as filterNot, but accepts Attribute and returns a new Attribute.

fun <T> Attribute<Sequence<T>>.filterNot(predicate: (T) -> Boolean): Attribute<Sequence<T>>

Same as filterNot, but accepts Attribute and returns a new Attribute.

fun Attribute<String>.filterNot(predicate: (Char) -> Boolean): Attribute<String>

filterNotA

Same as filterNot, but accepts Attribute and returns a new Attribute.

fun <T> Attribute<Iterable<T>>.filterNotA(predicate: (T) -> Attribute<Boolean>): Attribute<List<T>>
fun <K, V> Attribute<Map<K, V>>.filterNotA(predicate: (Entry<K, V>) -> Attribute<Boolean>): Attribute<Map<K, V>>

filterNotToSet

Same as filterNotToSet, but accepts Attribute and returns a new Attribute.

fun <T> Attribute<Iterable<T>>.filterNotToSet(predicate: (T) -> Boolean): Attribute<Set<T>>
fun <T> Attribute<Sequence<T>>.filterNotToSet(predicate: (T) -> Boolean): Attribute<Set<T>>

filterNotToSetA

Same as filterNotToSet, but accepts Attribute and returns a new Attribute.

fun <T> Attribute<Iterable<T>>.filterNotToSetA(predicate: (T) -> Attribute<Boolean>): Attribute<Set<T>>

filterToSet

Same as filterToSet, but accepts Attribute and returns a new Attribute.

fun <T> Attribute<Iterable<T>>.filterToSet(predicate: (T) -> Boolean): Attribute<Set<T>>
fun <T> Attribute<Sequence<T>>.filterToSet(predicate: (T) -> Boolean): Attribute<Set<T>>

filterToSetA

Same as filterToSet, but accepts Attribute and returns a new Attribute.

fun <T> Attribute<Iterable<T>>.filterToSetA(predicate: (T) -> Attribute<Boolean>): Attribute<Set<T>>

filterValues

Same as filterValues, but accepts Attribute and returns a new Attribute.

fun <K, V> Attribute<Map<K, V>>.filterValues(predicate: (V) -> Boolean): Attribute<Map<K, V>>

filterValuesA

Same as filterValues, but accepts Attribute and returns a new Attribute.

fun <K, V> Attribute<Map<K, V>>.filterValuesA(predicate: (V) -> Attribute<Boolean>): Attribute<Map<K, V>>

find

Same as find, but accepts Attribute and returns a new Attribute.

fun <T> Attribute<Iterable<T>>.find(predicate: (T) -> Boolean): Attribute<T?>

Same as find, but accepts Attribute and returns a new Attribute.

fun Attribute<Regex>.find(input: Attribute<CharSequence>, startIndex: Attribute<Int> = com.femastudios.dataflow.async.util.attributeOf(0)): Attribute<MatchResult?>
fun Attribute<Regex>.find(input: CharSequence, startIndex: Int = 0): Attribute<MatchResult?>
fun Attribute<Regex>.find(input: Attribute<CharSequence>, startIndex: Int = 0): Attribute<MatchResult?>
fun Attribute<Regex>.find(input: CharSequence, startIndex: Attribute<Int>): Attribute<MatchResult?>

Same as find, but accepts Attribute and returns a new Attribute.

fun <T> Attribute<Sequence<T>>.find(predicate: (T) -> Boolean): Attribute<T?>

Same as find, but accepts Attribute and returns a new Attribute.

fun Attribute<String>.find(predicate: (Char) -> Boolean): Attribute<Char?>

findA

Same as find, but accepts Attribute and returns a new Attribute.

fun <T> Attribute<Iterable<T>>.findA(predicate: (T) -> Attribute<Boolean>): Attribute<T?>

findAll

Same as findAll, but accepts Attribute and returns a new Attribute.

fun Attribute<Regex>.findAll(input: Attribute<CharSequence>, startIndex: Attribute<Int> = com.femastudios.dataflow.async.util.attributeOf(0)): Attribute<Sequence<MatchResult>>
fun Attribute<Regex>.findAll(input: CharSequence, startIndex: Int = 0): Attribute<Sequence<MatchResult>>
fun Attribute<Regex>.findAll(input: Attribute<CharSequence>, startIndex: Int = 0): Attribute<Sequence<MatchResult>>
fun Attribute<Regex>.findAll(input: CharSequence, startIndex: Attribute<Int>): Attribute<Sequence<MatchResult>>

findAnyOf

Same as findAnyOf, but accepts Attribute and returns a new Attribute.

fun Attribute<String>.findAnyOf(strings: Attribute<Collection<String>>, startIndex: Attribute<Int> = com.femastudios.dataflow.async.util.attributeOf(0), ignoreCase: Attribute<Boolean> = com.femastudios.dataflow.async.util.attributeOf(false)): Attribute<Pair<Int, String>?>
fun Attribute<String>.findAnyOf(strings: Collection<String>, startIndex: Int = 0, ignoreCase: Boolean = false): Attribute<Pair<Int, String>?>

findLast

Same as findLast, but accepts Attribute and returns a new Attribute.

fun <T> Attribute<Iterable<T>>.findLast(predicate: (T) -> Boolean): Attribute<T?>
fun <T> Attribute<List<T>>.findLast(predicate: (T) -> Boolean): Attribute<T?>

Same as findLast, but accepts Attribute and returns a new Attribute.

fun <T> Attribute<Sequence<T>>.findLast(predicate: (T) -> Boolean): Attribute<T?>

Same as findLast, but accepts Attribute and returns a new Attribute.

fun Attribute<String>.findLast(predicate: (Char) -> Boolean): Attribute<Char?>

findLastA

Same as findLast, but accepts Attribute and returns a new Attribute.

fun <T> Attribute<Iterable<T>>.findLastA(predicate: (T) -> Attribute<Boolean>): Attribute<T?>
fun <T> Attribute<List<T>>.findLastA(predicate: (T) -> Attribute<Boolean>): Attribute<T?>

findLastAnyOf

Same as findLastAnyOf, but accepts Attribute and returns a new Attribute.

fun Attribute<String>.findLastAnyOf(strings: Attribute<Collection<String>>, startIndex: Attribute<Int> = com.femastudios.dataflow.async.util.attributeOf(0), ignoreCase: Attribute<Boolean> = com.femastudios.dataflow.async.util.attributeOf(false)): Attribute<Pair<Int, String>?>
fun Attribute<String>.findLastAnyOf(strings: Collection<String>, startIndex: Int = 0, ignoreCase: Boolean = false): Attribute<Pair<Int, String>?>

first

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

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

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

fun <T> Attribute<Sequence<T>>.first(predicate: (T) -> Boolean): Attribute<T>

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

fun Attribute<String>.first(predicate: (Char) -> Boolean): Attribute<Char>

firstA

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

fun <T> Attribute<Iterable<T>>.firstA(predicate: (T) -> Attribute<Boolean>): Attribute<T>

firstOrNull

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

fun <T> Attribute<Iterable<T>>.firstOrNull(predicate: (T) -> Boolean): Attribute<T?>

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

fun <T> Attribute<Sequence<T>>.firstOrNull(predicate: (T) -> Boolean): Attribute<T?>

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

fun Attribute<String>.firstOrNull(predicate: (Char) -> Boolean): Attribute<Char?>

firstOrNullA

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

fun <T> Attribute<Iterable<T>>.firstOrNullA(predicate: (T) -> Attribute<Boolean>): Attribute<T?>

flatMap

Same as flatMap, but accepts Attribute and returns a new Attribute.

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

Same as flatMap, but accepts Attribute and returns a new Attribute.

fun <T, R> Attribute<Sequence<T>>.flatMap(transform: (T) -> Sequence<R>): Attribute<Sequence<R>>

Same as flatMap, but accepts Attribute and returns a new Attribute.

fun <R> Attribute<String>.flatMap(transform: (Char) -> Iterable<R>): Attribute<List<R>>

flatMapA

Same as flatMap, but accepts Attribute and returns a new Attribute.

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

flatMapToSet

Same as flatMapToSet, but accepts Attribute and returns a new Attribute.

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

flatMapToSetA

Same as flatMapToSet, but accepts Attribute and returns a new Attribute.

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

flipBit

Same as flipBit, but accepts Attribute and returns a new Attribute.

fun Attribute<BigInteger>.flipBit(n: Attribute<Int>): Attribute<BigInteger>
fun Attribute<BigInteger>.flipBit(n: Int): Attribute<BigInteger>

fold

Same as fold, but accepts Attribute and returns a new Attribute.

fun <T, K, R> Attribute<Grouping<T, K>>.fold(initialValue: R, operation: (accumulator: R, element: T) -> R): Attribute<Map<K, R>>
fun <T, K, R> Attribute<Grouping<T, K>>.fold(initialValue: Attribute<R>, operation: (accumulator: R, element: T) -> R): Attribute<Map<K, R>>
fun <T, K, R> Attribute<Grouping<T, K>>.fold(initialValueSelector: (key: K, element: T) -> R, operation: (key: K, accumulator: R, element: T) -> R): Attribute<Map<K, R>>
fun <T, R> Attribute<Iterable<T>>.fold(initial: R, operation: (acc: R, T) -> R): Attribute<R>
fun <T, R> Attribute<Iterable<T>>.fold(initial: Attribute<R>, operation: (acc: R, T) -> R): Attribute<R>

Same as fold, but accepts Attribute and returns a new Attribute.

fun <T, R> Attribute<Sequence<T>>.fold(initial: R, operation: (acc: R, T) -> R): Attribute<R>
fun <T, R> Attribute<Sequence<T>>.fold(initial: Attribute<R>, operation: (acc: R, T) -> R): Attribute<R>

Same as fold, but accepts Attribute and returns a new Attribute.

fun <R> Attribute<String>.fold(initial: R, operation: (acc: R, Char) -> R): Attribute<R>
fun <R> Attribute<String>.fold(initial: Attribute<R>, operation: (acc: R, Char) -> R): Attribute<R>

foldIndexed

Same as foldIndexed, but accepts Attribute and returns a new Attribute.

fun <T, R> Attribute<Iterable<T>>.foldIndexed(initial: R, operation: (index: Int, acc: R, T) -> R): Attribute<R>
fun <T, R> Attribute<Iterable<T>>.foldIndexed(initial: Attribute<R>, operation: (index: Int, acc: R, T) -> R): Attribute<R>

Same as foldIndexed, but accepts Attribute and returns a new Attribute.

fun <T, R> Attribute<Sequence<T>>.foldIndexed(initial: R, operation: (index: Int, acc: R, T) -> R): Attribute<R>
fun <T, R> Attribute<Sequence<T>>.foldIndexed(initial: Attribute<R>, operation: (index: Int, acc: R, T) -> R): Attribute<R>

Same as foldIndexed, but accepts Attribute and returns a new Attribute.

fun <R> Attribute<String>.foldIndexed(initial: R, operation: (index: Int, acc: R, Char) -> R): Attribute<R>
fun <R> Attribute<String>.foldIndexed(initial: Attribute<R>, operation: (index: Int, acc: R, Char) -> R): Attribute<R>

foldRight

Same as foldRight, but accepts Attribute and returns a new Attribute.

fun <T, R> Attribute<List<T>>.foldRight(initial: R, operation: (T, acc: R) -> R): Attribute<R>
fun <T, R> Attribute<List<T>>.foldRight(initial: Attribute<R>, operation: (T, acc: R) -> R): Attribute<R>

Same as foldRight, but accepts Attribute and returns a new Attribute.

fun <R> Attribute<String>.foldRight(initial: R, operation: (Char, acc: R) -> R): Attribute<R>
fun <R> Attribute<String>.foldRight(initial: Attribute<R>, operation: (Char, acc: R) -> R): Attribute<R>

foldRightIndexed

Same as foldRightIndexed, but accepts Attribute and returns a new Attribute.

fun <T, R> Attribute<List<T>>.foldRightIndexed(initial: R, operation: (index: Int, T, acc: R) -> R): Attribute<R>
fun <T, R> Attribute<List<T>>.foldRightIndexed(initial: Attribute<R>, operation: (index: Int, T, acc: R) -> R): Attribute<R>

Same as foldRightIndexed, but accepts Attribute and returns a new Attribute.

fun <R> Attribute<String>.foldRightIndexed(initial: R, operation: (index: Int, Char, acc: R) -> R): Attribute<R>
fun <R> Attribute<String>.foldRightIndexed(initial: Attribute<R>, operation: (index: Int, Char, acc: R) -> R): Attribute<R>

format

Same as format, but accepts Attribute and returns a new Attribute.

fun Attribute<String>.format(locale: Attribute<Locale>, vararg args: Attribute<Any?>): Attribute<String>
fun Attribute<String>.format(locale: Attribute<Locale>, vararg args: Any?): Attribute<String>
fun Attribute<String>.format(locale: Locale, vararg args: Attribute<Any?>): Attribute<String>
fun Attribute<String>.format(locale: Locale, vararg args: Any?): Attribute<String>
fun Attribute<String>.format(vararg args: Attribute<Any?>): Attribute<String>
fun Attribute<String>.format(vararg args: Any?): Attribute<String>

gcd

Same as gcd, but accepts Attribute and returns a new Attribute.

fun Attribute<BigInteger>.gcd(val: Attribute<BigInteger>): Attribute<BigInteger>
fun Attribute<BigInteger>.gcd(val: BigInteger): Attribute<BigInteger>

get

Same as get, but accepts Attribute and returns a new Attribute.

operator fun <K, V> Attribute<Map<in K, V>>.get(key: K): Attribute<V?>
operator fun <K, V> Attribute<Map<in K, V>>.get(key: Attribute<K>): Attribute<V?>

Same as get, but accepts Attribute and returns a new Attribute.

operator fun Attribute<MatchNamedGroupCollection>.get(name: Attribute<String>): Attribute<MatchGroup?>
operator fun Attribute<MatchNamedGroupCollection>.get(name: String): Attribute<MatchGroup?>

getLowestSetBit

Same as getLowestSetBit, but accepts Attribute and returns a new Attribute.

fun Attribute<BigInteger>.getLowestSetBit(): Attribute<Int>

getOrDefault

Same as getOrDefault, but accepts Attribute and returns a new Attribute.

fun <K, V> Attribute<Map<in K, V>>.getOrDefault(key: K, defaultValue: V): Attribute<V>
fun <K, V> Attribute<Map<in K, V>>.getOrDefault(key: K, defaultValue: Attribute<V>): Attribute<V>
fun <K, V> Attribute<Map<in K, V>>.getOrDefault(key: Attribute<K>, defaultValue: V): Attribute<V>
fun <K, V> Attribute<Map<in K, V>>.getOrDefault(key: Attribute<K>, defaultValue: Attribute<V>): Attribute<V>

getOrElse

Same as getOrElse, but accepts Attribute and returns a new Attribute.

fun <T> Attribute<List<T>>.getOrElse(index: Attribute<Int>, defaultValue: (Int) -> T): Attribute<T>
fun <T> Attribute<List<T>>.getOrElse(index: Int, defaultValue: (Int) -> T): Attribute<T>
fun <K, V> Attribute<Map<K, V>>.getOrElse(key: K, defaultValue: () -> V): Attribute<V>
fun <K, V> Attribute<Map<K, V>>.getOrElse(key: Attribute<K>, defaultValue: () -> V): Attribute<V>

Same as getOrElse, but accepts Attribute and returns a new Attribute.

fun Attribute<String>.getOrElse(index: Attribute<Int>, defaultValue: (Int) -> Char): Attribute<Char>
fun Attribute<String>.getOrElse(index: Int, defaultValue: (Int) -> Char): Attribute<Char>

getOrElseA

Same as getOrElse, but accepts Attribute and returns a new Attribute.

fun <K, V> Attribute<Map<K, V>>.getOrElseA(key: Attribute<K>, defaultValue: (key: K) -> Attribute<V>): Attribute<V>
fun <K, V> Attribute<Map<K, V>>.getOrElseA(key: K, defaultValue: () -> Attribute<V>): Attribute<V>

getPrecision

Same as getPrecision, but accepts Attribute and returns a new Attribute.

fun Attribute<MathContext>.getPrecision(): Attribute<Int>

getRoundingMode

Same as getRoundingMode, but accepts Attribute and returns a new Attribute.

fun Attribute<MathContext>.getRoundingMode(): Attribute<RoundingMode>

getValue

Same as getValue, but accepts Attribute and returns a new Attribute.

fun <K, V> Attribute<Map<K, V>>.getValue(key: K): Attribute<V>
fun <K, V> Attribute<Map<K, V>>.getValue(key: Attribute<K>): Attribute<V>

groupBy

Same as groupBy, but accepts Attribute and returns a new Attribute.

fun <T, K, V> Attribute<Iterable<T>>.groupBy(keySelector: (T) -> K, valueTransform: (T) -> V): Attribute<Map<K, List<V>>>
fun <T, K> Attribute<Iterable<T>>.groupBy(keySelector: (T) -> K): Attribute<Map<K, List<T>>>

Same as groupBy, but accepts Attribute and returns a new Attribute.

fun <T, K, V> Attribute<Sequence<T>>.groupBy(keySelector: (T) -> K, valueTransform: (T) -> V): Attribute<Map<K, List<V>>>
fun <T, K> Attribute<Sequence<T>>.groupBy(keySelector: (T) -> K): Attribute<Map<K, List<T>>>

Same as groupBy, but accepts Attribute and returns a new Attribute.

fun <K, V> Attribute<String>.groupBy(keySelector: (Char) -> K, valueTransform: (Char) -> V): Attribute<Map<K, List<V>>>
fun <K> Attribute<String>.groupBy(keySelector: (Char) -> K): Attribute<Map<K, List<Char>>>

groupByA

Same as groupBy, but accepts Attribute and returns a new Attribute.

fun <T, K, V> Attribute<Iterable<T>>.groupByA(keySelector: (T) -> Attribute<K>, valueTransform: (T) -> Attribute<V>): Attribute<Map<K, List<V>>>
fun <T, K> Attribute<Iterable<T>>.groupByA(keySelector: (T) -> Attribute<K>): Attribute<Map<K, List<T>>>

groupingBy

Same as groupingBy, but accepts Attribute and returns a new Attribute.

fun <T, K> Attribute<Iterable<T>>.groupingBy(keySelector: (T) -> K): Attribute<Grouping<T, K>>

Same as groupingBy, but accepts Attribute and returns a new Attribute.

fun <T, K> Attribute<Sequence<T>>.groupingBy(keySelector: (T) -> K): Attribute<Grouping<T, K>>

Same as groupingBy, but accepts Attribute and returns a new Attribute.

fun <K> Attribute<String>.groupingBy(keySelector: (Char) -> K): Attribute<Grouping<Char, K>>

groupingByA

Same as groupingBy, but accepts Attribute and returns a new Attribute.

fun <T, K> Attribute<Iterable<T>>.groupingByA(keySelector: (T) -> Attribute<K>): Attribute<Grouping<T, K>>

groups

Same as groups, but returns a new Attribute

fun Attribute<MatchResult>.groups(): Attribute<MatchGroupCollection>

groupValues

Same as groupValues, but returns a new Attribute

fun Attribute<MatchResult>.groupValues(): Attribute<List<String>>

hasSurrogatePairAt

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

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

IEEErem

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

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

ifEmpty

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

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

index

Same as index, but returns a new Attribute

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

indexOf

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

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

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

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

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

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

indexOfAny

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

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

indexOfFirst

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

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

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

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

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

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

indexOfFirstA

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

fun <T> Attribute<Iterable<T>>.indexOfFirstA(predicate: (T) -> Attribute<Boolean>): Attribute<Int>
fun <T> Attribute<List<T>>.indexOfFirstA(predicate: (T) -> Attribute<Boolean>): Attribute<Int>

indexOfLast

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

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

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

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

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

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

indexOfLastA

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

fun <T> Attribute<Iterable<T>>.indexOfLastA(predicate: (T) -> Attribute<Boolean>): Attribute<Int>
fun <T> Attribute<List<T>>.indexOfLastA(predicate: (T) -> Attribute<Boolean>): Attribute<Int>

interpolate

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

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

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

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

intersect

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

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

isBlank

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

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

isDefined

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

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

isDigit

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

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

isHighSurrogate

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

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

isIdentifierIgnorable

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

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

isISOControl

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

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

isJavaIdentifierPart

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

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

isJavaIdentifierStart

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

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

isLetter

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

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

isLetterOrDigit

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

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

isLowerCase

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

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

isLowSurrogate

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

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

isNotBlank

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

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

isNotNull

Returns a new Attribute whose value is true if and only if the value of this Attribute is not null.

fun Attribute<Any?>.isNotNull(): RecomputableAttribute<Boolean>

isNull

Returns a new Attribute whose value is true if and only if the value of this Attribute is null.

fun Attribute<Any?>.isNull(): RecomputableAttribute<Boolean>

isNullOrBlank

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

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

isProbablePrime

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

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

isSurrogate

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

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

isTitleCase

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

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

isUpperCase

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

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

isWhitespace

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

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

joinToString

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

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

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

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

joinToStringA

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

fun <T> Attribute<Iterable<T>>.joinToStringA(separator: Attribute<CharSequence>, prefix: Attribute<CharSequence> = com.femastudios.dataflow.async.util.attributeOf(""), postfix: Attribute<CharSequence> = com.femastudios.dataflow.async.util.attributeOf(""), limit: Attribute<Int> = com.femastudios.dataflow.async.util.attributeOf(-1), truncated: Attribute<CharSequence> = com.femastudios.dataflow.async.util.attributeOf("..."), transform: (T) -> Attribute<CharSequence>): Attribute<String>
fun <T> Attribute<Iterable<T>>.joinToStringA(separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: (T) -> Attribute<CharSequence>): Attribute<String>

key

Same as key, but returns a new Attribute

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

keyOf

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

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

keys

Same as keys, but returns a new Attribute

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

last

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

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

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

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

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

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

lastA

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

fun <T> Attribute<Iterable<T>>.lastA(predicate: (T) -> Attribute<Boolean>): Attribute<T>
fun <T> Attribute<List<T>>.lastA(predicate: (T) -> Attribute<Boolean>): Attribute<T>

lastIndexOf

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

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

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

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

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

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

lastIndexOfAny

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

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

lastOrNull

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

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

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

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

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

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

lastOrNullA

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

fun <T> Attribute<Iterable<T>>.lastOrNullA(predicate: (T) -> Attribute<Boolean>): Attribute<T?>
fun <T> Attribute<List<T>>.lastOrNullA(predicate: (T) -> Attribute<Boolean>): Attribute<T?>

length

Same as length, but returns a new Attribute

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

lessThanOrEquals

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

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

lines

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

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

lineSequence

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

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

map

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

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

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

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

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

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

mapA

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

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

mapIndexed

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

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

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

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

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

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

mapIndexedNotNull

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

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

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

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

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

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

mapIndexedNotNullToSet

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

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

mapIndexedToSet

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

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

mapKeys

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

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

mapKeysA

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

fun <K, V, R> Attribute<Map<K, V>>.mapKeysA(transform: (Entry<K, V>) -> Attribute<R>): Attribute<Map<R, V>>

mapNotNull

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

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

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

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

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

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

mapNotNullA

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

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

mapNotNullToSet

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

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

mapNotNullToSetA

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

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

mapToSet

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

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

mapToSetA

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

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

mapValues

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

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

mapValuesA

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

fun <K, V, R> Attribute<Map<K, V>>.mapValuesA(transform: (Entry<K, V>) -> Attribute<R>): Attribute<Map<K, R>>

mask

Same as mask, but returns a new Attribute

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

matchEntire

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

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

matches

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

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

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

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

maxBy

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

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

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

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

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

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

maxByA

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

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

maxWith

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

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

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

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

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

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

minBy

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

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

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

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

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

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

minByA

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

fun <T, R : Comparable<R>> Attribute<Iterable<T>>.minByA(