"A possibly-empty, immutable sequence of values. The type 
 `Sequential<Element>` may be abbreviated `[Element*]` or 
 `Element[]`. 
 
 `Sequential` has two enumerated subtypes:
 
 - [[Empty]], abbreviated `[]`, represents an empty 
   sequence, and
 - [[Sequence]]`<Element>`, abbreviated `[Element+]` 
   represents a non-empty sequence, and has the very 
   important subclass [[Tuple]]."​
​see (`class Tuple`)
​tagged("Sequences")
​shared interface Sequential<out Element=Anything>
        of []|[Element+]
        satisfies List<Element> & 
                  Ranged<Integer,Element,Element[]> {
    
    "The strictly-positive length of this sequence, that is, 
     the number of elements in this sequence."​
    shared actual formal Integer size;
    
    "A sequence containing all indexes of this sequence,
     that is, every index in the range `0:sequence.size`."​
    shared actual default Integer[] keys => 0:size;
    
    "This sequence."​
    shared actual default [Element+]|[] sequence() 
            => this of [Element+]|[];
    
    "The rest of the sequence, without the first element."​
    shared actual formal Element[] rest;
    
    "This sequence, without the last element."​
    since("1.3.3")
    shared actual formal Element[] exceptLast;
    
    "A subsequence of this sequence, starting at the element 
     with index [[from]], ending at the element with the 
     index [[to]]."​
    since("1.3.3")
    shared actual formal Element[] sublist(Integer from, Integer to);
    
    "A subsequence of this sequence, ending at the element 
     with the given [[index|to]]."​
    since("1.3.3")
    shared actual formal Element[] sublistTo(Integer to);
    
    "A subsequence of this sequence, starting at the element 
     with the given [[index|from]]."​
    since("1.3.3")
    shared actual formal Element[] sublistFrom(Integer from);
    
    "A sequence containing the elements of this sequence in
     reverse order to the order in which they occur in this
     sequence, or the [[empty sequence|empty]] if this
     sequence is the empty sequence."​
    shared actual formal Element[] reversed;
    
    "Produces a sequence formed by repeating the elements of
     this sequence the given [[number of times|times]], or
     the [[empty sequence|empty]] if `times<=0` or if this
     sequence is the empty sequence."​
    shared actual formal Element[] repeat(Integer times);
    
    "Select the first elements of this sequence, returning 
     a sequence no longer than the given length. If this 
     sequence is shorter than the given length, return this 
     sequence. Otherwise return a sequence of the given 
     length. If `length<=0` return an [[Empty]] sequence."​
    shared actual default Element[] initial(Integer length)
            => this[...length-1];
    
    "Select the last elements of the sequence, returning a 
     sequence no longer than the given length. If this 
     sequence is shorter than the given length, return this 
     sequence. Otherwise return a sequence of the given 
     length."​
    shared actual default Element[] terminal(Integer length)
            => this[size-length...]; 
    
    "This sequence."​
    shared actual default Element[] clone() => this;
    
    "Trim the elements satisfying the given predicate
     function from the start and end of this sequence, 
     returning a sequence no longer than this sequence."​
    shared actual default 
    Element[] trim(
        "The predicate function that determines if an 
         element at the start or end of this sequence should
         be trimmed"​
        Boolean trimming(Element&Object element))
            => super.trim(trimming).sequence(); //TODO: inefficient?​
    
    "Trim the elements satisfying the given predicate
     function from the start of this sequence, returning 
     a sequence no longer than this sequence."​
    shared actual default 
    Element[] trimLeading(
        "The predicate function that determines if an 
         element at the start of this sequence should be 
         trimmed"​
        Boolean trimming(Element&Object element))
            => super.trimLeading(trimming).sequence(); //TODO: inefficient?​
    
    "Trim the elements satisfying the given predicate
     function from the end of this sequence, returning a 
     sequence no longer than this sequence."​
    shared actual default 
    Element[] trimTrailing(
        "The predicate function that determines if an 
         element at the end of this sequence should be 
         trimmed"​
        Boolean trimming(Element&Object element))
            => super.trimTrailing(trimming).sequence(); //TODO: inefficient?​
    
    "Return two sequences, the first containing the elements
     that occur before the given [[index]], the second with
     the elements that occur after the given `index`. If the
     given `index` is outside the range of indices of this
     list, one of the returned sequences will be empty."​
    shared actual default 
    Element[][2] slice(Integer index)
            => [this[...index-1], this[index...]];
    
    "Returns a new sequence that starts with the specified
     [[element]], followed by the elements of this sequence,
     in the order they occur in this sequence."​
    see (`function prepend`,
         `function withTrailing`,
         `function follow`)
    since("1.1.0")
    shared formal 
    [Other,Element*] withLeading<Other>(
        "The first element of the resulting sequence."​
        Other element);
    
    "Returns a new sequence that starts with the elements of 
     this sequence, in the order they occur in this sequence, 
     and ends with the specified [[element]]."​
    see (`function append`,
         `function withLeading`)
    since("1.1.0")
    shared formal 
    [Element|Other+] withTrailing<Other>(
        "The last element of the resulting sequence."​
        Other element);
    
    "Return a sequence containing the elements of this 
     sequence, in the order in which they occur in this 
     sequence, followed by the given [[elements]], in the 
     order in which they occur in the given sequence."​
    see (`function prepend`,
         `function withTrailing`,
         `function concatenate`,
         `function chain`)
    since("1.1.0")
    shared formal 
    [Element|Other*] append<Other>(Other[] elements);
    
    "Return a sequence containing the given [[elements]], in 
     the order in which they occur in the given sequence,
     followed by the elements of this sequence, in the order 
     in which they occur in this sequence."​
    see (`function append`,
         `function withLeading`,
         `function concatenate`)
    since("1.1.0")
    shared formal 
    [Element|Other*] prepend<Other>(Other[] elements);
    
    "A [[Tuple]] with the same elements as this sequence.
     
     This operation makes it possible to narrow this 
     sequence to a given static length, for example:
     
         assert (is String[3] bits 
                    = string.split('/'.equals)
                            .sequence()
                            .tuple);
         value [prefix, middle, postfix] = bits;"​
    since("1.3.3")
    shared formal​
    Element[] tuple();
    
    "A string of form `\"[ x, y, z ]\"` where `x`, `y`, and 
     `z` are the `string` representations of the elements of 
     this collection, as produced by the iterator of the 
     collection, or the string `\"{}\"` if this collection 
     is empty. If the collection iterator produces the value 
     `null`, the string representation contains the string 
     `\"null\"`."​
    shared actual default 
    String string 
            => empty then "[]" else "[``commaList(this)``]";
    
}
​