io.github.goquati/io.github.goquati.kotlin.util

Package-level declarations

Types

class AesEncryption(key: AesEncryption.Key)

value class Result<out T, out E>

Functions

inline fun <T, K : Any> <Error class: unknown class><T>.associateByNotNull(crossinline keySelector: (T) -> K?): Map<K, T>

inline fun <T, K : Any> Iterable<T>.associateByNotNull(keySelector: (T) -> K?): Map<K, T>

associateNotNull

inline fun <T, K : Any, V : Any> <Error class: unknown class><T>.associateNotNull(crossinline valueSelector: (T) -> <Error class: unknown class><K?, V?>?): Map<K, V>

inline fun <T, K : Any, V : Any> Iterable<T>.associateNotNull(valueSelector: (T) -> <Error class: unknown class><K?, V?>?): Map<K, V>

associateWithNotNull

inline fun <T, V : Any> <Error class: unknown class><T>.associateWithNotNull(crossinline valueSelector: (T) -> V?): Map<T, V>

inline fun <T, V : Any> Iterable<T>.associateWithNotNull(valueSelector: (T) -> V?): Map<T, V>

combine

fun <K, T1, T2, R> combine(m1: Map<K, T1>, m2: Map<K, T2>, transform: (K, T1, T2) -> R): Map<K, R>

fun <K, T1, T2, T3, R> combine(m1: Map<K, T1>, m2: Map<K, T2>, m3: Map<K, T3>, transform: (K, T1, T2, T3) -> R): Map<K, R>

fun <K, T1, T2, T3, T4, R> combine(m1: Map<K, T1>, m2: Map<K, T2>, m3: Map<K, T3>, m4: Map<K, T4>, transform: (K, T1, T2, T3, T4) -> R): Map<K, R>

fun <K, T1, T2, T3, T4, T5, R> combine(m1: Map<K, T1>, m2: Map<K, T2>, m3: Map<K, T3>, m4: Map<K, T4>, m5: Map<K, T5>, transform: (K, T1, T2, T3, T4, T5) -> R): Map<K, R>

containsAny

fun <T> Collection<T>.containsAny(vararg elements: T): Boolean

fun <T> Collection<T>.containsAny(elements: Iterable<T>): Boolean

eachMaxBy

inline fun <T, K, C : Comparable<C>> <Error class: unknown class><T, K>.eachMaxBy(selector: (T) -> C): Map<K, T>

eachMinBy

inline fun <T, K, C : Comparable<C>> <Error class: unknown class><T, K>.eachMinBy(selector: (T) -> C): Map<K, T>

Failure

fun <E> Failure(error: E): Result<Nothing, E>

filterFailure

fun <E> Iterable<Result<*, E>>.filterFailure(): List<E>

filterSuccess

fun <T> Iterable<Result<T, *>>.filterSuccess(): List<T>

fun <T, E> Iterable<Result<T, E>>.filterSuccess(errorHandler: (E) -> Unit): List<T>

flatMap

inline fun <T1, T2, E> Result<T1, E>.flatMap(block: (T1) -> Result<T2, E>): Result<T2, E>

flatten

fun <T, E> Result<Result<T, E>, E>.flatten(): Result<T, E>

fun <K, V> Iterable<Map<K, V>>.flatten(): Map<K, V>

fromBase64

fun String.fromBase64(): ByteArray

fromBase64UrlSafe

fun String.fromBase64UrlSafe(): ByteArray

getFailureOr

fun <E> Result<*, E>.getFailureOr(default: E): E

inline fun <T, E> Result<T, E>.getFailureOr(block: (T) -> E): E

getOr

fun <T> Result<T, *>.getOr(default: T): T

inline fun <T, E> Result<T, E>.getOr(block: (E) -> T): T

getOrThrow

fun <T, E : Throwable> Result<T, E>.getOrThrow(): T

groupByNotNull

inline fun <T, K : Any> <Error class: unknown class><T>.groupByNotNull(crossinline keySelector: (T) -> K?): Map<K, List<T>>

inline fun <T, K : Any> Iterable<T>.groupByNotNull(keySelector: (T) -> K?): Map<K, List<T>>

inline fun <T, K : Any, V : Any> <Error class: unknown class><T>.groupByNotNull(crossinline keySelector: (T) -> K?, crossinline valueTransform: (T) -> V?): Map<K, List<V>>

inline fun <T, K : Any, V : Any> Iterable<T>.groupByNotNull(keySelector: (T) -> K?, valueTransform: (T) -> V?): Map<K, List<V>>

intersectAll

fun <T> intersectAll(vararg args: Collection<T>): Set<T>

intersectAll

fun <T> Collection<Collection<T>>.intersectAll(): Set<T>

isDistinct

fun <T> <Error class: unknown class><T>.isDistinct(): Boolean

fun <T> Collection<T>.isDistinct(): Boolean

isDistinctBy

inline fun <T, K> <Error class: unknown class><T>.isDistinctBy(crossinline keySelector: (T) -> K): Boolean

inline fun <T, K> Iterable<T>.isDistinctBy(keySelector: (T) -> K): Boolean

map

inline fun <T1, T2, E> Result<T1, E>.map(block: (T1) -> T2): Result<T2, E>

mapError

fun <T, E> <Error class: unknown class><T>.mapError(block: (Throwable) -> E): Result<T, E>

inline fun <T, E1, E2> Result<T, E1>.mapError(block: (E1) -> E2): Result<T, E2>

mapKeysNotNull

inline fun <K, V, R : Any> Map<out K, V>.mapKeysNotNull(transform: (Map.Entry<K, V>) -> R?): Map<R, V>

mapValuesNotNull

inline fun <K, V, R : Any> Map<out K, V>.mapValuesNotNull(transform: (Map.Entry<K, V>) -> R?): Map<K, R>

mostFrequent

fun <T> Iterable<T>.mostFrequent(): T

mostFrequentOrNull

fun <T> Iterable<T>.mostFrequentOrNull(): T?

Success

fun <V> Success(value: V): Result<V, Nothing>

take

fun <T> <Error class: unknown class><T>.take(n: Int, default: T): <Error class: unknown class><T>

fun <T> Iterable<T>.take(n: Int, default: T): List<T>

takeIfNotBlank

fun String.takeIfNotBlank(): String?

takeIfNotEmpty

fun <T, C : Collection<T>> C.takeIfNotEmpty(): C?

toBase64

fun ByteArray.toBase64(): String

toBase64UrlSafe

fun ByteArray.toBase64UrlSafe(): String

toResultCollection

fun <T, E, C : MutableCollection<in T>> Iterable<Result<T, E>>.toResultCollection(destination: C): Result<C, E>

toResultCollectionOr

inline fun <T, E, C : MutableCollection<in T>> Iterable<Result<T, E>>.toResultCollectionOr(destination: C, block: (Collection<E>) -> C): C

toResultList

fun <T, E> Iterable<Result<T, E>>.toResultList(): Result<List<T>, E>

toResultListOr

inline fun <T, E> Iterable<Result<T, E>>.toResultListOr(block: (Collection<E>) -> List<T>): List<T>

toResultSet

fun <T, E> Iterable<Result<T, E>>.toResultSet(): Result<Set<T>, E>

toResultSetOr

inline fun <T, E> Iterable<Result<T, E>>.toResultSetOr(block: (Collection<E>) -> Set<T>): Set<T>