Set0.29.1

Overview
Properties
Methods

external class Set<out Element> extends Collection<Element>

A collection of unique elements.

Known subtypes:
Known usages:
All versions:

Sets retain the order of elements when constructed, which affects the how they are iterated over. However, ordering does not affect equality between two sets.

The following operators are supported for sets:

set1 + set2  // union

Properties(show inherited)

link
length: Int

The number of elements in this collection.
Facts:
```
List(1, 2, 3).length == 3
List().length == 0
```
link
isEmpty: Boolean

Tells whether this collection is empty.
Facts:
```
!List(1, 2, 3).isEmpty
List().isEmpty
```
link
first: Element

The first element in this collection.
Throws if this collection is empty.

Facts:
```
List(1, 2, 3).first == 1
import("pkl:test").catch(() -> List().first)
```
link

firstOrNull: Element?

Same as first but returns null if this collection is empty.
link
rest: Set<Element>

The tail of this collection.
Throws if this collection is empty.

Facts:
```
List(1, 2, 3).rest == List(2, 3)
import("pkl:test").catch(() -> List().rest)
```
link

restOrNull: Set<Element>?

Same as rest but returns null if this collection is empty.
link
last: Element

The last element in this collection.
Throws if this collection is empty.

Facts:
```
List(1, 2, 3).last == 3
import("pkl:test").catch(() -> List().last)
```
link

lastOrNull: Element?

Same as last but returns null if this collection is empty.
link
single: Element

The single element in this collection.
Throws if this collection has zero or more than one element.

Facts:
```
List(1).single == 1
throws(() -> List().single)
throws(() -> List(1, 2, 3).single)
```
link

singleOrNull: Element?

Same as single but returns null if this collection is empty or has more than one element.
link

min: Element

Returns the first element in this collection that is less than or equal to any other element.

Shorthand for minWith((a, b) -> a < b).

Throws if this collection is empty, or if any two elements cannot be compared with <.
link

minOrNull: Element

Same as min but returns null if this collection is empty.
link

max: Element

Returns the first element in this collection that is greater than or equal to any other element.

Shorthand for maxWith((a, b) -> a < b).

Throws if this collection is empty, or if any two elements cannot be compared with <.
link

maxOrNull: Element?

Same as max but returns null if this collection empty.

Methods(show inherited)

link

function

Any.getClass(): Class (pkl.base)

Returns the class of this.
link

function

Any.toString(): String (pkl.base)

Returns a string representation of this.

This method is used to convert the values of string interpolation expressions to strings.
link

function

Any.ifNonNull<Result>(transform: (NonNull) -> Result): Result? (pkl.base)

Returns this |> transform if this is non-null, and null otherwise.

This method is the complement of the ?? operator and the equivalent of an Option type's map and flatMap methods.

link

function

contains(element: Any): Boolean

Tests if element is contained in this collection.

Facts:

List(1, 2, 3).contains(1)
List(1, 2, 3).contains(2)
List(1, 2, 3).contains(3)
!List(1, 2, 3).contains(4)

link

function
startsWith(coll: Collection<Any>): Boolean

Tests if this collection starts with the elements in coll.
Facts:
```
List(1, 2, 3).startsWith(List(1, 2))
List(1, 2, 3).startsWith(List())
!List(1, 2, 3).startsWith(List(2, 3))
```
link

function
endsWith(coll: Collection<Any>): Boolean

Tests if this collection ends with the elements in coll.
Facts:
```
List(1, 2, 3).endsWith(List(2, 3))
List(1, 2, 3).endsWith(List())
!List(1, 2, 3).endsWith(List(1, 2))
```
link

function

split(index: Int): Pair<Set<Element>, Set<Element>>

Splits this collection into two at split point index.

If index is zero or length, one of the two collections is empty. Throws if index is outside range 0..length.
link

function

splitOrNull(index: Int): Pair<Set<Element>, Set<Element>>?

Same as split() but returns null if index is outside range 0..length.
link

function

partition(predicate: (Element) -> Boolean): Pair<Set<Element>, Set<Element>>
link

abstract function
Collection.indexOf(element: Any): Int (pkl.base)

The zero-based index of the first occurrence of element in this collection.
Throws if this collection does not contains element.

Facts:
```
List(1, 2, 3).indexOf(2) == 1
List(1, 2, 2).indexOf(2) == 1
import("pkl:test").catch(() -> List(1, 2, 3).indexOf(4))
```
link

abstract function

Collection.indexOfOrNull(element: Any): Int? (pkl.base)

Same as indexOf() but returns null if this collection does not contain element.
link

