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

Attribute

interface Attribute<out T>

An Attribute is an object that holds either Loaded value (of type T), a Loading state, or an Error state. These states are all represented by a the sealed class AttributeData.

An attribute can be seen as a Field of AttributeData using the provided function asField. This field can be used to register callbacks. To access the current value the value property can be used.

The value of an attribute is read-only and cannot be directly changed. There is no mutable equivalent. If you need to set custom states you can use an AttributeWrapper.

Attributes are async by default, so all operation are automatically executed in a background thread pool.

To crate an Attribute you can use attributeOf or Attribute.of.

When creating or transforming attributes the lambdas we pass all have a WorkContext receiver, that is used to set the state to something other than Loaded.

For an introduction on how to use attributes you can also consult the online doc

See Also

AttributeData

Properties

value

The current attribute value.

abstract val value: AttributeData<T>

Functions

asField

Returns a Field that represents the attribute value.

abstract fun asField(): Field<AttributeData<T>>

currentValueOrNull

Returns the current value (of type T) if the attribute state is Loaded, null otherwise.

open fun currentValueOrNull(): T?

debounced

Returns a TimeShiftedAttribute whose value is debounced at with the specified delay (in milliseconds). When the original value changes, a countdown of delay milliseconds starts: if another change happens during this countdown the countdown is reset at delay milliseconds. When the countdown finishes the latest change is propagated to the new attribute.

open fun debounced(delay: Long, maxDelay: Long?): TimeShiftedAttribute<T>

Same as Attribute.debounced but with a null max delay.

open fun debounced(delay: Long): TimeShiftedAttribute<T>

Same as Attribute.debounced but the delay is a lambda called each time the attribute changes.

open fun debounced(delay: (debouncedValue: AttributeData<T>, newValue: AttributeData<T>) -> Long): TimeShiftedAttribute<T>
open fun debounced(delay: (debouncedValue: AttributeData<T>, newValue: AttributeData<T>) -> Long, maxDelay: Long?): TimeShiftedAttribute<T>

delayed

Returns a TimeShiftedAttribute whose value is shifted of the given delay milliseconds.

open fun delayed(delay: Long): TimeShiftedAttribute<T>

Same as Attribute.delayed but the delay is a lambda called each time the attribute changes.

open fun delayed(delay: (delayedValue: AttributeData<T>, newValue: AttributeData<T>) -> Long): TimeShiftedAttribute<T>

hashCodeA

Returns an Attribute<String> that represents the hashCode() value of the current value

open fun hashCodeA(): Attribute<Int>

isError

Returns a Field<Boolean> that is true when the state of this attribute is Error

open fun isError(): Field<Boolean>

isLoaded

Returns a Field<Boolean> that is true when the state of this attribute is Loaded

open fun isLoaded(): Field<Boolean>

isLoading

Returns a Field<Boolean> that is true when the state of this attribute is Loading

open fun isLoading(): Field<Boolean>

isNotLoaded

Returns a Field<Boolean> that is true when the state of this attribute is Loading or Error

open fun isNotLoaded(): Field<Boolean>

pair

Returns an Attribute<Pair<T, O>> whose first value of the pair is the value of this attribute, and second value of the pair is the value of another. When one of the attributes is in Error the resulting attribute will be in Error, when one of the attributes is in Loading the resulting attribute will be in Loading, when they are both Loaded the resulting attribute will have the specified pair.

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

then

Like Attribute.transform but the transform function can return an Attribute<O>

open fun <O> then(flowStrategy: FlowStrategy, transform: WorkContext.(T) -> Attribute<O>): RecomputableAttribute<O>

Like Attribute.transform but the transform function can return an Attribute<O> and with the default flow strategy FlowStrategy.EVENTUALLY_CONSISTENT

open fun <O> then(transform: WorkContext.(T) -> Attribute<O>): RecomputableAttribute<O>

thenF

Like Attribute.transform but the transform function can return a Field<O>

open fun <O> thenF(transform: WorkContext.(T) -> Field<O>): RecomputableAttribute<O>

toStringA

Returns an Attribute<String> that represents the toString() value of the current value

open fun toStringA(): Attribute<String>

transform

