all

 fun <T> T?.all(predicate: (T) -> Boolean): Boolean

Returns true if the element is not null and matches the given predicate

any

 fun <T> T?.any(predicate: (T) -> Boolean): Boolean

Returns true if the element is not null and matches the given predicate

count

 fun <T> T?.count(predicate: (T) -> Boolean): Int

Returns the 1 if the element is not null else 0

filter

 fun <T> T?.filter(predicate: (T) -> Boolean): T?

Returns a new List containing all elements in this collection which match the given predicate

filterNot

 fun <T> T?.filterNot(predicate: (T) -> Boolean): Collection<T>

Returns a new collection containing all elements in this collection which do not match the given predicate

filterNotNull

 fun <T> T?.filterNotNull(): Collection<T>

Returns a List containing all the non null elements in this collection

filterNotNullTo

 fun <T, C> T?.filterNotNullTo(result: C): C

Filters all the null elements in this collection winto the given result collection

filterNotTo

 fun <T, C> T?.filterNotTo(result: C, predicate: (T) -> Boolean): C

Returns a new collection containing all elements in this collection which do not match the given predicate

filterTo

 fun <T, C> T?.filterTo(result: C, predicate: (T) -> Boolean): C

Filters all elements in this collection which match the given predicate into the given result collection

find

 fun <T> T?.find(predicate: (T) -> Boolean): T?

Returns the first item which matches the predicate if this element is not null else null

flatMap

 fun <T, R> T?.flatMap(transform: (T) -> MutableCollection<R>): Collection<R>

Returns the result of transforming each item in the collection to a one or more values which
are concatenated together into a single collection

flatMapTo

 fun <T, R> T?.flatMapTo(result: MutableCollection<R>, transform: (T) -> MutableCollection<R>): Collection<R>

Returns the result of transforming each item in the collection to a one or more values which
are concatenated together into a single collection

fold

 fun <T> T?.fold(initial: T, operation: (T, T) -> T): T

Folds all the values from from left to right with the initial value to perform the operation on sequential pairs of values

For example to sum together all numeric values in a collection of numbers it would be
{code}val total = numbers.fold(0){(a, b) -> a + b}{code}

foldRight

 fun <T> T?.foldRight(initial: T, operation: (T, T) -> T): T

Folds all the values from right to left with the initial value to perform the operation on sequential pairs of values

forEach

 fun <T> T?.forEach(operation: (T) -> Unit): Unit

Performs the given operation on each element inside the collection

groupBy

 fun <T, K> T?.groupBy( [result: MutableMap<K, MutableList<T>>], toKey: (T) -> K): Map<K, MutableList<T>>

Iterates through the collection performing the transformation on each element and using the result
as the key in a map to group elements by the result

makeString

 fun <T> T?.makeString( [separator: String, prefix: String, postfix: String]): String

Creates a String from the nullable or item with the given prefix and postfix if supplied

map

 fun <T, R> T?.map(transform: (T) -> R): R?

Returns the nullable result of transforming this with the given transformation function

mapTo

 fun <T, R, C> T?.mapTo(result: C, transform: (T) -> R): C

Transforms each element of this collection with the given function then adds the results to the given collection

reverse

 fun <T> T?.reverse(): T?

Returns itself since it can’t be reversed as it can contain at most one item

toCollection

 fun <T, C> T?.toCollection(result: C): C

Copies the collection into the given collection

toLinkedList

 fun <T> T?.toLinkedList(): LinkedList<T>

Converts the collection into a LinkedList

toList

 fun <T> T?.toList(): List<T>

Converts the collection into a List

toSet

 fun <T> T?.toSet(): Set<T>

Converts the collection into a Set

toSortedSet

 fun <T> T?.toSortedSet(): SortedSet<T>

Converts the collection into a SortedSet