6.3. LINQ

The LINQ module provides query-style operations on sequences: filtering (where_), projection (select), sorting (order, order_by), deduplication (distinct), pagination (skip, take), aggregation (sum, average, aggregate), and element access (first, last).

See also Boost module for LINQ for pipe-syntax macros with underscore shorthand. See LINQ — Language-Integrated Query for a hands-on tutorial.

All functions and symbols are in “linq” module, use require to get access to it.

require daslib/linq

Example:

require daslib/linq

    [export]
    def main() {
        var src <- [iterator for (x in range(10)); x]
        var evens <- where_(src, $(x : int) : bool { return x % 2 == 0; })
        for (v in evens) {
            print("{v} ")
        }
        print("\n")
    }
    // output:
    // 0 2 4 6 8

6.3.1. Sorting data

6.3.1.1. order

order(a: array<auto(TT)>; fun: block<(v1:TT;v2:TT):bool> ): array<TT>

Sorts an array

Arguments:

  • a : array<auto(TT)>

  • fun : block<(v1:TT;v2:TT):bool>

order(arr: array<auto(TT)> ): array<TT>
order(a: iterator<auto(TT)> ): iterator<TT>
order(a: iterator<auto(TT)>; fun: block<(v1:TT;v2:TT):bool> ): iterator<TT>

6.3.1.2. order_by

order_by(a: array<auto(TT)>; key: auto ): array<TT>

Sorts an array

Arguments:

  • a : array<auto(TT)>

  • key : auto

order_by(a: iterator<auto(TT)>; key: auto ): iterator<TT>

6.3.1.3. order_by_descending

order_by_descending(a: array<auto(TT)>; key: auto ): array<TT>

Sorts an array in descending order

Arguments:

  • a : array<auto(TT)>

  • key : auto

order_by_descending(a: iterator<auto(TT)>; key: auto ): iterator<TT>
order_by_descending_inplace(buffer: array<auto(TT)>; key: auto ): auto

Sorts an array in descending order in place

Arguments:

  • buffer : array<auto(TT)>

  • key : auto

order_by_descending_to_array(a: iterator<auto(TT)>; key: auto ): array<TT>

Sorts an iterator in descending order and returns an array

Arguments:

  • a : iterator<auto(TT)>

  • key : auto

order_by_inplace(buffer: array<auto(TT)>; key: auto ): auto

Sorts an array in place

Arguments:

  • buffer : array<auto(TT)>

  • key : auto

order_by_to_array(a: iterator<auto(TT)>; key: auto ): array<TT>

Sorts an iterator and returns an array

Arguments:

  • a : iterator<auto(TT)>

  • key : auto

6.3.1.4. order_descending

order_descending(a: array<auto(TT)>; fun: block<(v1:TT;v2:TT):bool> ): array<TT>

Sorts an array in descending order

Arguments:

  • a : array<auto(TT)>

  • fun : block<(v1:TT;v2:TT):bool>

order_descending(arr: array<auto(TT)> ): array<TT>
order_descending(a: iterator<auto(TT)> ): iterator<TT>
order_descending(a: iterator<auto(TT)>; fun: block<(v1:TT;v2:TT):bool> ): iterator<TT>

6.3.1.5. order_descending_inplace

order_descending_inplace(buffer: array<auto(TT)> ): auto

Sorts an array in descending order in place

Arguments:

  • buffer : array<auto(TT)>

order_descending_inplace(buffer: array<auto(TT)>; fun: block<(v1:TT;v2:TT):bool> ): auto

6.3.1.6. order_descending_to_array

order_descending_to_array(a: iterator<auto(TT)> ): array<TT>

Sorts an iterator in descending order and returns an array

Arguments:

  • a : iterator<auto(TT)>

order_descending_to_array(a: iterator<auto(TT)>; fun: block<(v1:TT;v2:TT):bool> ): array<TT>

6.3.1.7. order_inplace

order_inplace(buffer: array<auto(TT)> ): auto

Sorts an array in place

Arguments:

  • buffer : array<auto(TT)>

order_inplace(buffer: array<auto(TT)>; fun: block<(v1:TT;v2:TT):bool> ): auto

6.3.1.8. order_to_array

order_to_array(a: iterator<auto(TT)> ): array<TT>

Sorts an iterator and returns an array

Arguments:

  • a : iterator<auto(TT)>

order_to_array(a: iterator<auto(TT)>; fun: block<(v1:TT;v2:TT):bool> ): array<TT>

6.3.1.9. order_unique_folded

order_unique_folded(a: array<auto(TT)> ): array<TT>

sort and remove duplicate elements from an array

Arguments:

  • a : array<auto(TT)>

order_unique_folded(a: iterator<auto(TT)> ): array<TT>
order_unique_folded_inplace(a: array<auto(TT)> ): auto

sort and remove duplicate elements from an array

Arguments:

  • a : array<auto(TT)>

6.3.1.10. reverse

reverse(a: array<auto(TT)> ): array<TT>

Reverses an array

Arguments:

  • a : array<auto(TT)>

reverse(a: iterator<auto(TT)> ): iterator<TT>
reverse_inplace(buffer: array<auto(TT)> ): auto

Reverses an array in place

Arguments:

  • buffer : array<auto(TT)>

reverse_to_array(a: iterator<auto(TT)> ): array<TT>

Reverses an iterator and returns an array

Arguments:

  • a : iterator<auto(TT)>

6.3.2. Top-N selection

spliced_pop_heap(buf: array<auto(TT)>; cmp: block<(x:TT;y:TT):bool> ): auto

Thin re-export of sort_boost::pop_heap for the bounded-heap splice (see spliced_push_heap).

Arguments:

  • buf : array<auto(TT)>

  • cmp : block<(x:TT;y:TT):bool>

spliced_push_heap(buf: array<auto(TT)>; cmp: block<(x:TT;y:TT):bool> ): auto

Thin re-export of sort_boost::push_heap so plan_decs_order_family’s bounded-heap splice can call it via _:: from any user module without requiring sort_boost directly.

Arguments:

  • buf : array<auto(TT)>

  • cmp : block<(x:TT;y:TT):bool>

6.3.2.1. top_n

top_n(arr: array<auto(TT)>; n: int ): array<TT>

Returns the n smallest elements of arr (by <), sorted ascending.

Arguments:

  • arr : array<auto(TT)>

  • n : int

top_n(a: iterator<auto(TT)>; n: int ): array<TT>

6.3.2.2. top_n_by

top_n_by(arr: array<auto(TT)>; n: int; key: auto ): array<TT>

Returns the n smallest elements of arr by key(element), sorted ascending. n <= 0 or empty arr yields an empty result.

Arguments:

  • arr : array<auto(TT)>

  • n : int

  • key : auto

top_n_by(a: iterator<auto(TT)>; n: int; key: auto ): array<TT>

6.3.2.3. top_n_by_descending

top_n_by_descending(arr: array<auto(TT)>; n: int; key: auto ): array<TT>

Returns the n largest elements of arr by key(element), sorted descending. n <= 0 or empty arr yields an empty result.

Arguments:

  • arr : array<auto(TT)>

  • n : int

  • key : auto

top_n_by_descending(a: iterator<auto(TT)>; n: int; key: auto ): array<TT>

6.3.2.4. top_n_by_with_cmp

top_n_by_with_cmp(arr: array<auto(TT)>; n: int; cmp: block<(v1:TT;v2:TT):bool> ): array<TT>

Returns the n smallest-per-cmp elements of arr. Pass a reversed comparator to extract the n largest instead.

Arguments:

  • arr : array<auto(TT)>

  • n : int

  • cmp : block<(v1:TT;v2:TT):bool>

top_n_by_with_cmp(a: iterator<auto(TT)>; n: int; cmp: block<(v1:TT;v2:TT):bool> ): array<TT>

6.3.2.5. top_n_descending

top_n_descending(arr: array<auto(TT)>; n: int ): array<TT>

Returns the n largest elements of arr (by <), sorted descending.

Arguments:

  • arr : array<auto(TT)>

  • n : int

top_n_descending(a: iterator<auto(TT)>; n: int ): array<TT>

6.3.3. Set operations

6.3.3.1. distinct

distinct(a: array<auto(TT)> ): array<TT>

Returns distinct elements from an array

Arguments:

  • a : array<auto(TT)>

distinct(a: iterator<auto(TT)> ): iterator<TT>

6.3.3.2. distinct_by

distinct_by(a: array<auto(TT)>; key: block<(arg:TT):auto> ): array<TT>

Returns distinct elements from an array based on a key

