A Sequence backed by an Array.

Since Arrays are mutable, this class is private to the language module, where we can be sure the Array is not modified after the ArraySequence has been initialized.

By: Tom
See also sequence()

no subtypes hierarchy

Initializer
ArraySequence(Array<Element> array)
Attributes
firstSource Codeshared actual Element first

The first element returned by the iterator, if any, or null if this stream is empty. For a stream with an unstable iteration order, a different value might be produced each time first is evaluated.

Refines Sequence.first ultimately refines Iterable.first
lastSource Codeshared actual Element last

The last element returned by the iterator, if any, or null if this stream is empty. In the case of an infinite stream, this operation never terminates; furthermore, this default implementation iterates all elements, which might be very expensive.

Refines Sequence.last ultimately refines Iterable.last
restSource Codeshared actual Element[] rest

A stream containing all but the first element of this stream. For a stream with an unstable iteration order, a different stream might be produced each time rest is evaluated.

Therefore, if the stream i has an unstable iteration order, the stream { i.first, *i.rest } might not have the same elements as i.

Refines Sequence.rest ultimately refines Iterable.rest
sizeSource Codeshared actual Integer size

The number of elements returned by the Iterable.iterator() of this stream, if the iterator terminates. In the case of an infinite stream, this operation never terminates.

Refines Sequence.size ultimately refines Iterable.size
Inherited Attributes
Attributes inherited from: Object
Attributes inherited from: Collection<Element>
Attributes inherited from: Correspondence<Key,Item>
Attributes inherited from: Iterable<Element,Absent>
Attributes inherited from: List<Element>
Attributes inherited from: [Element+]
Attributes inherited from: Element[]
Methods
cloneSource Codeshared actual [Element+] clone()

A shallow copy of this collection, that is, a collection with identical elements which does not change if this collection changes. If this collection is immutable, it is acceptable to return a reference to this collection. If this collection is mutable, a newly instantiated collection must be returned.

Refines Sequence.clone ultimately refines Collection.clone
collectSource Codeshared actual default [Result+] collect<Result>(Result collecting(Element element))

Produce a new sequence containing the results of applying the given mapping to the elements of this stream.

This operation is an eager counterpart to Iterable.map(). For any stream it, and mapping f:

it.collect(f) == [*it.map(f)]
Parameters:
  • collecting
    • nonempty sequence = array.collect(collecting)
Refines Sequence.collect ultimately refines Iterable.collect
containsSource Codeshared actual Boolean contains(Object element)

Returns true if the given value belongs to this Category, that is, if it is an element of this Category, or false otherwise.

For most Categorys the following relationship is satisfied by every pair of elements x and y:

  • if x==y, then x in category == y in category

However, it is possible to form a useful Category consistent with some other equivalence relation, for example ===. Therefore implementations of contains() which do not satisfy this relationship are tolerated.

Refines Sequence.contains ultimately refines Category.contains
getFromFirstSource Codeshared actual Element? getFromFirst(Integer index)

The indexth element returned by an iterator of this stream, or null if there are fewer than index+1 elements in the stream. For a stream with an unstable iteration order, a different value might be produced each time getFromFirst(index) is called for a given integer index.

iteratorSource Codeshared actual Iterator<Element> iterator()

An iterator for the elements belonging to this stream.

measureSource Codeshared actual Element[] measure(Integer from, Integer length)

Obtain a measure containing the mapped values starting from the given starting index, with the given length. If length<=0, the resulting measure is empty.

The measure should contain the given number of elements of this stream, starting from the element at the given starting index, in the same order as they are produced by the Iterable.iterator() of the stream. In the case where the iterator would be exhausted before length elements are produced, the resulting measure contains only those elements which were produced before the iterator was exhausted, and the length of the measure is less then the given length.

When the given index does not belong to this ranged object, the behavior is implementation dependent.

Refines Sequence.measure ultimately refines Ranged.measure
sortSource Codeshared actual [Element+] sort(Comparison comparing(Element x, Element y))

Produce a new sequence containing the elements of this stream, sorted according to the given comparator function imposing a partial order upon the elements of the stream.

For convenience, the functions byIncreasing() and byDecreasing() produce suitable comparator functions.

For example, this expression

"Hello World!".sort(byIncreasing(Character.lowercased))

evaluates to the sequence [ , !, d, e, H, l, l, l, o, o, r, W].

This operation is eager by nature.

Note that the toplevel function sort() may be used to sort a stream of Comparable values according to the natural order of its elements.

Parameters:
  • comparing
    • nonempty sequence = array.sort(comparing)
Refines Sequence.sort ultimately refines Iterable.sort
spanSource Codeshared actual Element[] span(Integer from, Integer to)

Obtain a span containing the elements between the two given indices.

The span should contain elements of this stream, starting from the element at the given starting index, and ending with the element at the given ending index, in the same order as they are produced by the Iterable.iterator() of the stream, except when the ending index occurs earlier than the starting index, in which case they occur in the opposite order.

When one or both of the given indices does not belong to this ranged stream, the behavior is implementation dependent.

Refines Sequence.span ultimately refines Ranged.span
spanFromSource Codeshared actual Element[] spanFrom(Integer from)

Obtain a span containing the elements between the given starting index and the last index of this ranged object.

The span should contain elements of this stream, starting from the element at the given starting index, in the same order as they are produced by the Iterable.iterator() of the stream.

When the given index does not belong to this ranged stream, the behavior is implementation dependent.

Refines Sequence.spanFrom ultimately refines Ranged.spanFrom
spanToSource Codeshared actual Element[] spanTo(Integer to)

Obtain a span containing the elements between the first index of this ranged stream and given end index.

The span should contain elements of this stream, up to the element at the given ending index, in the same order as they are produced by the Iterable.iterator() of the stream.

When the given index does not belong to this ranged stream, the behavior is implementation dependent.

Refines Sequence.spanTo ultimately refines Ranged.spanTo
Inherited Methods
Methods inherited from: Object
Methods inherited from: Category<Element>
Methods inherited from: Collection<Element>
Methods inherited from: Correspondence<Key,Item>
Methods inherited from: Iterable<Element,Absent>
Methods inherited from: List<Element>
Methods inherited from: Ranged<Index,Element,Subrange>
Methods inherited from: Element[]