Returns a new Attribute<O> whose Loaded value is transformed applying the given transform function. If the current state is Loaded or Error, it will be reflected on the transformed attribute.

open fun <O> transform(transform: WorkContext.(T) -> O): RecomputableAttribute<O>
open fun <O> transform(flowStrategy: FlowStrategy, transform: WorkContext.(T) -> O): RecomputableAttribute<O>

transformSync

Like Attribute.transform but used the flow strategy FlowStrategy.SYNCHRONOUS.

open fun <O> transformSync(transform: WorkContext.(T) -> O): RecomputableAttribute<O>

transformWithPrevious

Like Attribute.transform, but the transform function also accepts the previous transformed value.

open fun <O> transformWithPrevious(transform: WorkContext.(previous: O?, T) -> O): Attribute<O>
open fun <O> transformWithPrevious(transform: WorkContext.(previous: O?, T) -> O, flowStrategy: FlowStrategy = TRANSFORM_DEFAULT_FLOW_STRATEGY, allowLaziness: Boolean): Attribute<O>

valueOrNull

Returns a Field of type T that contains the current value if the attribute state is Loaded, null otherwise.

open fun valueOrNull(): Field<T?>

waitWhileLoading

Blocks the caller thread indefinitely until this attribute has a Loading status, then returns the current status, which can be either Error or Loaded

open fun waitWhileLoading(): AttributeData<T>

Blocks the caller thread until this attribute has a Loading status for a maximum time of maxWaitTime, then returns the current status, which can be either Error or Loaded if the waited time is less than maxWaitTime or Loading if after maxWaitTime milliseconds the attribute is still Loading

open fun waitWhileLoading(maxWaitTime: Long): AttributeData<T>

Companion Object Functions

of

Returns a new Attribute of type T whose state is always Loaded with a value of value

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

Returns a new Attribute of type T whose state is always data

fun <T> of(data: AttributeData<T>): Attribute<T>

Returns a new lazy RecomputableAttribute with the associated task.

fun <T> of(task: WorkContext.() -> T): RecomputableAttribute<T>

Returns a new RecomputableAttribute with the associated task.

fun <T> of(lazy: Boolean, task: WorkContext.() -> T): RecomputableAttribute<T>
fun <T> of(flowStrategy: FlowStrategy, task: WorkContext.() -> T): RecomputableAttribute<T>
fun <T> of(lazy: Boolean = true, flowStrategy: FlowStrategy = FlowStrategy.CONSISTENT, task: WorkContext.() -> T): RecomputableAttribute<T>

ofNull

Returns a new Attribute of type T whose state is always Loaded with a value of null

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

Extension Functions

abs

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

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

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

fun Attribute<BigInteger>.abs(): Attribute<BigInteger>

Same as absoluteValue, but returns a new Attribute

fun Attribute<Double>.abs(): Attribute<Double>
fun Attribute<Float>.abs(): Attribute<Float>
fun Attribute<Int>.abs(): Attribute<Int>
fun Attribute<Long>.abs(): Attribute<Long>

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(): Attribute<Boolean>
fun <T> Attribute<Iterable<T>>.any(predicate: (T) -> Boolean): Attribute<Boolean>
fun <K, V> Attribute<Map<K, V>>.any(): 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(): Attribute<Boolean>
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(): Attribute<Boolean>
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>

asIterable

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

fun <T> Attribute<Iterable<T>>.asIterable(): Attribute<Iterable<T>>
fun <K, V> Attribute<Map<K, V>>.asIterable(): Attribute<Iterable<Entry<K, V>>>

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

fun <T> Attribute<Sequence<T>>.asIterable(): Attribute<Iterable<T>>

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

fun Attribute<String>.asIterable(): Attribute<Iterable<Char>>

asReversed

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

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

asSequence

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

fun <T> Attribute<Iterable<T>>.asSequence(): Attribute<Sequence<T>>
fun <K, V> Attribute<Map<K, V>>.asSequence(): Attribute<Sequence<Entry<K, V>>>

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

fun <T> Attribute<Sequence<T>>.asSequence(): Attribute<Sequence<T>>

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

fun Attribute<String>.asSequence(): Attribute<Sequence<Char>>

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

average

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

