class Array<+T>

A contiguous, fixed-size list/array-like type.

Static Methods

Creating an Array

static fun sourcecreateFromItems<I: readonly Sequence<T>>(items: I): this

static fun sourcemcreateFromItems<I: readonly Sequence<T>>(items: I): mutable this

static fun sourcecreateFromIterator<I: mutable Iterator<T>>(items: I): this

static fun sourcemcreateFromIterator<I: mutable Iterator<T>>(items: I): mutable this

static fun sourcefill(count: Int, filler: T): Array<T>

static fun sourcemfill(count: Int, filler: T): mutable Array<T>

static fun sourcefillBy(size: Int, f: (Int) -> T): Array<T>

static fun sourcemfillBy(size: Int, f: (Int) -> T): mutable Array<T>

Methods

Copying an Array

readonly fun sourceclone(): mutable Array<T>

readonly fun sourcechill(): this

Sizing

readonly fun sourcesize(): Int

readonly fun sourceisEmpty(): Bool

Accessing/Modifying Items

readonly fun sourceget(index: Int): T

readonly fun sourcemaybeGet(i: Int): Option<T>

readonly fun sourcemaybeFirst(): Option<T>

readonly fun sourcemaybeLast(): Option<T>

readonly fun sourcefirst(): T

readonly fun sourcelast(): T

mutable fun sourceset(i: Int, value: T): Void

Reordering Items

mutable fun sourcereverse(): Void

mutable fun sourcesort(compare: (T, T) ~> Order): Void

Sorts the items in place using their default ordering. To sort a collection of non-Orderable items, use sortBy().

mutable fun sourcesortBy<K: readonly Orderable>(selector: (T) ~> K, compare: (K, K) ~> Order): Void

Sorts the items in place, using the given predicate to determine ordering. To sort a collection of non-Orderable items, use Orderable.create():

a: Array = Array[...]; compareFn = (a: NonOrderable, b: NonOrderable): Order ~> { ... }; b = a.sortBy(x ~> Orderable.create(x, compareFn));

Trait Implementations

readonly fun sourcecompare<U: Orderable>(other: Array<U>): Order

Lexicographical comparison of two Vectors.

readonly fun source<<U: Orderable>(other: Array<U>): Bool

readonly fun source><U: Orderable>(other: Array<U>): Bool

readonly fun source<=<U: Orderable>(other: Array<U>): Bool

readonly fun source>=<U: Orderable>(other: Array<U>): Bool

readonly fun source==<U: Equality>(other: readonly Array<U>): Bool

readonly fun source!=<U: Equality>(other: readonly Array<U>): Bool

readonly fun sourceeqBy<U>(other: readonly Array<U>, eq: (U, U) -> Bool): Bool

readonly fun sourcetoString(): String

readonly fun sourcehash(): Int

readonly fun sourcehashBy(hash: (T) -> Int, seed: Int): Int

readonly fun sourceinspect(): Inspect

Selecting Portions of a Sequence

readonly fun sourceslice(start: Int, end: Int): this

Aggregation

readonly fun sourceindexOf<S: Equality>(v: S): Option<Int>

readonly fun sourcecontains<S: Equality>(v: S): Bool

readonly fun sourcefoldl<Tresult>(f: (Tresult, T) -> Tresult, init: Tresult): Tresult

readonly fun sourcefind(p: (T) -> Bool): Option<T>

readonly fun sourceall(p: (T) -> Bool): Bool

readonly fun sourceany(p: (T) -> Bool): Bool

readonly fun sourcejoin(separator: String): String

Composition

readonly fun sourcemap<T2>(f: (T) -> T2): Array<T2>

frozen fun sourceparallelMap<T2>(f: (T) ~> T2): Array<T2>

readonly fun sourcemapWithIndex<T2>(f: (Int, T) -> T2): Array<T2>

readonly fun sourcemapAcc<R, U>(f: (R, T) -> (R, U), acc: R): (R, Array<U>)

readonly fun sourcefilter(p: (T) -> Bool): Array<T>

readonly fun sourcezip<U, S: readonly Sequence<U>>(second: S): Array<(T, U)>

readonly fun sourcezipWith<U, V, S: readonly Sequence<U>>(second: S, s: (T, U) -> V): Array<V>

readonly fun sourceunzip<T1, T2>(): (Array<T1>, Array<T2>)

readonly fun sourceunzipWith<T1, T2>(f: (T) -> (T1, T2)): (Array<T1>, Array<T2>)

readonly fun sourcetake(num: Int): Array<T>

readonly fun sourcedrop(num: Int): Array<T>

readonly fun sourcefilterNone<U>(): Array<U>

readonly fun sourceflatMap<U>(s: (T) -> Sequence<U>): Array<U>

readonly fun sourceflatten<U>(): Array<U>

readonly fun sourceconcat<T2>(other: Array<T2>): Array<T2>

readonly fun sourcereversed(): Array<T>

readonly fun sourcesorted(compare: (T, T) ~> Order): Array<T>

Returns a new collection representing the items of this collection in sorted order, using their default ordering. To sort a collection of non-Orderable items, use sortedBy().

readonly fun sourcesortedBy<K: readonly Orderable>(selector: (T) ~> K, compare: (K, K) ~> Order): Array<T>

Returns a new collection representing the items of this collection in sorted order, using the given predicate to determine ordering. To sort a collection of non-Orderable items, use Orderable.create():

a: Array = Array[...]; compareFn = (a: NonOrderable, b: NonOrderable): Order ~> { ... }; b = a.sortedBy(x ~> Orderable.create(x, compareFn));

Other

readonly fun sourcesplit(num: Int): (this, this)

Async

fun sourcegen<U: frozen>(): ^Array<U>

frozen fun sourcegenMap<U: frozen>(s: (T) ~> ^U): ^Array<U>

frozen fun sourcegenFilter(p: (T) ~> ^Bool): ^Array<T>

Iteration

readonly fun sourceeach(f: (T) -> Void): Void

readonly fun sourceeachWithIndex(f: (Int, T) -> Void): Void

Iterators

readonly fun sourceitems(): mutable Iterator<(Int, T)>

readonly fun sourcekeys(): mutable Iterator<Int>

readonly fun sourcevalues(): mutable Iterator<T>

readonly fun sourcereversedValues(): mutable Iterator<T>

Inherited Methods

static fun sourcemeta<U, C: MetaClass<U>>(itemClass: C): ArrayMetaClass<U, C>