Package it.unibo.tuprolog.utils

Types

BinaryOperator

common

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

Cache

common

interface Cache<K, V>

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

Cached

common

interface Cached<T>

Castable

common

interface Castable<T : Castable<T>>

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

Cursor

common

interface Cursor<T>

Indexed

common

interface Indexed<K, T>

IntIndexed

common

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

LongIndexed

common

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

NumberTypeTester

common

class NumberTypeTester

Optional

common

sealed class Optional<T>

Taggable

common

interface Taggable<Self : Taggable<Self>>

TagsOperator

common

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

Functions

addFirst

common

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

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

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

addTag

common

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

addTags

common

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

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

buffered

common

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

clearTags

common

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

cursor

common

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>

dequeOf

common

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

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

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

dropLast

common

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

forceCast

common

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

indexed

common

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

insertAt

common

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

interleave

common

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

common

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>

itemWiseEquals

common

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

common

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

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

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

iterable

jvm

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

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

iterator

jvm

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

longIndexed

common

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

merge

common

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>

mergeSequences

common

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>

permutations

common

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

plus

common

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

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

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

product

common

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

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

setTag

common

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

setTags

common

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

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

skipIndex

common

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

squared

common

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

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

subsequences

common

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

takeFirst

common

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

toCursor

common

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