Arguments:

  • a : array<auto(TT)>

  • key : block<(arg:TT):auto>

distinct_by(a: iterator<auto(TT)>; key: block<(arg:TT):auto> ): iterator<TT>
distinct_by_inplace(a: array<auto(TT)>; key: block<(arg:TT):auto> ): auto

Returns distinct elements from an array based on a key in place

Arguments:

  • a : array<auto(TT)>

  • key : block<(arg:TT):auto>

distinct_by_to_array(a: iterator<auto(TT)>; key: block<(arg:TT):auto> ): array<TT>

Returns distinct elements from an iterator based on a key and returns an array

Arguments:

  • a : iterator<auto(TT)>

  • key : block<(arg:TT):auto>

distinct_inplace(a: array<auto(TT)> ): auto

Returns distinct elements from an array in place

Arguments:

  • a : array<auto(TT)>

distinct_to_array(a: iterator<auto(TT)> ): array<TT>

Returns distinct elements from an iterator and returns an array

Arguments:

  • a : iterator<auto(TT)>

6.3.3.3. except

except(src: array<TT>; exclude: iterator<auto(TT) const> ): iterator<TT>

Returns elements from the array that are not in the iterator

Arguments:

  • src : array<TT>

  • exclude : iterator<auto(TT)>

except(src: array<auto(TT)>; exclude: array<auto(TT)> ): array<TT>
except(src: iterator<auto(TT) const>; exclude: array<TT> ): iterator<TT>
except(src: iterator<auto(TT)>; exclude: iterator<auto(TT)> ): iterator<TT>

6.3.3.4. except_by

except_by(src: array<TT>; exclude: iterator<auto(TT) const>; key: block<(arg:TT):auto> ): iterator<TT>

Returns elements from the array that are not in the iterator by key

Arguments:

  • src : array<TT>

  • exclude : iterator<auto(TT)>

  • key : block<(arg:TT):auto>

except_by(src: array<auto(TT)>; exclude: array<auto(TT)>; key: block<(arg:TT):auto> ): array<TT>
except_by(src: iterator<auto(TT) const>; exclude: array<TT>; key: block<(arg:TT):auto> ): iterator<TT>
except_by(src: iterator<auto(TT)>; exclude: iterator<auto(TT)>; key: block<(arg:TT):auto> ): iterator<TT>

6.3.3.5. except_by_to_array

except_by_to_array(src: array<TT>; exclude: iterator<auto(TT) const>; key: block<(arg:TT):auto> ): array<TT>

Elements from an array (left) not present in an iterator (right) by key, returning an array

Arguments:

  • src : array<TT>

  • exclude : iterator<auto(TT)>

  • key : block<(arg:TT):auto>

except_by_to_array(src: iterator<auto(TT) const>; exclude: array<TT>; key: block<(arg:TT):auto> ): array<TT>
except_by_to_array(src: iterator<auto(TT)>; exclude: iterator<auto(TT)>; key: block<(arg:TT):auto> ): array<TT>

6.3.3.6. except_to_array

except_to_array(src: array<TT>; exclude: iterator<auto(TT) const> ): array<TT>

Elements from an array (left) not present in an iterator (right), returning an array

Arguments:

  • src : array<TT>

  • exclude : iterator<auto(TT)>

except_to_array(src: iterator<auto(TT) const>; exclude: array<TT> ): array<TT>
except_to_array(src: iterator<auto(TT)>; exclude: iterator<auto(TT)> ): array<TT>

6.3.3.7. intersect

intersect(srca: array<TT>; srcb: iterator<auto(TT) const> ): iterator<TT>

Returns elements that are present in both an array and an iterator

Arguments:

  • srca : array<TT>

  • srcb : iterator<auto(TT)>

intersect(srca: array<auto(TT)>; srcb: array<auto(TT)> ): array<TT>
intersect(srca: iterator<auto(TT) const>; srcb: array<TT> ): iterator<TT>
intersect(srca: iterator<auto(TT)>; srcb: iterator<auto(TT)> ): iterator<TT>

6.3.3.8. intersect_by

intersect_by(srca: array<TT>; srcb: iterator<auto(TT) const>; key: block<(arg:TT):auto> ): iterator<TT>

Returns elements present in both an array and an iterator by key

Arguments:

  • srca : array<TT>

  • srcb : iterator<auto(TT)>

  • key : block<(arg:TT):auto>

intersect_by(srca: array<auto(TT)>; srcb: array<auto(TT)>; key: block<(arg:TT):auto> ): array<TT>
intersect_by(srca: iterator<auto(TT) const>; srcb: array<TT>; key: block<(arg:TT):auto> ): iterator<TT>
intersect_by(srca: iterator<auto(TT)>; srcb: iterator<auto(TT)>; key: block<(arg:TT):auto> ): iterator<TT>

6.3.3.9. intersect_by_to_array

intersect_by_to_array(srca: array<TT>; srcb: iterator<auto(TT) const>; key: block<(arg:TT):auto> ): array<TT>

Elements present in both an array and an iterator by key, returning an array

Arguments:

  • srca : array<TT>

  • srcb : iterator<auto(TT)>

  • key : block<(arg:TT):auto>

intersect_by_to_array(srca: iterator<auto(TT) const>; srcb: array<TT>; key: block<(arg:TT):auto> ): array<TT>
intersect_by_to_array(srca: iterator<auto(TT)>; srcb: iterator<auto(TT)>; key: block<(arg:TT):auto> ): array<TT>

6.3.3.10. intersect_to_array

intersect_to_array(srca: array<TT>; srcb: iterator<auto(TT) const> ): array<TT>

Elements present in both an array and an iterator, returning an array

Arguments:

  • srca : array<TT>

  • srcb : iterator<auto(TT)>

intersect_to_array(srca: iterator<auto(TT) const>; srcb: array<TT> ): array<TT>
intersect_to_array(srca: iterator<auto(TT)>; srcb: iterator<auto(TT)> ): array<TT>

6.3.3.11. union

union(srca: array<TT>; srcb: iterator<auto(TT) const> ): iterator<TT>

Returns distinct elements from the concatenation of an array and an iterator

Arguments:

  • srca : array<TT>

  • srcb : iterator<auto(TT)>

union(srca: array<auto(TT)>; srcb: array<auto(TT)> ): array<TT>
union(srca: iterator<auto(TT) const>; srcb: array<TT> ): iterator<TT>
union(srca: iterator<auto(TT)>; srcb: iterator<auto(TT)> ): iterator<TT>

6.3.3.12. union_by

union_by(srca: array<TT>; srcb: iterator<auto(TT) const>; key: block<(arg:TT):auto> ): iterator<TT>

Returns distinct elements from the concatenation of an array and an iterator by key

Arguments:

  • srca : array<TT>

  • srcb : iterator<auto(TT)>

  • key : block<(arg:TT):auto>

union_by(srca: array<auto(TT)>; srcb: array<auto(TT)>; key: block<(arg:TT):auto> ): array<TT>
union_by(srca: iterator<auto(TT) const>; srcb: array<TT>; key: block<(arg:TT):auto> ): iterator<TT>
union_by(srca: iterator<auto(TT)>; srcb: iterator<auto(TT)>; key: block<(arg:TT):auto> ): iterator<TT>

6.3.3.13. union_by_to_array

union_by_to_array(srca: array<TT>; srcb: iterator<auto(TT) const>; key: block<(arg:TT):auto> ): array<TT>

Distinct elements from the concatenation of an array and an iterator by key, returning an array

Arguments:

  • srca : array<TT>

  • srcb : iterator<auto(TT)>

  • key : block<(arg:TT):auto>

union_by_to_array(srca: iterator<auto(TT) const>; srcb: array<TT>; key: block<(arg:TT):auto> ): array<TT>
union_by_to_array(srca: iterator<auto(TT)>; srcb: iterator<auto(TT)>; key: block<(arg:TT):auto> ): array<TT>

6.3.3.14. union_to_array

union_to_array(srca: array<TT>; srcb: iterator<auto(TT) const> ): array<TT>

Distinct elements from the concatenation of an array and an iterator, returning an array

Arguments:

  • srca : array<TT>

  • srcb : iterator<auto(TT)>

union_to_array(srca: iterator<auto(TT) const>; srcb: array<TT> ): array<TT>
union_to_array(srca: iterator<auto(TT)>; srcb: iterator<auto(TT)> ): array<TT>

6.3.3.15. unique

unique(a: array<auto(TT)> ): array<TT>

sort and remove duplicate elements from an array

Arguments:

  • a : array<auto(TT)>