fun Attribute<Iterable<Byte>>.average(): Attribute<Double>
fun Attribute<Iterable<out Double>>.average(): Attribute<Double>
fun Attribute<Iterable<Float>>.average(): Attribute<Double>
fun Attribute<Iterable<Int>>.average(): Attribute<Double>
fun Attribute<Iterable<Long>>.average(): Attribute<Double>
fun Attribute<Iterable<Short>>.average(): Attribute<Double>

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

fun Attribute<Sequence<Byte>>.average(): Attribute<Double>
fun Attribute<Sequence<out Double>>.average(): Attribute<Double>
fun Attribute<Sequence<Float>>.average(): Attribute<Double>
fun Attribute<Sequence<Int>>.average(): Attribute<Double>
fun Attribute<Sequence<Long>>.average(): Attribute<Double>
fun Attribute<Sequence<Short>>.average(): Attribute<Double>

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>>
fun <T> Attribute<Iterable<T>>.chunked(size: Attribute<Int>): Attribute<List<List<T>>>
fun <T> Attribute<Iterable<T>>.chunked(size: Int): Attribute<List<List<T>>>

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>>
fun <T> Attribute<Sequence<T>>.chunked(size: Attribute<Int>): Attribute<Sequence<List<T>>>
fun <T> Attribute<Sequence<T>>.chunked(size: Int): Attribute<Sequence<List<T>>>

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>>
fun Attribute<String>.chunked(size: Attribute<Int>): Attribute<List<String>>
fun Attribute<String>.chunked(size: Int): Attribute<List<String>>

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 <T : Comparable<T>> Attribute<T>.coerceAtLeast(minimumValue: T): Attribute<T>
fun <T : Comparable<T>> Attribute<T>.coerceAtLeast(minimumValue: Attribute<T>): Attribute<T>
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 <T : Comparable<T>> Attribute<T>.coerceAtMost(maximumValue: T): Attribute<T>
fun <T : Comparable<T>> Attribute<T>.coerceAtMost(maximumValue: Attribute<T>): Attribute<T>
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 <T : Comparable<T>> Attribute<T>.coerceIn(minimumValue: T?, maximumValue: T?): Attribute<T>
fun <T : Comparable<T>> Attribute<T>.coerceIn(minimumValue: T?, maximumValue: Attribute<T?>?): Attribute<T>
fun <T : Comparable<T>> Attribute<T>.coerceIn(minimumValue: Attribute<T?>?, maximumValue: T?): Attribute<T>
fun <T : Comparable<T>> Attribute<T>.coerceIn(minimumValue: Attribute<T?>?, maximumValue: Attribute<T?>?): Attribute<T>
fun <T : Comparable<T>> Attribute<T>.coerceIn(range: Attribute<ClosedRange<T>>): Attribute<T>
fun <T : Comparable<T>> Attribute<T>.coerceIn(range: ClosedRange<T>): Attribute<T>
fun <T : Comparable<T>> Attribute<T>.coerceIn(range: Attribute<ClosedFloatingPointRange<T>>): Attribute<T>
fun <T : Comparable<T>> Attribute<T>.coerceIn(range: ClosedFloatingPointRange<T>): Attribute<T>
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 Attribute<Byte>.compareTo(other: Attribute<Double>): Attribute<Int>
fun Attribute<Byte>.compareTo(other: Attribute<Float>): Attribute<Int>
fun Attribute<Byte>.compareTo(other: Attribute<Int>): Attribute<Int>
fun Attribute<Byte>.compareTo(other: Attribute<Long>): Attribute<Int>
fun Attribute<Byte>.compareTo(other: Attribute<Short>): Attribute<Int>
fun Attribute<Byte>.compareTo(other: Attribute<Byte>): Attribute<Int>
fun Attribute<Byte>.compareTo(other: Byte): Attribute<Int>
fun Attribute<Byte>.compareTo(other: Double): Attribute<Int>
fun Attribute<Byte>.compareTo(other: Float): Attribute<Int>
fun Attribute<Byte>.compareTo(other: Int): Attribute<Int>
fun Attribute<Byte>.compareTo(other: Long): Attribute<Int>
fun Attribute<Byte>.compareTo(other: Short): Attribute<Int>

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>

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

