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

Package com.femastudios.dataflow.async.extensions

Extensions for External Classes

java.math.BigDecimal

java.math.BigInteger

kotlin.Boolean

kotlin.Byte

kotlin.Char

kotlin.collections.Collection

kotlin.collections.Grouping

kotlin.collections.Iterable

kotlin.collections.List

kotlin.collections.Map

kotlin.collections.Set

kotlin.Comparable

kotlin.Double

kotlin.Float

kotlin.Int

kotlin.Long

kotlin.ranges.CharProgression

kotlin.ranges.ClosedFloatingPointRange

kotlin.ranges.ClosedRange

kotlin.ranges.IntProgression

kotlin.ranges.LongProgression

kotlin.sequences.Sequence

kotlin.Short

kotlin.String

kotlin.text.CharCategory

kotlin.text.MatchGroupCollection

kotlin.text.MatchNamedGroupCollection

kotlin.text.Regex

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>

acos

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

fun acos(x: Attribute<Float>): Attribute<Float>
fun acos(x: Attribute<Double>): Attribute<Double>

acosh

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

fun acosh(x: Attribute<Float>): Attribute<Float>
fun acosh(x: Attribute<Double>): Attribute<Double>

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>

asin

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

fun asin(x: Attribute<Float>): Attribute<Float>
fun asin(x: Attribute<Double>): Attribute<Double>

asinh

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

fun asinh(x: Attribute<Float>): Attribute<Float>
fun asinh(x: Attribute<Double>): Attribute<Double>

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

atan

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

fun atan(x: Attribute<Float>): Attribute<Float>
fun atan(x: Attribute<Double>): Attribute<Double>

atan2

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

fun atan2(y: Attribute<Float>, x: Attribute<Float>): Attribute<Float>
fun atan2(y: Attribute<Float>, x: Float): Attribute<Float>
fun atan2(y: Float, x: Attribute<Float>): Attribute<Float>
fun atan2(y: Attribute<Double>, x: Attribute<Double>): Attribute<Double>
fun atan2(y: Attribute<Double>, x: Double): Attribute<Double>
fun atan2(y: Double, x: Attribute<Double>): Attribute<Double>

atanh

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

fun atanh(x: Attribute<Float>): Attribute<Float>
fun atanh(x: Attribute<Double>): Attribute<Double>

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>

ceil

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

fun ceil(x: Attribute<Float>): Attribute<Float>
fun ceil(x: Attribute<Double>): Attribute<Double>

charset

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

fun charset(charsetName: Attribute<String>): Attribute<Charset>

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 <T : Comparable<T>> 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 <T : Comparable<T>> 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 <T : Comparable<T>> T.coerceIn(minimumValue: T?, maximumValue: Attribute<T?>?): Attribute<T>
fun <T : Comparable<T>> T.coerceIn(minimumValue: Attribute<T?>?, maximumValue: T?): Attribute<T>
fun <T : Comparable<T>> T.coerceIn(minimumValue: Attribute<T?>?, maximumValue: Attribute<T?>?): Attribute<T>
fun <T : Comparable<T>> T.coerceIn(range: Attribute<ClosedRange<T>>): Attribute<T>
fun <T : Comparable<T>> T.coerceIn(range: Attribute<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>

compareValues

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

fun <T : Comparable<*>> compareValues(a: T?, b: Attribute<T?>?): Attribute<Int>
fun <T : Comparable<*>> compareValues(a: Attribute<T?>?, b: T?): Attribute<Int>
fun <T : Comparable<*>> compareValues(a: Attribute<T?>?, b: Attribute<T?>?): Attribute<Int>

compareValuesBy

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

fun <T> compareValuesBy(a: Attribute<T>, b: Attribute<T>, vararg selectors: Attribute<(T) -> Comparable<*>?>): 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>

cos

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

fun cos(x: Attribute<Float>): Attribute<Float>
fun cos(x: Attribute<Double>): Attribute<Double>

cosh

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

fun cosh(x: Attribute<Float>): Attribute<Float>
fun cosh(x: Attribute<Double>): Attribute<Double>

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>
infix fun <T> T.eq(another: Attribute<T>): Attribute<Boolean>

exp

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

fun exp(x: Attribute<Float>): Attribute<Float>
fun exp(x: Attribute<Double>): Attribute<Double>

expm1

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

fun expm1(x: Attribute<Float>): Attribute<Float>
fun expm1(x: Attribute<Double>): Attribute<Double>

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>

floor

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

fun floor(x: Attribute<Float>): Attribute<Float>
fun floor(x: Attribute<Double>): Attribute<Double>

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,