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

AttributeWrapper

interface AttributeWrapper<T> : Attribute<T>

This special implementation of Attribute works similarly to a FieldWrapper, but for attributes.

Basically we can either mirror another Attribute or set a custom AttributeData value.

To create an AttributeWrapper you can use attributeWrapperOf or AttributeWrapper.of

Properties

value

The current attribute value.

abstract var value: AttributeData<T>

Functions

setAttribute

Sets the current state to mirror the one in the given attribute

abstract fun setAttribute(attribute: Attribute<T>): Unit

setError

Sets the current state to be Error with the given parameters

open fun setError(displayableMessage: String? = null, displayableDescription: String? = null, retry: (() -> Unit)? = null): Unit

setLoadedValue

Sets the current state to be Loaded with the given value

open fun setLoadedValue(value: T): Unit

Atomically sets the current state to be Loaded, computing the contained value with the given valueComputer

open fun setLoadedValue(valueComputer: (AttributeData<T>) -> T): Unit

Sets the current state to be Loaded with the value mirroring the one contained in value

abstract fun setLoadedValue(value: Field<T>): Unit

setLoading

Sets the current state to be Loading

open fun setLoading(): Unit

setValue

Atomically sets the current state, computing it with valueComputer

abstract fun setValue(valueComputer: (AttributeData<T>) -> AttributeData<T>): Unit

Companion Object Functions

of

Returns an AttributeWrapper initially containing the Loading state

fun <T> of(): AttributeWrapper<T>

Returns an AttributeWrapper initially containing the Loaded state with value loadedValue

fun <T> of(loadedValue: T): AttributeWrapper<T>

Returns an AttributeWrapper initially containing the given value state

fun <T> of(value: AttributeData<T>): AttributeWrapper<T>

Returns an AttributeWrapper initially containing the Loaded state with value mirroring the given loadedValue field

fun <T> of(loadedValue: Field<T>): AttributeWrapper<T>

Returns an AttributeWrapper initially mirroring the state of the given value attribute

fun <T> of(value: Attribute<T>): AttributeWrapper<T>

ofNull

Returns an AttributeWrapper initially containing the Loaded state with value null

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

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(