fun Attribute<Double>.compareTo(other: Attribute<Byte>): Attribute<Int>
fun Attribute<Double>.compareTo(other: Attribute<Float>): Attribute<Int>
fun Attribute<Double>.compareTo(other: Attribute<Int>): Attribute<Int>
fun Attribute<Double>.compareTo(other: Attribute<Long>): Attribute<Int>
fun Attribute<Double>.compareTo(other: Attribute<Short>): Attribute<Int>
fun Attribute<Double>.compareTo(other: Attribute<Double>): Attribute<Int>
fun Attribute<Double>.compareTo(other: Byte): Attribute<Int>
fun Attribute<Double>.compareTo(other: Double): Attribute<Int>
fun Attribute<Double>.compareTo(other: Float): Attribute<Int>
fun Attribute<Double>.compareTo(other: Int): Attribute<Int>
fun Attribute<Double>.compareTo(other: Long): Attribute<Int>
fun Attribute<Double>.compareTo(other: Short): Attribute<Int>

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

fun Attribute<Float>.compareTo(other: Attribute<Byte>): Attribute<Int>
fun Attribute<Float>.compareTo(other: Attribute<Double>): Attribute<Int>
fun Attribute<Float>.compareTo(other: Attribute<Int>): Attribute<Int>
fun Attribute<Float>.compareTo(other: Attribute<Long>): Attribute<Int>
fun Attribute<Float>.compareTo(other: Attribute<Short>): Attribute<Int>
fun Attribute<Float>.compareTo(other: Attribute<Float>): Attribute<Int>
fun Attribute<Float>.compareTo(other: Byte): Attribute<Int>
fun Attribute<Float>.compareTo(other: Double): Attribute<Int>
fun Attribute<Float>.compareTo(other: Float): Attribute<Int>
fun Attribute<Float>.compareTo(other: Int): Attribute<Int>
fun Attribute<Float>.compareTo(other: Long): Attribute<Int>
fun Attribute<Float>.compareTo(other: Short): Attribute<Int>

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

fun Attribute<Int>.compareTo(other: Attribute<Byte>): Attribute<Int>
fun Attribute<Int>.compareTo(other: Attribute<Double>): Attribute<Int>
fun Attribute<Int>.compareTo(other: Attribute<Float>): Attribute<Int>
fun Attribute<Int>.compareTo(other: Attribute<Long>): Attribute<Int>
fun Attribute<Int>.compareTo(other: Attribute<Short>): Attribute<Int>
fun Attribute<Int>.compareTo(other: Attribute<Int>): Attribute<Int>
fun Attribute<Int>.compareTo(other: Byte): Attribute<Int>
fun Attribute<Int>.compareTo(other: Double): Attribute<Int>
fun Attribute<Int>.compareTo(other: Float): Attribute<Int>
fun Attribute<Int>.compareTo(other: Int): Attribute<Int>
fun Attribute<Int>.compareTo(other: Long): Attribute<Int>
fun Attribute<Int>.compareTo(other: Short): Attribute<Int>

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

fun Attribute<Long>.compareTo(other: Attribute<Byte>): Attribute<Int>
fun Attribute<Long>.compareTo(other: Attribute<Double>): Attribute<Int>
fun Attribute<Long>.compareTo(other: Attribute<Float>): Attribute<Int>
fun Attribute<Long>.compareTo(other: Attribute<Int>): Attribute<Int>
fun Attribute<Long>.compareTo(other: Attribute<Short>): Attribute<Int>
fun Attribute<Long>.compareTo(other: Attribute<Long>): Attribute<Int>
fun Attribute<Long>.compareTo(other: Byte): Attribute<Int>
fun Attribute<Long>.compareTo(other: Double): Attribute<Int>
fun Attribute<Long>.compareTo(other: Float): Attribute<Int>
fun Attribute<Long>.compareTo(other: Int): Attribute<Int>
fun Attribute<Long>.compareTo(other: Long): Attribute<Int>
fun Attribute<Long>.compareTo(other: Short): Attribute<Int>

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

