Indexed collections: vector, array, string, ...

In indexed.cecil:

abstract object indexed[T] isa sequence[T], table[int,T]; 
extend type indexed[`T] subtypes indexed[`S >= T]; 
method !(t@:indexed[`T], key:int): T;
method fetch(t@:indexed[`T], key:int): T; 
method do(a@:indexed[`T], c:&(T):void):void; 
method do(a1@:indexed[`T1], a2@:indexed[`T2], c:&(T1,T2):void):void; 
method do(a1@:indexed[`T1], a2@:indexed[`T2], a3@:indexed[`T3], 
c:&(T1,T2,T3):void):void;
method do(a1@:indexed[`T1], a2@:indexed[`T2], a3@:indexed[`T3],  
a4@:indexed[`T4], c:&(T1,T2,T3,T4):void):void;
method reverse_do(a@:indexed[`T], c:&(T):void):void; 
method reverse_do(a1@:indexed[`T1], a2@:indexed[`T2], 
c:&(T1,T2):void):void;
method reverse_do(a1@:indexed[`T1], a2@:indexed[`T2], a3@:indexed[`T3], 
c:&(T1,T2,T3):void):void;
method reverse_do(a1@:indexed[`T1], a2@:indexed[`T2], a3@:indexed[`T3], 
a4@:indexed[`T4], c:&(T1,T2,T3,T4):void):void;
method do_associations(a@:indexed[`T], c:&(int,T):void):void; 
method do_associations_allowing_updates(a@:indexed[`T], c:&(int,T):void):void; 
method includes_key(a@:indexed[`T], key:int):bool; 
method keys(t@:indexed[`T]):interval; 
method ||(s1@:indexed[`T], s2@:indexed[`T]):indexed[T];

   Indexed collections are indexed sequences. They support the behavior of keyed tables, where the integers from 0 to c.length-1 serve as the keys. Indexed collections inherit: length, is_empty, do, pick_any, includes, find, copy, etc., from collections; pair_do, reverse_do, flatten, ||, etc., from sequences; fetch, !, do_associations, keys_do, etc., from tables.

Currently, none of the _allowing_updates iterators work for indexed collections.

method includes_index(a@:indexed[`T], i:int):bool; 
method find_index(a@:indexed[`T <= comparable[T]], value:T):int; 
method find_index(a@:indexed[`T <= comparable[T]], value:T, 
if_absent:&():int):int;
method elems_print_string(c@:indexed[`T]):string; 
method elems_print(c@:indexed[`T]):void; 
method =(c1@:indexed[`T <= comparable[T]], c2@:indexed[T]):bool; 
method <(c1@:indexed[`T <= ordered[T]], c2@:indexed[T]):bool;
method <=(c1@:indexed[`T <= ordered[T]], c2@:indexed[T]):bool;
signature copy(indexed[`T]):indexed[T]; 

   The includes_index and find_index methods are simply renamings of the standard includes_key and find_key methods.

abstract object i_indexed[T] isa indexed[T], i_table[int,T]; 
extend type i_indexed[`T] subtypes i_indexed[`S >= T]; 
abstract object m_indexed[T] isa indexed[T], m_table[int,T]; 
method do_associations_allowing_updates(a@:m_indexed[`T], 
c:&(int,T):void):void;
method as_m_indexed(t@:m_indexed[`T]):m_indexed[T]; 
signature copy(m_indexed[`T]):m_indexed[T]; 

As usual, there are immutable and mutable varieties of indexed collections. Mutable collections support changing bindings of indices to values through the store or set_! methods inherited from m_table.

method set_first (a@:m_indexed[`T], x:T):void; 
method set_second(a@:m_indexed[`T], x:T):void; 
method set_third (a@:m_indexed[`T], x:T):void; 
method set_fourth(a@:m_indexed[`T], x:T):void; 
method set_last (a@:m_indexed[`T], x:T):void; 

There are convenient ways of assigning into the beginning and end of a collection. They can be invoked using the assignment message sugar, e.g., first(c) := x.

method swap(c@:m_indexed[`T], i:int, j:int):void; 

The swap method exchanges the indices of two collection elements.

method sort(c@:m_indexed[`T <= ordered[T]]):void; 
method sort_by(c@:m_indexed[`T], pred:&(T,T):bool):void; 
method sort_by(c@:m_indexed[`T], pred:&(T,T):bool, 
first_index:int, last_index:int):void;

The sort method sorts a collection in place, using either the element type's natural comparison operation ( <=) or a user-supplied comparator function. Sorting uses the quicksort algorithm and attempts to be a reasonably stable sort.

method pos(s1:indexed[`T <= comparable[T]], s2@:indexed[T]):int; 
method pos(s1@:indexed[`T <= comparable[T]], s2@:indexed[T], 
if_fail:&():int):int;
method has_subsequence(s1@:indexed[`T <= comparable[T]], s2@:indexed[T]):bool; 
method count_subsequences(s1@:indexed[`T <= comparable[T]], 
s2@:indexed[T]):int;

The pos method returns the index at which the first collection occurs in the second collection (invoking the if_absent closure if not found), using the Knuth-Morris-Pratt string-matching algorithm. The has_subsequence method returns whether the second collection is found in the first collection, and the count_subsequences method returns the number of non-overlapping occurrences of the second collection in the first. [Note that the order of collection arguments in pos is opposite to that in the subsequence methods!]