utils/it.unibo.tuprolog.utils

Package it.unibo.tuprolog.utils

Types

typealias BinaryOperator<T> = (T, T) -> T

interface Cache<K, V>

Mutable, fixed-capacity cache whose eviction strategy depends on the specific implementation

interface Cached<T>

interface Castable<T : Castable<T>>

A type for all object which can be down-casted via explicit methods

interface Cursor<T>

interface Indexed<K, T>

interface IntIndexed<T> : Indexed<Int, T> , Comparable<IntIndexed<T>>

interface LongIndexed<T> : Indexed<Long, T> , Comparable<LongIndexed<T>>

NumberTypeTester

class NumberTypeTester

sealed class Optional<T>

interface Taggable<Self : Taggable<Self>>

typealias TagsOperator = BinaryOperator<Map<String, Any>>

Functions

expect fun <T> MutableList<T>.addFirst(item: T)

expect fun <T> MutableList<T>.addFirst(items: Iterable<T>)

expect fun <T> MutableList<T>.addFirst(items: Sequence<T>)

actual fun <T> MutableList<T>.addFirst(item: T)

actual fun <T> MutableList<T>.addFirst(items: Iterable<T>)

actual fun <T> MutableList<T>.addFirst(items: Sequence<T>)

actual fun <T> MutableList<T>.addFirst(item: T)

actual fun <T> MutableList<T>.addFirst(items: Iterable<T>)

actual fun <T> MutableList<T>.addFirst(items: Sequence<T>)

fun <T : U, U : Taggable<U>, X : Any> T.addTag(name: String, value: X): T

fun <T : U, U : Taggable<U>, X : Any> T.addTags(tags: Map<String, X>): T

fun <T : U, U : Taggable<U>, X : Any> T.addTags(tag: Pair<String, X>, vararg otherTags: Pair<String, X>): T

fun <T> Sequence<T>.buffered(): Sequence<T>

fun <T : U, U : Taggable<U>> T.clearTags(): T

fun <T> Array<T>.cursor(): Cursor<out T>

fun <T> Collection<T>.cursor(): Cursor<out T>

fun <T> Iterable<T>.cursor(): Cursor<out T>

fun <T> Sequence<T>.cursor(): Cursor<out T>

expect fun <T> dequeOf(vararg items: T): MutableList<T>

expect fun <T> dequeOf(items: Iterable<T>): MutableList<T>

expect fun <T> dequeOf(items: Sequence<T>): MutableList<T>

actual fun <T> dequeOf(vararg items: T): MutableList<T>

actual fun <T> dequeOf(items: Iterable<T>): MutableList<T>

actual fun <T> dequeOf(items: Sequence<T>): MutableList<T>

actual fun <T> dequeOf(vararg items: T): MutableList<T>

actual fun <T> dequeOf(items: Iterable<T>): MutableList<T>

actual fun <T> dequeOf(items: Sequence<T>): MutableList<T>

fun <T> Sequence<T>.dropLast(): Sequence<T>

expect fun <T> Any?.forceCast(): T

actual fun <T> Any?.forceCast(): T

actual fun <T> Any?.forceCast(): T

fun <T> Sequence<T>.indexed(): Sequence<IntIndexed<T>>

fun <T> Sequence<T>.insertAt( index: Int, item: T, vararg items: T): Sequence<T>

fun <T> interleave(vararg iterables: Iterable<T>): Sequence<T>

fun <T> interleave(iterables: Iterable<Iterable<T>>): Sequence<T>

fun <T> interleave(iterables: Sequence<Iterable<T>>): Sequence<T>

interleaveSequences

fun <T> interleaveSequences(vararg iterables: Sequence<T>): Sequence<T>

fun <T> interleaveSequences(iterables: Iterable<Sequence<T>>): Sequence<T>

fun <T> interleaveSequences(iterables: Sequence<Sequence<T>>): Sequence<T>

fun <T> itemWiseEquals(iterable1: Iterable<T>, iterable2: Iterable<T>): Boolean

fun <T> itemWiseEquals(sequence1: Sequence<T>, sequence2: Sequence<T>): Boolean