abstract function
Collection.lastIndexOf(element: Any): Int (pkl.base)

The zero-based index of the last occurrence of element in this collection.
Throws if this collection does not contain element.

Facts:
```
List(1, 2, 3).lastIndexOf(2) == 1
List(1, 2, 2).lastIndexOf(2) == 2
import("pkl:test").catch(() -> List(1, 2, 3).lastIndexOf(4))
```
link

abstract function

Collection.lastIndexOfOrNull(element: Any): Int? (pkl.base)

Same as lastIndexOf() but returns null if this collection does not contain element.
link

function
find(predicate: (Element) -> Boolean): Element

The first element for which predicate returns true.
Throws if predicate does not hold for any element in this collection.

Facts:
```
List(5, 6, 7).find((n) -> n.isEven) == 6
List(4, 6, 7).find((n) -> n.isEven) == 4
import("pkl:test").catch(() -> List(5, 7, 9).find((n) -> n.isEven))
```
link

function

findOrNull(predicate: (Element) -> Boolean): Element?

Same as find() but returns null if predicate does not hold for any element in this collection.
link

function
findLast(predicate: (Element) -> Boolean): Element

The last element for which predicate returns true.
Throws if predicate does not hold for any element in this collection.

Facts:
```
List(5, 6, 7).findLast((n) -> n.isEven) == 6
List(4, 6, 8).findLast((n) -> n.isEven) == 8
List(5, 7, 9).findLast((n) -> n.isEven) == null
```
link

function

findLastOrNull(predicate: (Element) -> Boolean): Element?

Same as findLast() but returns null if predicate does not hold for any element in this collection.
link

abstract function
Collection.findIndex(predicate: (Element) -> Boolean): Int (pkl.base)

The index of the first element for which predicate returns true.

Also known as:

indexWhere
Throws if predicate does not hold for any element in this collection.

Facts:
```
List(5, 6, 7).findIndex((n) -> n.isEven) == 1
List(4, 6, 8).findIndex((n) -> n.isEven) == 0
import("pkl:test").catch(() -> List(5, 7, 9).findLast((n) -> n.isEven))
```
link

abstract function

Collection.findIndexOrNull(predicate: (Element) -> Boolean): Int? (pkl.base)

Same as findIndex() but returns null if predicate does not hold for any element in this collection.

Also known as:

indexWhere
link

abstract function
Collection.findLastIndex(predicate: (Element) -> Boolean): Int (pkl.base)

The index of the last element for which predicate returns true.

Also known as:

lastIndexWhere
Throws if predicate does not hold for any element in this collection.

Facts:
```
List(5, 6, 7).findLastIndex((n) -> n.isEven) == 1
List(4, 6, 8).findLastIndex((n) -> n.isEven) == 2
import("pkl:test").catch(() -> List(5, 7, 9).findLastIndex((n) -> n.isEven))
```
link

abstract function

Collection.findLastIndexOrNull(predicate: (Element) -> Boolean): Int? (pkl.base)

Same as findLastIndex() but returns null if predicate does not hold for any element in this collection.

Also known as:

lastIndexWhere

link

function

count(predicate: (Element) -> Boolean): Int

The number of elements for which predicate returns true.

Facts:

List(1, 2, 3).count((n) -> n.isEven) == 1
List(1, 2, 3).count((n) -> n.isOdd) == 2
List(1, 2, 3).count((n) -> n > 9) == 0

link

function
every(predicate: (Element) -> Boolean): Boolean

Tests whether predicate holds for every element in this collection.
Facts:
```
List(1, 3, 3).every((n) -> n.isOdd)
List().every((n) -> n.isOdd)
!List(1, 2, 3).every((n) -> n.isOdd)
```
link

function
any(predicate: (Element) -> Boolean): Boolean

Tests whether predicate holds for at least one element in this collection.
Facts:
```
List(1, 2, 3).any((n) -> n.isEven)
!List(1, 2, 3).any((n) -> n.isEven)
!List().any((n) -> n.isEven)
```

link

function

filter(predicate: (Element) -> Boolean): Set<Element>

Retains elements for which predicate holds.

Facts:

List(1, 2, 3).filter((n) -> n.isOdd) == List(1, 3)
List(1, 2, 3).filter((n) -> n.isEven) == List(2)
List(1, 2, 3).filter((n) -> n > 9) == List()

link

function

filterNonNull(): Set<Element(this != null)>

Retains non-null elements.

Shorthand for filter((it) -> it != null).

link

function

filterIndexed(predicate: (Int, Element) -> Boolean): Set<Element>

Retains elements for which predicate holds.