unique(a: iterator<auto(TT)> ): iterator<TT>

6.3.3.16. unique_by

unique_by(a: array<auto(TT)>; key: block<(arg:TT):auto> ): array<TT>

sort and remove duplicate elements from an array based on a key

Arguments:

  • a : array<auto(TT)>

  • key : block<(arg:TT):auto>

unique_by(a: iterator<auto(TT)>; key: block<(arg:TT):auto> ): iterator<TT>
unique_by_inplace(a: array<auto(TT)>; key: block<(arg:TT):auto> ): auto

remove duplicate elements from an array based on a key in place

Arguments:

  • a : array<auto(TT)>

  • key : block<(arg:TT):auto>

unique_by_to_array(a: iterator<auto(TT)>; key: block<(arg:TT):auto> ): array<TT>

sort and remove duplicate elements from an iterator based on a key and returns an array

Arguments:

  • a : iterator<auto(TT)>

  • key : block<(arg:TT):auto>

unique_inplace(a: array<auto(TT)> ): auto

remove duplicate elements from sorted array in place

Arguments:

  • a : array<auto(TT)>

unique_key(a: auto ): auto

generates unique key of workhorse type for the value

Arguments:

  • a : auto

unique_to_array(a: iterator<auto(TT)> ): array<TT>

sort and remove duplicate elements from an iterator and returns an array

Arguments:

  • a : iterator<auto(TT)>

6.3.4. Concatenation operations

6.3.4.1. append

append(arr: array<auto(TT)>; value: TT ): array<TT>

Appends a value to the end of an array

Arguments:

  • arr : array<auto(TT)>

  • value : TT

append(it: iterator<auto(TT)>; value: TT ): iterator<TT>
append_inplace(arr: array<auto(TT)>; value: TT ): auto

Appends a value to the end of an array in place

Arguments:

  • arr : array<auto(TT)>

  • value : TT

append_to_array(it: iterator<auto(TT)>; value: TT ): array<TT>

Appends a value to the end of an iterator and returns an array

Arguments:

  • it : iterator<auto(TT)>

  • value : TT

6.3.4.2. concat

concat(a: array<TT>; b: iterator<auto(TT) const> ): iterator<TT>

Concatenates an array and an iterator. Materializes eagerly (unlike the lazy iterator+iterator form).

Arguments:

  • a : array<TT>

  • b : iterator<auto(TT)>

concat(a: array<auto(TT)>; b: array<auto(TT)> ): array<TT>
concat(a: iterator<auto(TT) const>; b: array<TT> ): iterator<TT>
concat(a: iterator<auto(TT)>; b: iterator<auto(TT)> ): iterator<TT>
concat_inplace(a: array<auto(TT)>; b: array<auto(TT)> ): auto

Concatenates two arrays in place

Arguments:

  • a : array<auto(TT)>

  • b : array<auto(TT)>

6.3.4.3. concat_to_array

concat_to_array(a: array<TT>; b: iterator<auto(TT) const> ): array<TT>

Concatenates an array and an iterator, returning an array

Arguments:

  • a : array<TT>

  • b : iterator<auto(TT)>

concat_to_array(a: iterator<auto(TT) const>; b: array<TT> ): array<TT>
concat_to_array(a: iterator<auto(TT)>; b: iterator<auto(TT)> ): array<TT>

6.3.4.4. prepend

prepend(arr: array<auto(TT)>; value: TT ): array<TT>

Prepends a value to the beginning of an array

Arguments:

  • arr : array<auto(TT)>

  • value : TT

prepend(it: iterator<auto(TT)>; value: TT ): iterator<TT>
prepend_inplace(arr: array<auto(TT)>; value: TT ): auto

Prepends a value to the beginning of an array in place

Arguments:

  • arr : array<auto(TT)>

  • value : TT

prepend_to_array(it: iterator<auto(TT)>; value: TT ): array<TT>

Prepends a value to the beginning of an iterator and returns an array

Arguments:

  • it : iterator<auto(TT)>

  • value : TT

6.3.5. Generation operations

default_empty(src: iterator<auto(TT)> ): iterator<TT>

Returns the elements of the iterator, or a default value if the iterator is empty

Arguments:

  • src : iterator<auto(TT)>

empty(typ: auto(TT) ): iterator<TT>

Returns an empty iterator of the specified type

Arguments:

  • typ : auto(TT)

range_sequence(start: int; count: int ): iterator<int>

Generates a sequence of integers within a specified range

Arguments:

  • start : int

  • count : int

repeat(element: auto(TT); count: int ): iterator<TT>

Generates a sequence that contains one repeated value

Arguments:

  • element : auto(TT)

  • count : int

6.3.6. Aggregation operations

6.3.6.1. aggregate

aggregate(src: array<auto(TT)>; seed: auto(AGG); func: block<(acc:AGG;x:TT):AGG> ): AGG

Aggregates elements in an array using a seed and a function

Arguments:

  • src : array<auto(TT)>

  • seed : auto(AGG)

  • func : block<(acc:AGG;x:TT):AGG>

aggregate(src: iterator<auto(TT)>; seed: auto(AGG); func: block<(acc:AGG;x:TT):AGG> ): AGG

6.3.6.2. average

average(src: array<auto(TT)> ): double

