"A nonempty, immutable sequence of values. The type `Sequence<Element>`, may be abbreviated `[Element+]`. Given a possibly-empty sequence of type `[Element*]`, the `if (nonempty ...)` construct, or, alternatively, the `assert (nonempty ...)` construct, may be used to narrow to a nonempty sequence type: [Integer*] nums = ... ; if (nonempty nums) { Integer first = nums.first; Integer max = max(nums); [Integer+] squares = nums.collect((Integer i) => i**2)); [Integer+] sorted = nums.sort(byIncreasing((Integer i) => i)); } Operations like `first`, `max()`, `collect()`, and `sort()`, which polymorphically produce a nonempty or non-null output when given a nonempty input are called _emptiness-preserving_." see (`interface Empty`) by ("Gavin") shared interface Sequence<out Element> satisfies Element[] & {Element+} & Cloneable<[Element+]> { "The index of the last element of the sequence." see (`value Sequence.size`) shared actual formal Integer lastIndex; "The first element of the sequence, that is, the element with index `0`." shared actual formal Element first; "The last element of the sequence, that is, the element with index `sequence.lastIndex`." shared actual formal Element last; "Returns `false`, since every `Sequence` contains at least one element." shared actual Boolean empty => false; "Reverse this sequence, returning a new nonempty sequence." shared actual formal [Element+] reversed; "This nonempty sequence." shared default actual [Element+] sequence => this; "The rest of the sequence, without the first element." shared actual formal Element[] rest; "A nonempty sequence containing the elements of this container, sorted according to a function imposing a partial order upon the elements." shared default actual [Element+] sort( "The function comparing pairs of elements." Comparison comparing(Element x, Element y)) { value s = internalSort(comparing, this); //TODO: fix internalSort() and remove this assertion assert (nonempty s); return s; } "A nonempty sequence containing the results of applying the given mapping to the elements of this sequence." shared default actual [Result+] collect<Result>( "The transformation applied to the elements." Result collecting(Element element)) { value s = map(collecting).sequence; assert (nonempty s); return s; } "This nonempty sequence." shared actual default [Element+] clone => this; shared actual default String string => (super of Sequential<Element>).string; shared actual default Boolean shorterThan(Integer length) => (super of List<Element>).shorterThan(length); shared actual default Boolean longerThan(Integer length) => (super of List<Element>).longerThan(length); shared default actual Element? findLast (Boolean selecting(Element elem)) => (super of List<Element>).findLast(selecting); shared actual default Element[] repeat(Integer times) => (super of Element[]).repeat(times); }