predicate takes two arguments: the index of the element, and the element itself.

Facts:

List(1, 2, 3).filterIndexed((i, n) -> i.isOdd) == List(2)
List(1, 2, 3).filterIndexed((i, n) -> i.isEven) == List(1, 3)
List(1, 2, 3).filterIndexed((i, n) -> i.isOdd && n > 2) == List()
List(1, 2, 3).filterIndexed((i, n) -> i.isEven && n > 2) == List(3)

link

function
filterIsInstance<Type>(clazz: Class): Set<Type>

Retains elements whose class is a subclass of clazz.
Shorthand for filter((it) -> it is X).

Facts:
```
List(42, "Pigeon", true, "Parrot").filterIsInstance(String) == List("Pigeon", "Parrot")
```
link

function
map<Result>(transform: (Element) -> Result): Set<Result>

Transforms this collection by applying transform to each element.
Facts:
```
List(1, 2, 3).map((n) -> n * 2) == List(2, 4, 6)
List(1, 2, 3).map((n) -> n.isEven) == List(false, true, false)
```
link

function
mapIndexed<Result>(transform: (Int, Element) -> Result): Set<Result>

Transforms this collection by applying transform to each element.
transform takes two arguments: the index of the element, and the element itself.

Facts:
```
List(1, 2, 3).mapIndexed((i, n) -> n * i) == List(0, 2, 6)
List(1, 2, 3).mapIndexed((i, n) -> i.isOdd && n.isEven) == List(false, true, false)
```
link

function
mapNonNull<Result>(transform: (Element) -> Result): Set<Result(this != null)>

Transforms this collection by applying transform to each element and removing resulting null elements.
Equivalent to map(transform).filterNonNull().

Facts:
```
List(1, 2, 3).mapNonNull((n) -> if (n.isOdd) null else n + 2) == List(4)
```
link

function
mapNonNullIndexed<Result>(transform: (Int, Element) -> Result): Set<Result(this != null)>

Transforms this collection by applying transform to each element and removing resulting null elements.
transform takes two arguments: the index of the element, and the element itself.

Facts:
```
List(1, 2, 3, 4).mapNonNullIndexed((i, n) -> if (n.isOdd) null else n * i) == List(2, 12)
List(1, 2, 3, 4, null).mapNonNullIndexed((i, n) -> if (n?.isOdd ?? true) null else n * i) == List(2, 12)
```
link

function

flatMap<Result>(transform: (Element) -> Collection<Result>): Set<Result>

Applies a collection-generating transform to each element in this collection and concatenates the resulting collections.

Throws if transform produces a non-collection value.
link

function

flatMapIndexed<Result>(transform: (Int, Element) -> Collection<Result>): Set<Result>

Applies a collection-generating transform to each element in this collection and concatenates the resulting collections.

transform takes two arguments: the index of the element, and the element itself.

Throws if transform produces a non-collection value.
link

function

flatten(): Set

Concatenates the elements in this collection, each of which must itself be a collection.

Throws if any element is not a collection.
link

function

add<Other>(element: Other): Set<(Element|Other)>

Adds element to this collection.

For List, element is appended.
link

function

take(n: Int): Set<Element>

Returns the first n elements in this collection.
link

function

takeLast(n: Int): Set<Element>

Returns the last n elements in this collection.
link

function

takeWhile(predicate: (Element) -> Boolean): Set<Element>

Returns the longest prefix of this collection that satisfies predicate.
link

function

takeLastWhile(predicate: (Element) -> Boolean): Set<Element>

Returns the longest suffix of this collection that satisfies predicate.
link

function

drop(n: Int): Set<Element>

Removes the first n elements in this collection.
link

function

dropLast(n: Int): Set<Element>

Removes the last n elements in this collection.
link

function

dropWhile(predicate: (Element) -> Boolean): Set<Element>

Removes the longest prefix of this collection that satisfies predicate.
link

function

dropLastWhile(predicate: (Element) -> Boolean): Set<Element>

Removes the longest suffix of this collection that satisfies predicate.
link

function

fold<Result>(initial: Result, operator: (Result, Element) -> Result): Result

Folds this collection in iteration order using operator, starting with initial.
link

function

foldBack<Result>(initial: Result, operator: (Element, Result) -> Result): Result

Folds this collection in reverse iteration order using operator, starting with initial.
link

function

foldIndexed<Result>(initial: Result, operator: (Int, Result, Element) -> Result): Result

Folds this collection in iteration order using operator, starting with initial.

The first parameter of operator is the zero-based index of the current element.
link

function

reduce<Result>(operator: ((Element|Result), Element) -> Result): Result