fun Attribute<Short>.compareTo(other: Attribute<Byte>): Attribute<Int>
fun Attribute<Short>.compareTo(other: Attribute<Double>): Attribute<Int>
fun Attribute<Short>.compareTo(other: Attribute<Float>): Attribute<Int>
fun Attribute<Short>.compareTo(other: Attribute<Int>): Attribute<Int>
fun Attribute<Short>.compareTo(other: Attribute<Long>): Attribute<Int>
fun Attribute<Short>.compareTo(other: Attribute<Short>): Attribute<Int>
fun Attribute<Short>.compareTo(other: Byte): Attribute<Int>
fun Attribute<Short>.compareTo(other: Double): Attribute<Int>
fun Attribute<Short>.compareTo(other: Float): Attribute<Int>
fun Attribute<Short>.compareTo(other: Int): Attribute<Int>
fun Attribute<Short>.compareTo(other: Long): Attribute<Int>
fun Attribute<Short>.compareTo(other: Short): Attribute<Int>

component1

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

operator fun <T> Attribute<List<T>>.component1(): Attribute<T>
operator fun <K, V> Attribute<Entry<K, V>>.component1(): Attribute<K>

component2

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

operator fun <T> Attribute<List<T>>.component2(): Attribute<T>
operator fun <K, V> Attribute<Entry<K, V>>.component2(): Attribute<V>

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<Collection<T>>.count(): Attribute<Int>
fun <T> Attribute<Iterable<T>>.count(): Attribute<Int>
fun <T> Attribute<Iterable<T>>.count(predicate: (T) -> Boolean): Attribute<Int>
fun <K, V> Attribute<Map<K, V>>.count(): 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(): Attribute<Int>
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(): Attribute<Int>
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

dec

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

operator fun Attribute<BigDecimal>.dec(): Attribute<BigDecimal>
operator fun Attribute<BigInteger>.dec(): Attribute<BigInteger>

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

operator fun Attribute<Byte>.dec(): Attribute<Byte>

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

operator fun Attribute<Char>.dec(): Attribute<Char>

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

operator fun Attribute<Double>.dec(): Attribute<Double>

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

operator fun Attribute<Float>.dec(): Attribute<Float>

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

operator fun Attribute<Int>.dec(): Attribute<Int>

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

operator fun Attribute<Long>.dec(): Attribute<Long>

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

operator fun Attribute<Short>.dec(): Attribute<Short>

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>

distinct

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

fun <T> Attribute<Iterable<T>>.distinct(): Attribute<List<T>>

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

fun <T> Attribute<Sequence<T>>.distinct(): Attribute<Sequence<T>>

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>

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

operator fun Attribute<Byte>.div(other: Attribute<Double>): Attribute<Double>
operator fun Attribute<Byte>.div(other: Attribute<Float>): Attribute<Float>
operator fun Attribute<Byte>.div(other: Attribute<Int>): Attribute<Int>
operator fun Attribute<Byte>.div(other: Attribute<Long>): Attribute<Long>
operator fun Attribute<Byte>.div(other: Attribute<Short>): Attribute<Int>
operator fun Attribute<Byte>.div(other: Attribute<Byte>): Attribute<Int>
operator fun Attribute<Byte>.div(other: Byte): Attribute<Int>
operator fun Attribute<Byte>.div(other: Double): Attribute<Double>
operator fun Attribute<Byte>.div(other: Float): Attribute<Float>
operator fun Attribute<Byte>.div(other: Int): Attribute<Int>
operator fun Attribute<Byte>.div(other: Long): Attribute<Long>
operator fun Attribute<Byte>.div(other: Short): Attribute<Int>

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

operator fun Attribute<Double>.div(other: Attribute<Byte>): Attribute<Double>
operator fun Attribute<Double>.div(other: Attribute<Float>): Attribute<Double>
operator fun Attribute<Double>.div(other: Attribute<Int>): Attribute<Double>
operator fun Attribute<Double>.div(other: Attribute<Long>): Attribute<Double>
operator fun Attribute<Double>.div(other: Attribute<Short>): Attribute<Double>
operator fun Attribute<Double>.div(other: Attribute<Double>): Attribute<Double>
operator fun Attribute<Double>.div(other: Byte): Attribute<Double>
operator fun Attribute<Double>.div(other: Double): Attribute<Double>
operator fun Attribute<Double>.div(other: Float): Attribute<Double>
operator fun Attribute<Double>.div(other: Int): Attribute<Double>
operator fun Attribute<Double>.div(other: Long): Attribute<Double>
operator fun Attribute<Double>.div(other: Short): Attribute<Double>

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