Averages elements in an array. Always returns double (matches SQL AVG / C# Average); element type must cast to double.

Arguments:

  • src : array<auto(TT)>

average(src: iterator<auto(TT)> ): double

6.3.6.3. count

count(a: array<auto(TT)> ): int

Counts elements in an array

Arguments:

  • a : array<auto(TT)>

count(a: array<auto(TT)>; predicate: block<(arg:TT):bool> ): int
count(a: iterator<auto(TT)> ): int
count(a: iterator<auto(TT)>; predicate: block<(arg:TT):bool> ): int

6.3.6.4. long_count

long_count(a: array<auto(TT)> ): int64

Counts elements in an array, using a long integer

Arguments:

  • a : array<auto(TT)>

long_count(a: array<auto(TT)>; predicate: block<(arg:TT):bool> ): int64
long_count(a: iterator<auto(TT)> ): int64
long_count(a: iterator<auto(TT)>; predicate: block<(arg:TT):bool> ): int64

6.3.6.5. max

max(src: array<auto(TT)> ): TT

Finds the maximum element in an array

Arguments:

  • src : array<auto(TT)>

max(src: iterator<auto(TT)> ): TT

6.3.6.6. max_by

max_by(src: array<auto(TT)>; key: auto ): TT

Finds the maximum element in an array by key

Arguments:

  • src : array<auto(TT)>

  • key : auto

max_by(src: iterator<auto(TT)>; key: auto ): TT

6.3.6.7. min

min(src: array<auto(TT)> ): TT

Finds the minimum element in an array

Arguments:

  • src : array<auto(TT)>

min(src: iterator<auto(TT)> ): TT

6.3.6.8. min_by

min_by(src: array<auto(TT)>; key: auto ): TT

Finds the minimum element in an array by key

Arguments:

  • src : array<auto(TT)>

  • key : auto

min_by(src: iterator<auto(TT)>; key: auto ): TT

6.3.6.9. min_max

min_max(src: array<auto(TT)> ): tuple<TT;TT>

Finds the minimum and maximum elements in an array

Arguments:

  • src : array<auto(TT)>

min_max(src: iterator<auto(TT)> ): tuple<TT;TT>

6.3.6.10. min_max_average

min_max_average(src: array<auto(TT)> ): tuple<TT;TT;TT>

Finds the minimum, maximum, and average elements in an array

Arguments:

  • src : array<auto(TT)>

min_max_average(src: iterator<auto(TT)> ): tuple<TT;TT;TT>

6.3.6.11. min_max_average_by

min_max_average_by(src: array<auto(TT)>; key: auto ): tuple<TT;TT;TT>

Finds the minimum, maximum, and average elements in an array by key

Arguments:

  • src : array<auto(TT)>

  • key : auto

min_max_average_by(src: iterator<auto(TT)>; key: auto ): tuple<TT;TT;TT>

6.3.6.12. min_max_by

min_max_by(src: array<auto(TT)>; key: auto ): tuple<TT;TT>

Finds the minimum and maximum elements in an array by key

Arguments:

  • src : array<auto(TT)>

  • key : auto

min_max_by(src: iterator<auto(TT)>; key: auto ): tuple<TT;TT>

6.3.6.13. sum

sum(src: array<auto(TT)> ): TT

Sums elements in an array

Arguments:

  • src : array<auto(TT)>

sum(src: iterator<auto(TT)> ): TT

6.3.7. Filtering data

6.3.7.1. where

where_(src: array<auto(TT)>; predicate: block<(arg:TT):bool> ): array<TT>

Filters elements in an array based on a predicate

Arguments:

  • src : array<auto(TT)>

  • predicate : block<(arg:TT):bool>

where_(src: iterator<auto(TT)>; predicate: block<(arg:TT):bool> ): iterator<TT>
where_to_array(src: iterator<auto(TT)>; predicate: block<(arg:TT):bool> ): array<TT>

Filters elements in an iterator based on a predicate and returns an array

Arguments:

  • src : iterator<auto(TT)>

  • predicate : block<(arg:TT):bool>

6.3.8. Partitioning data

6.3.8.1. chunk

chunk(src: array<auto(TT)>; size: int ): array<array<TT>>

Splits an array into chunks of a specified size

Arguments:

  • src : array<auto(TT)>

  • size : int

chunk(src: iterator<auto(TT)>; size: int ): iterator<array<TT>>
chunk_to_array(src: iterator<auto(TT)>; size: int ): array<array<TT>>

Splits an iterator into chunks of a specified size and returns an array

Arguments:

  • src : iterator<auto(TT)>

  • size : int

6.3.8.2. skip

skip(arr: array<auto(TT)>; total: int ): array<TT>

Yields all but the first total elements

Arguments:

  • arr : array<auto(TT)>

  • total : int

skip(src: iterator<auto(TT)>; total: int ): iterator<TT>
skip_inplace(arr: array<auto(TT)>; total: int ): auto

Removes the first total elements from an array in place

Arguments:

  • arr : array<auto(TT)>

  • total : int

6.3.8.3. skip_last

skip_last(arr: array<auto(TT)>; total: int ): array<TT>

Yields all but the last total elements from an array

Arguments:

  • arr : array<auto(TT)>

  • total : int

skip_last(src: iterator<auto(TT)>; total: int ): iterator<TT>
skip_last_inplace(arr: array<auto(TT)>; total: int ): auto

Removes the last total elements from an array in place

Arguments:

  • arr : array<auto(TT)>

  • total : int

skip_last_to_array(src: iterator<auto(TT)>; total: int ): array<TT>

Yields all but the last total elements from an iterator and returns an array

Arguments:

  • src : iterator<auto(TT)>

  • total : int

skip_to_array(src: iterator<auto(TT)>; total: int ): array<TT>

Yields all but the first total elements and returns an array

Arguments:

  • src : iterator<auto(TT)>

  • total : int

6.3.8.4. skip_while

skip_while(src: array<auto(TT)>; predicate: block<(arg:TT):bool> ): array<TT>

Skips all elements of an array while the predicate is true

Arguments:

  • src : array<auto(TT)>

  • predicate : block<(arg:TT):bool>

skip_while(src: iterator<auto(TT)>; predicate: block<(arg:TT):bool> ): iterator<TT>
skip_while_to_array(src: iterator<auto(TT)>; predicate: block<(arg:TT):bool> ): array<TT>

Skips all elements of an iterator while the predicate is true and returns an array

Arguments:

  • src : iterator<auto(TT)>

  • predicate : block<(arg:TT):bool>

6.3.8.5. take

take(arr: array<auto(TT)>; total: int ): array<TT>

Yields only the first total elements

Arguments:

  • arr : array<auto(TT)>

  • total : int

take(src: array<auto(TT)>; from: range ): array<TT>
take(src: iterator<auto(TT)>; from: range ): iterator<TT>
take(src: iterator<auto(TT)>; total: int ): iterator<TT>

6.3.8.6. take_inplace

take_inplace(arr: array<auto(TT)>; from: range ): auto

Keeps only a range of elements in an array in place

Arguments:

  • arr : array<auto(TT)>

  • from : range

take_inplace(arr: array<auto(TT)>; total: int ): auto

6.3.8.7. take_last

take_last(arr: array<auto(TT)>; total: int ): array<TT>

Yields only the last total elements from an array

Arguments:

  • arr : array<auto(TT)>

  • total : int

take_last(src: iterator<auto(TT)>; total: int ): iterator<TT>
take_last_inplace(arr: array<auto(TT)>; total: int ): auto

Keeps only the last total elements in an array in place

Arguments:

  • arr : array<auto(TT)>

  • total : int

take_last_to_array(src: iterator<auto(TT)>; total: int ): array<TT>

Yields only the last total elements from an iterator and returns an array

Arguments:

  • src : iterator<auto(TT)>

  • total : int

6.3.8.8. take_to_array

take_to_array(src: iterator<auto(TT)>; from: range ): array<TT>

Yields a range of elements from an iterator and returns an array

Arguments:

  • src : iterator<auto(TT)>

  • from : range

take_to_array(src: iterator<auto(TT)>; total: int ): array<TT>

6.3.8.9. take_while

take_while(src: array<auto(TT)>; predicate: block<(arg:TT):bool> ): array<TT>

Yields only the elements of an array while the predicate is true

Arguments:

  • src : array<auto(TT)>

  • predicate : block<(arg:TT):bool>

take_while(src: iterator<auto(TT)>; predicate: block<(arg:TT):bool> ): iterator<TT>
take_while_to_array(src: iterator<auto(TT)>; predicate: block<(arg:TT):bool> ): array<TT>

Yields only the elements of an iterator while the predicate is true and returns an array

Arguments:

  • src : iterator<auto(TT)>

  • predicate : block<(arg:TT):bool>

6.3.9. Joining

6.3.9.1. cross_join

cross_join(srca: array<auto(TA)>; srcb: array<auto(TB)>; result: auto) : array<typedecl(result(type<TA>,type<TB>) )>

Cross join — every (TA, TB) pair

Arguments:

  • srca : array<auto(TA)>

  • srcb : array<auto(TB)>

  • result : auto

cross_join(srca: array<auto(TA)>; srcb: iterator<auto(TB) const>; result: auto) : iterator<typedecl(result(type<TA>,type<TB>) )>
cross_join(srca: iterator<auto(TA) const>; srcb: array<auto(TB)>; result: auto) : iterator<typedecl(result(type<TA>,type<TB>) )>
cross_join(srca: iterator<auto(TA)>; srcb: iterator<auto(TB)>; result: auto) : iterator<typedecl(result(type<TA>,type<TB>) )>

6.3.9.2. cross_join_to_array

cross_join_to_array(srca: array<auto(TA)>; srcb: iterator<auto(TB) const>; result: auto) : array<typedecl(result(type<TA>,type<TB>) )>

Cross join of an array (left) and an iterator (right), returning an array. The iterator is materialized first (cross re-iterates the right side per left row).

Arguments:

  • srca : array<auto(TA)>

  • srcb : iterator<auto(TB)>

  • result : auto

cross_join_to_array(srca: iterator<auto(TA) const>; srcb: array<auto(TB)>; result: auto) : array<typedecl(result(type<TA>,type<TB>) )>
cross_join_to_array(srca: iterator<auto(TA)>; srcb: iterator<auto(TB)>; result: auto) : array<typedecl(result(type<TA>,type<TB>) )>

6.3.9.3. full_outer_join

full_outer_join(srca: array<auto(TA)>; srcb: array<auto(TB)>; keya: auto; keyb: auto; result: auto) : array<typedecl(result(type<$Option(type<TA -const -&>)>"Option"type<TA -const -&>,type<$Option(type<TB -const -&>)>"Option"type<TB -const -&>) )>

Full outer join — both sides surface; unmatched rows pair with none on the other side

Arguments:

  • srca : array<auto(TA)>

  • srcb : array<auto(TB)>

  • keya : auto

  • keyb : auto

  • result : auto

full_outer_join(srca: array<auto(TA)>; srcb: iterator<auto(TB) const>; keya: auto; keyb: auto; result: auto) : iterator<typedecl(result(type<$Option(type<TA -const -&>)>"Option"type<TA -const -&>,type<$Option(type<TB -const -&>)>"Option"type<TB -const -&>) )>
full_outer_join(srca: iterator<auto(TA) const>; srcb: array<auto(TB)>; keya: auto; keyb: auto; result: auto) : iterator<typedecl(result(type<$Option(type<TA -const -&>)>"Option"type<TA -const -&>,type<$Option(type<TB -const -&>)>"Option"type<TB -const -&>) )>
full_outer_join(srca: iterator<auto(TA)>; srcb: iterator<auto(TB)>; keya: auto; keyb: auto; result: auto) : iterator<typedecl(result(type<$Option(type<TA -const -&>)>"Option"type<TA -const -&>,type<$Option(type<TB -const -&>)>"Option"type<TB -const -&>) )>

6.3.9.4. full_outer_join_to_array

full_outer_join_to_array(srca: array<auto(TA)>; srcb: iterator<auto(TB) const>; keya: auto; keyb: auto; result: auto) : array<typedecl(result(type<$Option(type<TA -const -&>)>"Option"type<TA -const -&>,type<$Option(type<TB -const -&>)>"Option"type<TB -const -&>) )>

Full outer join of an array (left) and an iterator (right), returning an array

Arguments:

  • srca : array<auto(TA)>

  • srcb : iterator<auto(TB)>

  • keya : auto

  • keyb : auto

  • result : auto

full_outer_join_to_array(srca: iterator<auto(TA) const>; srcb: array<auto(TB)>; keya: auto; keyb: auto; result: auto) : array<typedecl(result(type<$Option(type<TA -const -&>)>"Option"type<TA -const -&>,type<$Option(type<TB -const -&>)>"Option"type<TB -const -&>) )>
full_outer_join_to_array(srca: iterator<auto(TA)>; srcb: iterator<auto(TB)>; keya: auto; keyb: auto; result: auto) : array<typedecl(result(type<$Option(type<TA -const -&>)>"Option"type<TA -const -&>,type<$Option(type<TB -const -&>)>"Option"type<TB -const -&>) )>

6.3.9.5. group_join

group_join(srca: array<auto(TA)>; srcb: array<auto(TB)>; keya: auto; keyb: auto; result: auto) : array<typedecl(result(type<TA>,type<array<TB -const -&>>) )>

we pass TA, and sequence of TB to ‘result’

Arguments:

  • srca : array<auto(TA)>

  • srcb : array<auto(TB)>

  • keya : auto

  • keyb : auto

  • result : auto

group_join(srca: array<auto(TA)>; srcb: iterator<auto(TB) const>; keya: auto; keyb: auto; result: auto) : iterator<typedecl(result(type<TA>,type<array<TB -const -&>>) )>
group_join(srca: iterator<auto(TA) const>; srcb: array<auto(TB)>; keya: auto; keyb: auto; result: auto) : iterator<typedecl(result(type<TA>,type<array<TB -const -&>>) )>
group_join(srca: iterator<auto(TA)>; srcb: iterator<auto(TB)>; keya: auto; keyb: auto; result: auto) : iterator<typedecl(result(type<TA>,type<array<TB -const -&>>) )>

6.3.9.6. group_join_to_array

group_join_to_array(srca: array<auto(TA)>; srcb: iterator<auto(TB) const>; keya: auto; keyb: auto; result: auto) : array<typedecl(result(type<TA>,type<array<TB -const -&>>) )>

Group join of an array (left) and an iterator (right), returning an array

Arguments:

  • srca : array<auto(TA)>

  • srcb : iterator<auto(TB)>

  • keya : auto

  • keyb : auto

  • result : auto

group_join_to_array(srca: iterator<auto(TA) const>; srcb: array<auto(TB)>; keya: auto; keyb: auto; result: auto) : array<typedecl(result(type<TA>,type<array<TB -const -&>>) )>
group_join_to_array(srca: iterator<auto(TA)>; srcb: iterator<auto(TB)>; keya: auto; keyb: auto; result: auto) : array<typedecl(result(type<TA>,type<array<TB -const -&>>) )>

6.3.9.7. join

join(srca: array<auto(TA)>; srcb: array<auto(TB)>; keya: auto; keyb: auto; result: auto) : array<typedecl(result(type<TA>,type<TB>) )>

Joins two arrays based on matching keys (inner join)

Arguments:

  • srca : array<auto(TA)>

  • srcb : array<auto(TB)>

  • keya : auto

  • keyb : auto

  • result : auto

join(srca: array<auto(TA)>; srcb: iterator<auto(TB) const>; keya: auto; keyb: auto; result: auto) : iterator<typedecl(result(type<TA>,type<TB>) )>
join(srca: iterator<auto(TA) const>; srcb: array<auto(TB)>; keya: auto; keyb: auto; result: auto) : iterator<typedecl(result(type<TA>,type<TB>) )>
join(srca: iterator<auto(TA)>; srcb: iterator<auto(TB)>; keya: auto; keyb: auto; result: auto) : iterator<typedecl(result(type<TA>,type<TB>) )>

6.3.9.8. join_to_array

join_to_array(srca: array<auto(TA)>; srcb: iterator<auto(TB) const>; keya: auto; keyb: auto; result: auto) : array<typedecl(result(type<TA>,type<TB>) )>

Inner join of an array (left) and an iterator (right), returning an array

Arguments:

  • srca : array<auto(TA)>

  • srcb : iterator<auto(TB)>

  • keya : auto

  • keyb : auto

  • result : auto

join_to_array(srca: iterator<auto(TA) const>; srcb: array<auto(TB)>; keya: auto; keyb: auto; result: auto) : array<typedecl(result(type<TA>,type<TB>) )>
join_to_array(srca: iterator<auto(TA)>; srcb: iterator<auto(TB)>; keya: auto; keyb: auto; result: auto) : array<typedecl(result(type<TA>,type<TB>) )>

6.3.9.9. left_join

left_join(srca: array<auto(TA)>; srcb: array<auto(TB)>; keya: auto; keyb: auto; result: auto) : array<typedecl(result(type<TA>,type<$Option(type<TB -const -&>)>"Option"type<TB -const -&>) )>

Left outer join — every TA emits at least one row; right side is Option<TB> (none when no match)

Arguments:

  • srca : array<auto(TA)>

  • srcb : array<auto(TB)>

  • keya : auto

  • keyb : auto

  • result : auto

left_join(srca: array<auto(TA)>; srcb: iterator<auto(TB) const>; keya: auto; keyb: auto; result: auto) : iterator<typedecl(result(type<TA>,type<$Option(type<TB -const -&>)>"Option"type<TB -const -&>) )>
left_join(srca: iterator<auto(TA) const>; srcb: array<auto(TB)>; keya: auto; keyb: auto; result: auto) : iterator<typedecl(result(type<TA>,type<$Option(type<TB -const -&>)>"Option"type<TB -const -&>) )>
left_join(srca: iterator<auto(TA)>; srcb: iterator<auto(TB)>; keya: auto; keyb: auto; result: auto) : iterator<typedecl(result(type<TA>,type<$Option(type<TB -const -&>)>"Option"type<TB -const -&>) )>

6.3.9.10. left_join_to_array

left_join_to_array(srca: array<auto(TA)>; srcb: iterator<auto(TB) const>; keya: auto; keyb: auto; result: auto) : array<typedecl(result(type<TA>,type<$Option(type<TB -const -&>)>"Option"type<TB -const -&>) )>

Left outer join of an array (left) and an iterator (right), returning an array

Arguments:

  • srca : array<auto(TA)>

  • srcb : iterator<auto(TB)>

  • keya : auto

  • keyb : auto

  • result : auto

left_join_to_array(srca: iterator<auto(TA) const>; srcb: array<auto(TB)>; keya: auto; keyb: auto; result: auto) : array<typedecl(result(type<TA>,type<$Option(type<TB -const -&>)>"Option"type<TB -const -&>) )>
left_join_to_array(srca: iterator<auto(TA)>; srcb: iterator<auto(TB)>; keya: auto; keyb: auto; result: auto) : array<typedecl(result(type<TA>,type<$Option(type<TB -const -&>)>"Option"type<TB -const -&>) )>

6.3.9.11. right_join

right_join(srca: array<auto(TA)>; srcb: array<auto(TB)>; keya: auto; keyb: auto; result: auto) : array<typedecl(result(type<$Option(type<TA -const -&>)>"Option"type<TA -const -&>,type<TB>) )>

Right outer join — every TB emits at least one row; left side is Option<TA> (none when no left match)

Arguments:

  • srca : array<auto(TA)>

  • srcb : array<auto(TB)>

  • keya : auto

  • keyb : auto

  • result : auto

right_join(srca: array<auto(TA)>; srcb: iterator<auto(TB) const>; keya: auto; keyb: auto; result: auto) : iterator<typedecl(result(type<$Option(type<TA -const -&>)>"Option"type<TA -const -&>,type<TB>) )>
right_join(srca: iterator<auto(TA) const>; srcb: array<auto(TB)>; keya: auto; keyb: auto; result: auto) : iterator<typedecl(result(type<$Option(type<TA -const -&>)>"Option"type<TA -const -&>,type<TB>) )>
right_join(srca: iterator<auto(TA)>; srcb: iterator<auto(TB)>; keya: auto; keyb: auto; result: auto) : iterator<typedecl(result(type<$Option(type<TA -const -&>)>"Option"type<TA -const -&>,type<TB>) )>

6.3.9.12. right_join_to_array

right_join_to_array(srca: array<auto(TA)>; srcb: iterator<auto(TB) const>; keya: auto; keyb: auto; result: auto) : array<typedecl(result(type<$Option(type<TA -const -&>)>"Option"type<TA -const -&>,type<TB>) )>

Right outer join of an array (left) and an iterator (right), returning an array

Arguments:

  • srca : array<auto(TA)>

  • srcb : iterator<auto(TB)>

  • keya : auto

  • keyb : auto

  • result : auto

right_join_to_array(srca: iterator<auto(TA) const>; srcb: array<auto(TB)>; keya: auto; keyb: auto; result: auto) : array<typedecl(result(type<$Option(type<TA -const -&>)>"Option"type<TA -const -&>,type<TB>) )>
right_join_to_array(srca: iterator<auto(TA)>; srcb: iterator<auto(TB)>; keya: auto; keyb: auto; result: auto) : array<typedecl(result(type<$Option(type<TA -const -&>)>"Option"type<TA -const -&>,type<TB>) )>

6.3.10. Grouping

6.3.10.1. group_by

group_by(source: array<auto(TT)>; key: auto; element_selector: auto; result_selector: auto ): auto

Groups the elements of an array according to a specified key selector function

Arguments:

  • source : array<auto(TT)>

  • key : auto

  • element_selector : auto

  • result_selector : auto

group_by(source: iterator<auto(TT)>; key: auto; element_selector: auto; result_selector: auto ): auto

6.3.10.2. group_by_lazy

group_by_lazy(source: array<auto(TT)>; key: auto ): auto

IGrouping shape over an array — yields (key, array<TT>) per group.

Arguments:

  • source : array<auto(TT)>

  • key : auto

group_by_lazy(source: iterator<auto(TT)>; key: auto ): auto
group_by_lazy_to_array(source: iterator<auto(TT)>; key: auto ): auto

IGrouping shape returning an array — see group_by_lazy.

Arguments:

  • source : iterator<auto(TT)>

  • key : auto

group_by_to_array(source: iterator<auto(TT)>; key: auto; element_selector: auto; result_selector: auto ): auto

Groups the elements of an iterator according to a specified key selector function and returns an array

Arguments:

  • source : iterator<auto(TT)>

  • key : auto

  • element_selector : auto

  • result_selector : auto

6.3.10.3. having

having_(src: array<auto(TT)>; predicate: block<(arg:TT):bool> ): array<TT>

Post-aggregate filter on an array — semantics match where_; preserved as a distinct call so SQL translation can route to HAVING.

Arguments:

  • src : array<auto(TT)>

  • predicate : block<(arg:TT):bool>

having_(src: iterator<auto(TT)>; predicate: block<(arg:TT):bool> ): iterator<TT>
having_to_array(src: iterator<auto(TT)>; predicate: block<(arg:TT):bool> ): array<TT>

Post-aggregate filter returning an array — see having_.

Arguments:

  • src : iterator<auto(TT)>

  • predicate : block<(arg:TT):bool>

6.3.11. Querying data

6.3.11.1. all

all(src: array<auto(TT)>; predicate: block<(arg:TT):bool> ): bool

Returns true if all elements in the array satisfy the predicate

Arguments:

  • src : array<auto(TT)>

  • predicate : block<(arg:TT):bool>

all(src: iterator<auto(TT) const>; predicate: block<(arg:TT):bool> ): bool

6.3.11.2. any

any(src: array<auto(TT)> ): bool

Returns true if the array has at least one element

Arguments:

  • src : array<auto(TT)>

any(src: array<auto(TT)>; predicate: block<(arg:TT):bool> ): bool
any(src: iterator<auto(TT)> ): bool
any(src: iterator<auto(TT)>; predicate: block<(arg:TT):bool> ): bool

6.3.11.3. contains

contains(src: array<auto(TT)>; element: TT ): bool

Returns true if the element is present in the array

Arguments:

  • src : array<auto(TT)>

  • element : TT

contains(src: iterator<auto(TT) const>; element: TT ): bool

6.3.11.4. none

none(src: array<auto(TT)> ): bool

Returns true if the array has no elements

Arguments:

  • src : array<auto(TT)>

none(src: array<auto(TT)>; predicate: block<(arg:TT):bool> ): bool
none(src: iterator<auto(TT)> ): bool
none(src: iterator<auto(TT)>; predicate: block<(arg:TT):bool> ): bool

6.3.12. Element operations

6.3.12.1. element_at

element_at(src: array<auto(TT)>; index: int ): TT

Returns the element at the specified index

Arguments:

  • src : array<auto(TT)>

  • index : int

element_at(src: iterator<auto(TT)>; index: int ): TT

6.3.12.2. element_at_or_default

element_at_or_default(src: array<auto(TT)>; index: int ): TT

Returns the element at the specified index, or a default value if the index is out of range

Arguments:

  • src : array<auto(TT)>

  • index : int

element_at_or_default(src: iterator<auto(TT)>; index: int ): TT

6.3.12.3. first

first(src: array<auto(TT)> ): TT

Returns the first element of an array

Arguments:

  • src : array<auto(TT)>

first(src: iterator<auto(TT)> ): TT

6.3.12.4. first_or_default

first_or_default(src: array<auto(TT)>; defaultValue: TT ): TT

Returns the first element of an array, or a default value if the array is empty

Arguments:

  • src : array<auto(TT)>

  • defaultValue : TT

first_or_default(src: iterator<auto(TT)>; defaultValue: TT ): TT

6.3.12.5. last

last(src: array<auto(TT)> ): TT

Returns the last element of an array

Arguments:

  • src : array<auto(TT)>

last(src: iterator<auto(TT)> ): TT

6.3.12.6. last_or_default

last_or_default(src: array<auto(TT)>; defaultValue: TT ): TT

Returns the last element of an array, or a default value if the array is empty

Arguments:

  • src : array<auto(TT)>

  • defaultValue : TT

last_or_default(src: iterator<auto(TT)>; defaultValue: TT ): TT

6.3.12.7. single

single(src: array<auto(TT)> ): TT

Returns the only element of an array, and throws if there is not exactly one element

Arguments:

  • src : array<auto(TT)>

single(src: iterator<auto(TT)> ): TT

6.3.12.8. single_or_default

single_or_default(src: array<auto(TT)>; defaultValue: TT ): TT

Returns the only element of an array, or a default value if there is not exactly one element

Arguments:

  • src : array<auto(TT)>

  • defaultValue : TT

single_or_default(src: iterator<auto(TT)>; defaultValue: TT ): TT

6.3.13. Transform operations

6.3.13.1. select

select(src: array<auto(TT)> ): array<tuple<int;TT>>

Projects each element of an array into a new form

Arguments:

  • src : array<auto(TT)>

select(src: array<auto(TT)>; result_selector: auto) : array<typedecl(result_selector(type<TT>) )>
select(src: iterator<auto(TT)> ): iterator<tuple<int;TT>>
select(src: iterator<auto(TT)>; result_selector: auto) : iterator<typedecl(result_selector(type<TT>) )>

6.3.13.2. select_many

select_many(src: array<auto(TT)>; collection_selector: auto; result_selector: auto) : array<typedecl(result_selector(iter_type(collection_selector(type<TT>))) )>

Projects each element of an array to an iterator and flattens the resulting iterators into one array

Arguments:

  • src : array<auto(TT)>

  • collection_selector : auto

  • result_selector : auto

select_many(src: array<auto(TT)>; result_selector: auto) : array<typedecl(result_selector(iter_type(type<TT>)) )>
select_many(src: iterator<auto(TT)>; collection_selector: auto; result_selector: auto) : iterator<typedecl(result_selector(iter_type(collection_selector(type<TT>))) )>
select_many(src: iterator<auto(TT)>; result_selector: auto) : iterator<typedecl(result_selector(iter_type(type<TT>)) )>

6.3.13.3. select_many_to_array

select_many_to_array(src: iterator<auto(TT)>; collection_selector: auto; result_selector: auto) : array<typedecl(result_selector(iter_type(collection_selector(type<TT>))) )>

Projects each element of an iterator to an iterator and flattens the resulting iterators into one array

Arguments:

  • src : iterator<auto(TT)>

  • collection_selector : auto

  • result_selector : auto

select_many_to_array(src: iterator<auto(TT)>; result_selector: auto) : array<typedecl(result_selector(iter_type(type<TT>)) )>

6.3.13.4. select_to_array

select_to_array(src: iterator<auto(TT)> ): array<tuple<int;TT>>

Projects each element of an iterator into a new form and returns an array

Arguments:

  • src : iterator<auto(TT)>

select_to_array(src: iterator<auto(TT)>; result_selector: auto) : array<typedecl(result_selector(type<TT>) )>

6.3.13.5. zip

zip(a: array<auto(TT)>; b: array<auto(UU)> ): array<tuple<TT;UU>>

Merges two arrays into an array of tuples

Arguments:

  • a : array<auto(TT)>

  • b : array<auto(UU)>

zip(a: array<auto(TT)>; b: array<auto(UU)>; c: array<auto(WW)> ): array<tuple<TT;UU;WW>>
zip(a: array<auto(TT)>; b: array<auto(UU)>; c: array<auto(WW)>; d: array<auto(XX)> ): array<tuple<TT;UU;WW;XX>>
zip(a: array<auto(TT)>; b: array<auto(UU)>; c: array<auto(WW)>; d: array<auto(XX)>; e: array<auto(YY)> ): array<tuple<TT;UU;WW;XX;YY>>
zip(a: array<auto(TT)>; b: array<auto(UU)>; c: array<auto(WW)>; d: array<auto(XX)>; e: array<auto(YY)>; f: array<auto(ZZ)> ): array<tuple<TT;UU;WW;XX;YY;ZZ>>
zip(a: array<auto(TT)>; b: array<auto(UU)>; c: array<auto(WW)>; d: array<auto(XX)>; e: array<auto(YY)>; f: array<auto(ZZ)>; g: array<auto(RR)> ): array<tuple<TT;UU;WW;XX;YY;ZZ;RR>>
zip(a: array<auto(TT)>; b: array<auto(UU)>; c: array<auto(WW)>; d: array<auto(XX)>; e: array<auto(YY)>; f: array<auto(ZZ)>; g: array<auto(RR)>; h: array<auto(SS)> ): array<tuple<TT;UU;WW;XX;YY;ZZ;RR;SS>>
zip(a: array<auto(TT)>; b: array<auto(UU)>; c: array<auto(WW)>; d: array<auto(XX)>; e: array<auto(YY)>; f: array<auto(ZZ)>; g: array<auto(RR)>; h: array<auto(SS)>; result_selector: block<(l:TT;r:UU;w:WW;x:XX;y:YY;z:ZZ;m:RR;n:SS):auto>) : array<typedecl(result_selector(type<TT>,type<UU>,type<WW>,type<XX>,type<YY>,type<ZZ>,type<RR>,type<SS>) )>
zip(a: array<auto(TT)>; b: array<auto(UU)>; c: array<auto(WW)>; d: array<auto(XX)>; e: array<auto(YY)>; f: array<auto(ZZ)>; g: array<auto(RR)>; result_selector: block<(l:TT;r:UU;w:WW;x:XX;y:YY;z:ZZ;m:RR):auto>) : array<typedecl(result_selector(type<TT>,type<UU>,type<WW>,type<XX>,type<YY>,type<ZZ>,type<RR>) )>
zip(a: array<auto(TT)>; b: array<auto(UU)>; c: array<auto(WW)>; d: array<auto(XX)>; e: array<auto(YY)>; f: array<auto(ZZ)>; result_selector: block<(l:TT;r:UU;w:WW;x:XX;y:YY;z:ZZ):auto>) : array<typedecl(result_selector(type<TT>,type<UU>,type<WW>,type<XX>,type<YY>,type<ZZ>) )>
zip(a: array<auto(TT)>; b: array<auto(UU)>; c: array<auto(WW)>; d: array<auto(XX)>; e: array<auto(YY)>; result_selector: block<(l:TT;r:UU;w:WW;x:XX;y:YY):auto>) : array<typedecl(result_selector(type<TT>,type<UU>,type<WW>,type<XX>,type<YY>) )>
zip(a: array<auto(TT)>; b: array<auto(UU)>; c: array<auto(WW)>; d: array<auto(XX)>; result_selector: block<(l:TT;r:UU;w:WW;x:XX):auto>) : array<typedecl(result_selector(type<TT>,type<UU>,type<WW>,type<XX>) )>
zip(a: array<auto(TT)>; b: array<auto(UU)>; c: array<auto(WW)>; result_selector: block<(l:TT;r:UU;w:WW):auto>) : array<typedecl(result_selector(type<TT>,type<UU>,type<WW>) )>
zip(a: array<auto(TT)>; b: array<auto(UU)>; result_selector: block<(l:TT;r:UU):auto>) : array<typedecl(result_selector(type<TT>,type<UU>) )>
zip(a: iterator<auto(TT)>; b: iterator<auto(UU)> ): iterator<tuple<TT;UU>>
zip(a: iterator<auto(TT)>; b: iterator<auto(UU)>; result_selector: block<(l:TT;r:UU):auto>) : iterator<typedecl(result_selector(type<TT>,type<UU>) )>
zip(a: iterator<auto(TT)>; b: iterator<auto(UU)>; c: iterator<auto(WW)> ): iterator<tuple<TT;UU;WW>>
zip(a: iterator<auto(TT)>; b: iterator<auto(UU)>; c: iterator<auto(WW)>; result_selector: block<(l:TT;r:UU;w:WW):auto>) : iterator<typedecl(result_selector(type<TT>,type<UU>,type<WW>) )>
zip(a: iterator<auto(TT)>; b: iterator<auto(UU)>; c: iterator<auto(WW)>; d: iterator<auto(XX)> ): iterator<tuple<TT;UU;WW;XX>>
zip(a: iterator<auto(TT)>; b: iterator<auto(UU)>; c: iterator<auto(WW)>; d: iterator<auto(XX)>; result_selector: block<(l:TT;r:UU;w:WW;x:XX):auto>) : iterator<typedecl(result_selector(type<TT>,type<UU>,type<WW>,type<XX>) )>
zip(a: iterator<auto(TT)>; b: iterator<auto(UU)>; c: iterator<auto(WW)>; d: iterator<auto(XX)>; e: iterator<auto(YY)> ): iterator<tuple<TT;UU;WW;XX;YY>>
zip(a: iterator<auto(TT)>; b: iterator<auto(UU)>; c: iterator<auto(WW)>; d: iterator<auto(XX)>; e: iterator<auto(YY)>; result_selector: block<(l:TT;r:UU;w:WW;x:XX;y:YY):auto>) : iterator<typedecl(result_selector(type<TT>,type<UU>,type<WW>,type<XX>,type<YY>) )>
zip(a: iterator<auto(TT)>; b: iterator<auto(UU)>; c: iterator<auto(WW)>; d: iterator<auto(XX)>; e: iterator<auto(YY)>; f: iterator<auto(ZZ)> ): iterator<tuple<TT;UU;WW;XX;YY;ZZ>>
zip(a: iterator<auto(TT)>; b: iterator<auto(UU)>; c: iterator<auto(WW)>; d: iterator<auto(XX)>; e: iterator<auto(YY)>; f: iterator<auto(ZZ)>; result_selector: block<(l:TT;r:UU;w:WW;x:XX;y:YY;z:ZZ):auto>) : iterator<typedecl(result_selector(type<TT>,type<UU>,type<WW>,type<XX>,type<YY>,type<ZZ>) )>
zip(a: iterator<auto(TT)>; b: iterator<auto(UU)>; c: iterator<auto(WW)>; d: iterator<auto(XX)>; e: iterator<auto(YY)>; f: iterator<auto(ZZ)>; g: iterator<auto(RR)> ): iterator<tuple<TT;UU;WW;XX;YY;ZZ;RR>>
zip(a: iterator<auto(TT)>; b: iterator<auto(UU)>; c: iterator<auto(WW)>; d: iterator<auto(XX)>; e: iterator<auto(YY)>; f: iterator<auto(ZZ)>; g: iterator<auto(RR)>; result_selector: block<(l:TT;r:UU;w:WW;x:XX;y:YY;z:ZZ;m:RR):auto>) : iterator<typedecl(result_selector(type<TT>,type<UU>,type<WW>,type<XX>,type<YY>,type<ZZ>,type<RR>) )>
zip(a: iterator<auto(TT)>; b: iterator<auto(UU)>; c: iterator<auto(WW)>; d: iterator<auto(XX)>; e: iterator<auto(YY)>; f: iterator<auto(ZZ)>; g: iterator<auto(RR)>; h: iterator<auto(SS)> ): iterator<tuple<TT;UU;WW;XX;YY;ZZ;RR;SS>>
zip(a: iterator<auto(TT)>; b: iterator<auto(UU)>; c: iterator<auto(WW)>; d: iterator<auto(XX)>; e: iterator<auto(YY)>; f: iterator<auto(ZZ)>; g: iterator<auto(RR)>; h: iterator<auto(SS)>; result_selector: block<(l:TT;r:UU;w:WW;x:XX;y:YY;z:ZZ;m:RR;n:SS):auto>) : iterator<typedecl(result_selector(type<TT>,type<UU>,type<WW>,type<XX>,type<YY>,type<ZZ>,type<RR>,type<SS>) )>

6.3.13.6. zip_to_array

zip_to_array(a: iterator<auto(TT)>; b: iterator<auto(UU)> ): array<tuple<TT;UU>>

Merges two iterators into an array of tuples

Arguments:

  • a : iterator<auto(TT)>

  • b : iterator<auto(UU)>

zip_to_array(a: iterator<auto(TT)>; b: iterator<auto(UU)>; result_selector: block<(l:TT;r:UU):auto>) : array<typedecl(result_selector(type<TT>,type<UU>) )>
zip_to_array(a: iterator<auto(TT)>; b: iterator<auto(UU)>; c: iterator<auto(WW)> ): array<tuple<TT;UU;WW>>
zip_to_array(a: iterator<auto(TT)>; b: iterator<auto(UU)>; c: iterator<auto(WW)>; result_selector: block<(l:TT;r:UU;w:WW):auto>) : array<typedecl(result_selector(type<TT>,type<UU>,type<WW>) )>
zip_to_array(a: iterator<auto(TT)>; b: iterator<auto(UU)>; c: iterator<auto(WW)>; d: iterator<auto(XX)> ): array<tuple<TT;UU;WW;XX>>
zip_to_array(a: iterator<auto(TT)>; b: iterator<auto(UU)>; c: iterator<auto(WW)>; d: iterator<auto(XX)>; result_selector: block<(l:TT;r:UU;w:WW;x:XX):auto>) : array<typedecl(result_selector(type<TT>,type<UU>,type<WW>,type<XX>) )>
zip_to_array(a: iterator<auto(TT)>; b: iterator<auto(UU)>; c: iterator<auto(WW)>; d: iterator<auto(XX)>; e: iterator<auto(YY)> ): array<tuple<TT;UU;WW;XX;YY>>
zip_to_array(a: iterator<auto(TT)>; b: iterator<auto(UU)>; c: iterator<auto(WW)>; d: iterator<auto(XX)>; e: iterator<auto(YY)>; result_selector: block<(l:TT;r:UU;w:WW;x:XX;y:YY):auto>) : array<typedecl(result_selector(type<TT>,type<UU>,type<WW>,type<XX>,type<YY>) )>
zip_to_array(a: iterator<auto(TT)>; b: iterator<auto(UU)>; c: iterator<auto(WW)>; d: iterator<auto(XX)>; e: iterator<auto(YY)>; f: iterator<auto(ZZ)> ): array<tuple<TT;UU;WW;XX;YY;ZZ>>
zip_to_array(a: iterator<auto(TT)>; b: iterator<auto(UU)>; c: iterator<auto(WW)>; d: iterator<auto(XX)>; e: iterator<auto(YY)>; f: iterator<auto(ZZ)>; result_selector: block<(l:TT;r:UU;w:WW;x:XX;y:YY;z:ZZ):auto>) : array<typedecl(result_selector(type<TT>,type<UU>,type<WW>,type<XX>,type<YY>,type<ZZ>) )>
zip_to_array(a: iterator<auto(TT)>; b: iterator<auto(UU)>; c: iterator<auto(WW)>; d: iterator<auto(XX)>; e: iterator<auto(YY)>; f: iterator<auto(ZZ)>; g: iterator<auto(RR)> ): array<tuple<TT;UU;WW;XX;YY;ZZ;RR>>
zip_to_array(a: iterator<auto(TT)>; b: iterator<auto(UU)>; c: iterator<auto(WW)>; d: iterator<auto(XX)>; e: iterator<auto(YY)>; f: iterator<auto(ZZ)>; g: iterator<auto(RR)>; result_selector: block<(l:TT;r:UU;w:WW;x:XX;y:YY;z:ZZ;m:RR):auto>) : array<typedecl(result_selector(type<TT>,type<UU>,type<WW>,type<XX>,type<YY>,type<ZZ>,type<RR>) )>
zip_to_array(a: iterator<auto(TT)>; b: iterator<auto(UU)>; c: iterator<auto(WW)>; d: iterator<auto(XX)>; e: iterator<auto(YY)>; f: iterator<auto(ZZ)>; g: iterator<auto(RR)>; h: iterator<auto(SS)> ): array<tuple<TT;UU;WW;XX;YY;ZZ;RR;SS>>
zip_to_array(a: iterator<auto(TT)>; b: iterator<auto(UU)>; c: iterator<auto(WW)>; d: iterator<auto(XX)>; e: iterator<auto(YY)>; f: iterator<auto(ZZ)>; g: iterator<auto(RR)>; h: iterator<auto(SS)>; result_selector: block<(l:TT;r:UU;w:WW;x:XX;y:YY;z:ZZ;m:RR;n:SS):auto>) : array<typedecl(result_selector(type<TT>,type<UU>,type<WW>,type<XX>,type<YY>,type<ZZ>,type<RR>,type<SS>) )>

6.3.14. Conversion operations

6.3.14.1. to_sequence

to_sequence(a: array<auto(TT)> ): iterator<TT>

Converts an array to an iterator

Arguments:

  • a : array<auto(TT)>!

to_sequence(a: array<auto(TT)> ): iterator<TT>
to_sequence_move(a: array<auto(TT)> ): iterator<TT>

Converts an array to an iterator, captures input

Arguments:

  • a : array<auto(TT)>

6.3.14.2. to_table

to_table(a: array<auto(TT)>; key: block<(v:TT):auto>; elementSelector: block<(v:TT):auto>) : table<typedecl(_::unique_key(type<TT>)), typedecl(elementSelector(type<TT>) )>

Converts an array to a table

Arguments:

  • a : array<auto(TT)>

  • key : block<(v:TT):auto>

  • elementSelector : block<(v:TT):auto>

to_table(a: iterator<auto(TT)>; key: block<(v:TT):auto>; elementSelector: block<(v:TT):auto>) : table<typedecl(_::unique_key(type<TT>)), typedecl(elementSelector(type<TT>) )>

6.3.15. Comparators and keys

6.3.15.1. less

less(a: auto; b: auto ): bool

Compares two values, returns true if first is less than second

Arguments:

  • a : auto

  • b : auto

less(a: tuple<auto(TT);auto(UU);auto(VV);auto(WW)>; b: tuple<auto(TT);auto(UU);auto(VV);auto(WW)> ): bool
less(a: tuple<auto(TT);auto(UU);auto(VV)>; b: tuple<auto(TT);auto(UU);auto(VV)> ): bool
less(a: tuple<auto(TT);auto(UU)>; b: tuple<auto(TT);auto(UU)> ): bool
less(a: tuple<auto(TT)>; b: tuple<auto(TT)> ): bool

6.3.15.2. sequence_equal

sequence_equal(first: array<TT>; second: iterator<auto(TT) const> ): bool

Checks if an array and an iterator hold equal elements in the same order

Arguments:

  • first : array<TT>

  • second : iterator<auto(TT)>

sequence_equal(first: array<auto(TT)>; second: array<auto(TT)> ): bool
sequence_equal(first: iterator<auto(TT) const>; second: array<TT> ): bool
sequence_equal(first: iterator<auto(TT)>; second: iterator<auto(TT)> ): bool

6.3.15.3. sequence_equal_by

sequence_equal_by(first: array<TT>; second: iterator<auto(TT) const>; key: block<(arg:TT):auto> ): bool

Checks if an array and an iterator are equal by key

Arguments:

  • first : array<TT>

  • second : iterator<auto(TT)>

  • key : block<(arg:TT):auto>

sequence_equal_by(first: array<auto(TT)>; second: array<auto(TT)>; key: block<(arg:TT):auto> ): bool
sequence_equal_by(first: iterator<auto(TT) const>; second: array<TT>; key: block<(arg:TT):auto> ): bool
sequence_equal_by(first: iterator<auto(TT)>; second: iterator<auto(TT)>; key: block<(arg:TT):auto> ): bool