Folds this collection in iteration order using operator, starting with the first element.

Throws if this collection is empty.
link

function

reduceOrNull<Result>(operator: ((Element|Result), Element) -> Result): Result?

Same as reduce() but returns null if this collection is empty.
link

function

groupBy<Key>(selector: (Element) -> Key): Map<Key, Set<Element>>

Groups the elements in this collection according to keys returned by selector.
link

function

repeat(n: Int): List<Element>

Concatenates this collection n times.
link

function

minBy(selector: (Element) -> Int): Element

Returns the first element in this collection that is less than or equal to any other element after applying selector.

Shorthand for minWith((a, b) -> selector.apply(a) < selector.apply(b)).

Throws if this collection is empty or if any two elements cannot be compared with <.
link

function

minByOrNull(selector: (Element) -> Int): Element?

Same as minBy() but returns null if this collection is empty.
link

function

minWith(comparator: (Element, Element) -> (Boolean|Int)): Element

Returns the first element in this collection that is less than or equal to any other element according to comparator.

comparator should return true if its first argument is less than its second argument, and false otherwise.

Throws if this collection is empty.
link

function

minWithOrNull(comparator: (Element, Element) -> (Boolean|Int)): Element?

Same as minWith() but returns null if this collection is empty.
link

function

maxBy(selector: (Element) -> Int): Element

Returns the first element in this collection that is greater than or equal to any other element after applying selector.

Shorthand for maxWith((a, b) -> selector.apply(a) < selector.apply(b)).

Throws if this collection is empty, or if any two elements cannot be compared with < after applying selector.
link

function

maxByOrNull(selector: (Element) -> Int): Element?

Same as maxBy() but returns null if this collection is empty.
link

function

maxWith(comparator: (Element, Element) -> (Boolean|Int)): Element

Returns the first element in this collection that is greater than or equal to any other element according to comparator.

comparator should return true if its first argument is less than its second argument, and false otherwise.

Throws if this collection is empty.
link

function

maxWithOrNull(comparator: (Element, Element) -> (Boolean|Int)): Element?

Same as maxWith() but returns null if this collection is empty.
link

function

sort(): List<Element>

Sorts this collection of Comparable elements in ascending order.

Shorthand for sortWith((a, b) -> a < b).

Throws if any two elements in this collection cannot be compared with <.
link

function

sortBy(selector: (Element) -> Comparable): List<Element>

Sorts this collection in ascending order after applying selector.

Shorthand for sortWith((a, b) -> selector.apply(a) < selector.apply(b)).

Throws if any two elements in this collection cannot be compared with < after applying selector.
link

function
sortWith(comparator: (Element, Element) -> (Boolean|Int)): List<Element>

Sorts this collection according to comparator.
comparator should return true if its first argument comes before its second argument in the sort order, and false otherwise.

Facts:
```
List(1, 2, 3).sortWith((a, b) -> a > b)) == List(3, 2, 1)
```
link

function

reverse(): List<Element>

Reverses the order of elements in this collection.
link

function
zip<Other>(coll: Collection<Other>): Set<Pair<Element, Other>>

Returns a collection that combines corresponding elements of this and coll in pairs.
The returned collection's length is the minimum of this.length and coll.length.

Facts:
```
List(1, 2, 3).zip(List(4, 5, 6)) == List(Pair(1, 4), Pair(2, 5), Pair(3, 6))
List(1, 2, 3).zip(List(4, 5, 6, 7, 8)) == List(Pair(1, 4), Pair(2, 5), Pair(3, 6))
```
link

abstract function

Collection.transpose(): Collection (pkl.base)

Transposes this two-dimensional collection of collections.

The nth row of the resulting collection corresponds to the nth column of this collection. Throws if an element of this collection is not itself a collection.
link

function

join(separator: String): String

Converts the elements of this collection to strings and concatenates them inserting separator between elements.
link

function

toList(): List<Element>

Converts this collection to a list.

Returns this collection if it already is a list.
link

function

toSet(): Set<Element>

Converts this collection to a set.

Returns this collection if it already is a set.
link

function

toMap<Key, Value>(keyExtractor: (Element) -> Key, valueExtractor: (Element) -> Value): Map<Key, Value>

Converts this collection to a map by extracting a key and value from each element using the given functions.
link

function

toListing(): Listing<Element>

Converts this collection to a Listing.
link

function

toDynamic(): Dynamic

Converts this collection to a Dynamic object.
link

function

intersect(other: Set): Set<Element>

The intersection of this set and other.
link

function

difference(other: Set): Set<Element>

The difference of this set and other.