operator fun Attribute<Float>.div(other: Attribute<Byte>): Attribute<Float>
operator fun Attribute<Float>.div(other: Attribute<Double>): Attribute<Double>
operator fun Attribute<Float>.div(other: Attribute<Int>): Attribute<Float>
operator fun Attribute<Float>.div(other: Attribute<Long>): Attribute<Float>
operator fun Attribute<Float>.div(other: Attribute<Short>): Attribute<Float>
operator fun Attribute<Float>.div(other: Attribute<Float>): Attribute<Float>
operator fun Attribute<Float>.div(other: Byte): Attribute<Float>
operator fun Attribute<Float>.div(other: Double): Attribute<Double>
operator fun Attribute<Float>.div(other: Float): Attribute<Float>
operator fun Attribute<Float>.div(other: Int): Attribute<Float>
operator fun Attribute<Float>.div(other: Long): Attribute<Float>
operator fun Attribute<Float>.div(other: Short): Attribute<Float>

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

operator fun Attribute<Int>.div(other: Attribute<Byte>): Attribute<Int>
operator fun Attribute<Int>.div(other: Attribute<Double>): Attribute<Double>
operator fun Attribute<Int>.div(other: Attribute<Float>): Attribute<Float>
operator fun Attribute<Int>.div(other: Attribute<Long>): Attribute<Long>
operator fun Attribute<Int>.div(other: Attribute<Short>): Attribute<Int>
operator fun Attribute<Int>.div(other: Attribute<Int>): Attribute<Int>
operator fun Attribute<Int>.div(other: Byte): Attribute<Int>
operator fun Attribute<Int>.div(other: Double): Attribute<Double>
operator fun Attribute<Int>.div(other: Float): Attribute<Float>
operator fun Attribute<Int>.div(other: Int): Attribute<Int>
operator fun Attribute<Int>.div(other: Long): Attribute<Long>
operator fun Attribute<Int>.div(other: Short): Attribute<Int>

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

operator fun Attribute<Long>.div(other: Attribute<Byte>): Attribute<Long>
operator fun Attribute<Long>.div(other: Attribute<Double>): Attribute<Double>
operator fun Attribute<Long>.div(other: Attribute<Float>): Attribute<Float>
operator fun Attribute<Long>.div(other: Attribute<Int>): Attribute<Long>
operator fun Attribute<Long>.div(other: Attribute<Short>): Attribute<Long>
operator fun Attribute<Long>.div(other: Attribute<Long>): Attribute<Long>
operator fun Attribute<Long>.div(other: Byte): Attribute<Long>
operator fun Attribute<Long>.div(other: Double): Attribute<Double>
operator fun Attribute<Long>.div(other: Float): Attribute<Float>
operator fun Attribute<Long>.div(other: Int): Attribute<Long>
operator fun Attribute<Long>.div(other: Long): Attribute<Long>
operator fun Attribute<Long>.div(other: Short): Attribute<Long>

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