fun <T> itemWiseEquals( iterable1: Iterable<T>, iterable2: Iterable<T>, comparator: (T, T) -> Boolean): Boolean

fun <T> itemWiseEquals( sequence1: Sequence<T>, sequence2: Sequence<T>, comparator: (T, T) -> Boolean): Boolean

itemWiseHashCode

fun <T> itemWiseHashCode(vararg items: T): Int

fun <T> itemWiseHashCode(iterable: Iterable<T>): Int

fun <T> itemWiseHashCode(sequence: Sequence<T>): Int

fun <T> iterable(iterable: Iterable<T>): MutableIterable<T>

fun <T> iterable(sequence: Sequence<T>): MutableIterable<T>

fun <T> iterator(iterator: Iterator<T>): MutableIterator<T>

fun <T> Sequence<T>.longIndexed(): Sequence<LongIndexed<T>>

fun <T> merge(vararg iterables: Iterable<T>, comparator: (T, T) -> Int): Sequence<T>

fun <T> merge(comparator: Comparator<T>, vararg iterables: Iterable<T>): Sequence<T>

fun <T> merge(comparator: Comparator<T>, iterables: Iterable<Iterable<T>>): Sequence<T>

fun <T> merge(comparator: Comparator<T>, iterables: Sequence<Iterable<T>>): Sequence<T>

fun <T> merge(iterables: Iterable<Iterable<T>>, comparator: (T, T) -> Int): Sequence<T>

fun <T> merge(iterables: Sequence<Iterable<T>>, comparator: (T, T) -> Int): Sequence<T>

fun <T> mergeSequences(vararg iterables: Sequence<T>, comparator: (T, T) -> Int): Sequence<T>

fun <T> mergeSequences(comparator: Comparator<T>, vararg iterables: Sequence<T>): Sequence<T>

fun <T> mergeSequences(comparator: Comparator<T>, iterables: Iterable<Sequence<T>>): Sequence<T>

fun <T> mergeSequences(comparator: Comparator<T>, iterables: Sequence<Sequence<T>>): Sequence<T>

fun <T> mergeSequences(iterables: Iterable<Sequence<T>>, comparator: (T, T) -> Int): Sequence<T>

fun <T> mergeSequences(iterables: Sequence<Sequence<T>>, comparator: (T, T) -> Int): Sequence<T>

fun <T> Iterable<T>.permutations(): Sequence<List<T>>

fun <T> List<T>.permutations(): Sequence<List<T>>

fun <T> Sequence<T>.permutations(): Sequence<List<T>>

fun <T> permutations(vararg items: T): Sequence<List<T>>

operator fun <T : U, U : Taggable<U>, X : Any> T.plus(tag: Pair<String, X>): T

operator fun <T : U, U : Taggable<U>, X : Any> T.plus(tags: Map<String, X>): T

operator fun <T> Cursor<out T>.plus(other: Cursor<out T>): Cursor<out T>

fun <T, U> Sequence<T>.product(other: Sequence<U>): Sequence<Pair<T, U>>

fun <T, U, R> Sequence<T>.product(other: Sequence<U>, combinator: (T, U) -> R): Sequence<R>

fun <T : U, U : Taggable<U>, X : Any> T.setTag(key: String, value: X): T

fun <T : U, U : Taggable<U>, X : Any> T.setTags(tags: Map<String, X>): T

fun <T : U, U : Taggable<U>, X : Any> T.setTags(tag: Pair<String, X>, vararg otherTags: Pair<String, X>): T

fun <T> Sequence<T>.skipIndex(index: Int): Sequence<T>

fun <T> Sequence<T>.squared(): Sequence<Pair<T, T>>

fun <T, R> Sequence<T>.squared(combinator: (T, T) -> R): Sequence<R>

fun <T> Iterable<T>.subsequences(): Sequence<Sequence<T>>

fun <T> Sequence<T>.subsequences(): Sequence<Sequence<T>>

fun <T> subsequences(vararg items: T): Sequence<Sequence<T>>

expect fun <T> MutableList<T>.takeFirst(): T?

actual fun <T> MutableList<T>.takeFirst(): T?

actual fun <T> MutableList<T>.takeFirst(): T?

fun <T> Iterator<T>.toCursor(): Cursor<out T>