operator fun Attribute<Short>.div(other: Attribute<Byte>): Attribute<Int>
operator fun Attribute<Short>.div(other: Attribute<Double>): Attribute<Double>
operator fun Attribute<Short>.div(other: Attribute<Float>): Attribute<Float>
operator fun Attribute<Short>.div(other: Attribute<Int>): Attribute<Int>
operator fun Attribute<Short>.div(other: Attribute<Long>): Attribute<Long>
operator fun Attribute<Short>.div(other: Attribute<Short>): Attribute<Int>
operator fun Attribute<Short>.div(other: Byte): Attribute<Int>
operator fun Attribute<Short>.div(other: Double): Attribute<Double>
operator fun Attribute<Short>.div(other: Float): Attribute<Float>
operator fun Attribute<Short>.div(other: Int): Attribute<Int>
operator fun Attribute<Short>.div(other: Long): Attribute<Long>
operator fun Attribute<Short>.div(other: Short): Attribute<Int>

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<Byte>.downTo(to: Attribute<Int>): Attribute<IntProgression>
infix fun Attribute<Byte>.downTo(to: Attribute<Long>): Attribute<LongProgression>
infix fun Attribute<Byte>.downTo(to: Attribute<Short>): Attribute<IntProgression>
infix fun Attribute<Byte>.downTo(to: Attribute<Byte>): Attribute<IntProgression>
infix fun Attribute<Byte>.downTo(to: Byte): Attribute<IntProgression>
infix fun Attribute<Byte>.downTo(to: Int): Attribute<IntProgression>
infix fun Attribute<Byte>.downTo(to: Long): Attribute<LongProgression>
infix fun Attribute<Byte>.downTo(to: Short): Attribute<IntProgression>
infix fun Attribute<Char>.downTo(to: Attribute<Char>): Attribute<CharProgression>
infix fun Attribute<Char>.downTo(to: Char): Attribute<CharProgression>
infix fun Attribute<Int>.downTo(to: Attribute<Byte>): Attribute<IntProgression>
infix fun Attribute<Int>.downTo(to: Attribute<Long>): Attribute<LongProgression>
infix fun Attribute<Int>.downTo(to: Attribute<Short>): Attribute<IntProgression>
infix fun Attribute<Int>.downTo(to: Attribute<Int>): Attribute<IntProgression>
infix fun Attribute<Int>.downTo(to: Byte): Attribute<IntProgression>
infix fun Attribute<Int>.downTo(to: Int): Attribute<IntProgression>
infix fun Attribute<Int>.downTo(to: Long): Attribute<LongProgression>
infix fun Attribute<Int>.downTo(to: Short): Attribute<IntProgression>
infix fun Attribute<Long>.downTo(to: Attribute<Byte>): Attribute<LongProgression>
infix fun Attribute<Long>.downTo(to: Attribute<Int>): Attribute<LongProgression>
infix fun Attribute<Long>.downTo(to: Attribute<Short>): Attribute<LongProgression>
infix fun Attribute<Long>.downTo(to: Attribute<Long>): Attribute<LongProgression>
infix fun Attribute<Long>.downTo(to: Byte): Attribute<LongProgression>
infix fun Attribute<Long>.downTo(to: Int): Attribute<LongProgression>
infix fun Attribute<Long>.downTo(to: Long): Attribute<LongProgression>
infix fun Attribute<Long>.downTo(to: Short): Attribute<LongProgression>
infix fun Attribute<Short>.downTo(to: Attribute<Byte>): Attribute<IntProgression>
infix fun Attribute<Short>.downTo(to: Attribute<Int>): Attribute<IntProgression>
infix fun Attribute<Short>.downTo(to: Attribute<Long>): Attribute<LongProgression>
infix fun Attribute<Short>.downTo(to: Attribute<Short>): Attribute<IntProgression>
infix fun Attribute<Short>.downTo(to: Byte): Attribute<IntProgression>
infix fun Attribute<Short>.downTo(to: Int): Attribute<IntProgression>
infix fun Attribute<Short>.downTo(to: Long): Attribute<LongProgression>
infix fun Attribute<Short>.downTo(to: Short): Attribute<IntProgression>

drop

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

fun <T> Attribute<Iterable<T>>.drop(n: Attribute<Int>): Attribute<List<T>>
fun <T> Attribute<Iterable<T>>.drop(n: Int): Attribute<List<T>>

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

fun <T> Attribute<Sequence<T>>.drop(n: Attribute<Int>): Attribute<Sequence<T>>
fun <T> Attribute<Sequence<T>>.drop(n: Int): Attribute<Sequence<T>>

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

fun Attribute<String>.drop(n: Attribute<Int>): Attribute<String>
fun Attribute<String>.drop(n: Int): Attribute<String>

dropLast

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

fun <T> Attribute<List<T>>.dropLast(n: Attribute<Int>): Attribute<List<T>>
fun <T> Attribute<List<T>>.dropLast(n: Int): Attribute<List<T>>

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

fun Attribute<String>.dropLast(n: Attribute<Int>): Attribute<String>
fun Attribute<String>.dropLast(n: Int): Attribute<String>

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

elementAt

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

fun <T> Attribute<Iterable<T>>.elementAt(index: Attribute<Int>): Attribute<T>
fun <T> Attribute<Iterable<T>>.elementAt(index: Int): Attribute<T>
fun <T> Attribute<List<T>>.elementAt(index: Attribute<Int>): Attribute<T>
fun <T> Attribute<List<T>>.elementAt(index: Int): Attribute<T>

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

fun <T> Attribute<Sequence<T>>.elementAt(index: Attribute<Int>): Attribute<T>
fun <T> Attribute<Sequence<T>>.elementAt(index: Int): Attribute<T>

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

fun Attribute<String>.elementAt(index: Attribute<Int>): Attribute<Char>
fun Attribute<String>.elementAt(index: Int): Attribute<Char>

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>

elementAtOrNull

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

fun <T> Attribute<Iterable<T>>.elementAtOrNull(index: Attribute<Int>): Attribute<T?>
fun <T> Attribute<Iterable<T>>.elementAtOrNull(index: Int): Attribute<T?>
fun <T> Attribute<List<T>>.elementAtOrNull(index: Attribute<Int>): Attribute<T?>
fun <T> Attribute<List<T>>.elementAtOrNull(index: Int): Attribute<T?>

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

fun <T> Attribute<Sequence<T>>.elementAtOrNull(index: Attribute<Int>): Attribute<T?>
fun <T> Attribute<Sequence<T>>.elementAtOrNull(index: Int): Attribute<T?>

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

fun Attribute<String>.elementAtOrNull(index: Attribute<Int>): Attribute<Char?>
fun Attribute<String>.elementAtOrNull(index: Int): 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>>
fun <R> Attribute<Iterable<*>>.filterIsInstance(): 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>>
fun <R> Attribute<Sequence<*>>.filterIsInstance(): 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<Iterable<*>>.filterIsInstanceToSet(): 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>>
fun <R> Attribute<Sequence<*>>.filterIsInstanceToSet(): 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>>

filterNotNull

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

fun <T : Any> Attribute<Iterable<T?>>.filterNotNull(): Attribute<List<T>>

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

fun <T : Any> Attribute<Sequence<T?>>.filterNotNull(): Attribute<Sequence<T>>

filterNotNullToSet

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

fun <T : Any> Attribute<Iterable<T?>>.filterNotNullToSet(): Attribute<Set<T>>
fun <T : Any> Attribute<Sequence<T?>>.filterNotNullToSet(): Attribute<Set<T>>

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 returns a new Attribute

fun Attribute<CharProgression>.first(): Attribute<Char>
fun Attribute<IntProgression>.first(): Attribute<Int>
fun Attribute<LongProgression>.first(): Attribute<Long>

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

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

Same as first, but returns a new Attribute

fun <A> Attribute<Pair<A, *>>.first(): Attribute<A>

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

fun <T> Attribute<Sequence<T>>.first(): Attribute<T>
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(): Attribute<Char>
fun Attribute<String>.first(predicate: (Char) -> Boolean): Attribute<Char>

Same as first, but returns a new Attribute

fun <A> Attribute<Triple<A, *, *>>.first(): Attribute<A>

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(): Attribute<T?>
fun <T> Attribute<Iterable<T>>.firstOrNull(predicate: (T) -> Boolean): Attribute<T?>
fun <T> Attribute<List<T>>.firstOrNull(): Attribute<T?>

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

fun <T> Attribute<Sequence<T>>.firstOrNull(): Attribute<T?>
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(): Attribute<Char?>
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>>

flatten

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

fun <T> Attribute<Iterable<Iterable<T>>>.flatten(): Attribute<List<T>>

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

fun <T> Attribute<Sequence<Iterable<T>>>.flatten(): Attribute<Sequence<T>>
fun <T> Attribute<Sequence<out Sequence<T>>>.flatten(): Attribute<Sequence<T>>

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 <E> Attribute<List<E>>.get(index: Attribute<Int>): Attribute<E>
operator fun <E> Attribute<List<E>>.get(index: Int): Attribute<E>

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<MatchGroupCollection>.get(index: Attribute<Int>): Attribute<MatchGroup?>
operator fun Attribute<MatchGroupCollection>.get(index: Int): Attribute<MatchGroup?>

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

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

operator fun Attribute<String>.get(index: Attribute<Int>): Attribute<Char>
operator fun Attribute<String>.get(index: Int): Attribute<Char>

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