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 tutorial_linq 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

linq.order(a: iterator<auto(TT)>): iterator<TT>

Sorts an iterator

Arguments:

  • a : iterator<auto(TT)>

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

6.3.1.2. order_by

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

Sorts an array

Arguments:

  • a : array<auto(TT)>

  • key : auto

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

6.3.1.3. order_by_descending

linq.order_by_descending(a: iterator<auto(TT)>; key: auto): iterator<TT>

Sorts an iterator in descending order

Arguments:

  • a : iterator<auto(TT)>

  • key : auto

linq.order_by_descending(a: array<auto(TT)>; key: auto): array<TT>
linq.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

linq.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

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

Sorts an array in place

Arguments:

  • buffer : array<auto(TT)>

  • key : auto

linq.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

linq.order_descending(a: iterator<auto(TT)>): iterator<TT>

Sorts an iterator in descending order

Arguments:

  • a : iterator<auto(TT)>

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

6.3.1.5. order_descending_inplace

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

Sorts an array in descending order in place

Arguments:

  • buffer : array<auto(TT)>

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

6.3.1.6. order_descending_to_array

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

Sorts an iterator in descending order and returns an array

Arguments:

  • a : iterator<auto(TT)>

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

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

6.3.1.7. order_inplace

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

Sorts an array in place

Arguments:

  • buffer : array<auto(TT)>

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

6.3.1.8. order_to_array

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

Sorts an iterator and returns an array

Arguments:

  • a : iterator<auto(TT)>

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

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

6.3.1.9. order_unique_folded

linq.order_unique_folded(a: iterator<auto(TT)>): array<TT>

sort and remove duplicate elements from an iterator

Arguments:

  • a : iterator<auto(TT)>

linq.order_unique_folded(a: array<auto(TT)>): array<TT>
linq.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

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

Reverses an array

Arguments:

  • a : array<auto(TT)>

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

Reverses an array in place

Arguments:

  • buffer : array<auto(TT)>

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

Reverses an iterator and returns an array

Arguments:

  • a : iterator<auto(TT)>

6.3.2. Set operations

6.3.2.1. distinct

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

Returns distinct elements from an array

Arguments:

  • a : array<auto(TT)>

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

6.3.2.2. distinct_by

linq.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>

linq.distinct_by(a: iterator<auto(TT)>; key: block<(arg:TT):auto>): iterator<TT>
linq.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>

linq.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>

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

Returns distinct elements from an array in place

Arguments:

  • a : array<auto(TT)>

linq.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.2.3. except

linq.except(src: iterator<auto(TT)>; exclude: iterator<auto(TT)>): iterator<TT>

Returns elements from the first iterator that are not in the second iterator

Arguments:

  • src : iterator<auto(TT)>

  • exclude : iterator<auto(TT)>

linq.except(src: array<auto(TT)>; exclude: array<auto(TT)>): array<TT>

6.3.2.4. except_by

linq.except_by(src: array<auto(TT)>; exclude: array<auto(TT)>; key: block<(arg:TT):auto>): array<TT>

Returns elements from the first array that are not in the second array by key

Arguments:

  • src : array<auto(TT)>

  • exclude : array<auto(TT)>

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

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

Returns elements from the first iterator that are not in the second iterator by key and returns an array

Arguments:

  • src : iterator<auto(TT)>

  • exclude : iterator<auto(TT)>

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

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

Returns elements from the first iterator that are not in the second iterator and returns an array

Arguments:

  • src : iterator<auto(TT)>

  • exclude : iterator<auto(TT)>

6.3.2.5. intersect

linq.intersect(srca: array<auto(TT)>; srcb: array<auto(TT)>): array<TT>

Returns elements that are present in both arrays

Arguments:

  • srca : array<auto(TT)>

  • srcb : array<auto(TT)>

linq.intersect(srca: iterator<auto(TT)>; srcb: iterator<auto(TT)>): iterator<TT>

6.3.2.6. intersect_by

linq.intersect_by(srca: array<auto(TT)>; srcb: array<auto(TT)>; key: block<(arg:TT):auto>): array<TT>

Returns elements that are present in both arrays by key

Arguments:

  • srca : array<auto(TT)>

  • srcb : array<auto(TT)>

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

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

Returns elements that are present in both iterators by key and returns an array

Arguments:

  • srca : iterator<auto(TT)>

  • srcb : iterator<auto(TT)>

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

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

Returns elements that are present in both iterators and returns an array

Arguments:

  • srca : iterator<auto(TT)>

  • srcb : iterator<auto(TT)>

6.3.2.7. union

linq.union(srca: iterator<auto(TT)>; srcb: iterator<auto(TT)>): iterator<TT>

Returns distinct elements from the concatenation of two iterators

Arguments:

  • srca : iterator<auto(TT)>

  • srcb : iterator<auto(TT)>

linq.union(srca: array<auto(TT)>; srcb: array<auto(TT)>): array<TT>

6.3.2.8. union_by

linq.union_by(srca: array<auto(TT)>; srcb: array<auto(TT)>; key: block<(arg:TT):auto>): array<TT>

Returns distinct elements from the concatenation of two arrays by key

Arguments:

  • srca : array<auto(TT)>

  • srcb : array<auto(TT)>

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

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

Returns distinct elements from the concatenation of two iterators by key and returns an array

Arguments:

  • srca : iterator<auto(TT)>

  • srcb : iterator<auto(TT)>

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

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

Returns distinct elements from the concatenation of two iterators and returns an array

Arguments:

  • srca : iterator<auto(TT)>

  • srcb : iterator<auto(TT)>

6.3.2.9. unique

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

sort and remove duplicate elements from an array

Arguments:

  • a : array<auto(TT)>

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

6.3.2.10. unique_by

linq.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>

linq.unique_by(a: iterator<auto(TT)>; key: block<(arg:TT):auto>): iterator<TT>
linq.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>

linq.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>

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

remove duplicate elements from sorted array in place

Arguments:

  • a : array<auto(TT)>

linq.unique_key(a: auto): auto

generates unique key of workhorse type for the value

Arguments:

  • a : auto

linq.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.3. Concatenation operations

6.3.3.1. append

linq.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

linq.append(it: iterator<auto(TT)>; value: TT): iterator<TT>
linq.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

linq.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.3.2. concat

linq.concat(a: iterator<auto(TT)>; b: iterator<auto(TT)>): iterator<TT>

Concatenates two iterators

Arguments:

  • a : iterator<auto(TT)>

  • b : iterator<auto(TT)>

linq.concat(a: array<auto(TT)>; b: array<auto(TT)>): array<TT>
linq.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)>

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

Concatenates two iterators and returns an array

Arguments:

  • a : iterator<auto(TT)>

  • b : iterator<auto(TT)>

6.3.3.3. prepend

linq.prepend(it: iterator<auto(TT)>; value: TT): iterator<TT>

Prepends a value to the beginning of an iterator

Arguments:

  • it : iterator<auto(TT)>

  • value : TT

linq.prepend(arr: array<auto(TT)>; value: TT): array<TT>
linq.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

linq.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.4. Generation operations

linq.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)>

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

Returns an empty iterator of the specified type

Arguments:

  • typ : auto(TT)

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

Generates a sequence of integers within a specified range

Arguments:

  • start : int

  • count : int

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

Generates a sequence that contains one repeated value

Arguments:

  • element : auto(TT)

  • count : int

6.3.5. Aggregation operations

6.3.5.1. aggregate

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

Aggregates elements in an iterator using a seed and a function

Arguments:

  • src : iterator<auto(TT)>

  • seed : auto(AGG)

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

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

6.3.5.2. average

linq.average(src: array<auto(TT)>): TT

Averages elements in an array

Arguments:

  • src : array<auto(TT)>

linq.average(src: iterator<auto(TT)>): TT

6.3.5.3. count

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

Counts elements in an array that satisfy a predicate

Arguments:

  • a : array<auto(TT)>

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

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

6.3.5.4. long_count

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

Counts elements in an array, using a long integer

Arguments:

  • a : array<auto(TT)>

linq.long_count(a: iterator<auto(TT)>): int64

6.3.5.5. max

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

Finds the maximum element in an iterator

Arguments:

  • src : iterator<auto(TT)>

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

6.3.5.6. max_by

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

Finds the maximum element in an iterator by key

Arguments:

  • src : iterator<auto(TT)>

  • key : auto

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

6.3.5.7. min

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

Finds the minimum element in an iterator

Arguments:

  • src : iterator<auto(TT)>

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

6.3.5.8. min_by

linq.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

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

6.3.5.9. min_max

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

Finds the minimum and maximum elements in an iterator

Arguments:

  • src : iterator<auto(TT)>

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

6.3.5.10. min_max_average

linq.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)>

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

6.3.5.11. min_max_average_by

linq.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

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

6.3.5.12. min_max_by

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

Finds the minimum and maximum elements in an iterator by key

Arguments:

  • src : iterator<auto(TT)>

  • key : auto

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

6.3.5.13. sum

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

Sums elements in an array

Arguments:

  • src : array<auto(TT)>

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

6.3.6. Filtering data

6.3.6.1. where

linq.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>

linq.where_(src: iterator<auto(TT)>; predicate: block<(arg:TT):bool>): iterator<TT>
linq.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.7. Partitioning data

6.3.7.1. chunk

linq.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

linq.chunk(src: iterator<auto(TT)>; size: int): iterator<array<TT>>
linq.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.7.2. skip

linq.skip(src: iterator<auto(TT)>; total: int): iterator<TT>

Yields all but the first total elements

Arguments:

  • src : iterator<auto(TT)>

  • total : int

linq.skip(arr: array<auto(TT)>; total: int): array<TT>
linq.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.7.3. skip_last

linq.skip_last(src: iterator<auto(TT)>; total: int): iterator<TT>

Yields all but the last total elements from an iterator

Arguments:

  • src : iterator<auto(TT)>

  • total : int

linq.skip_last(arr: array<auto(TT)>; total: int): array<TT>
linq.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

linq.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

linq.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.7.4. skip_while

linq.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>

linq.skip_while(src: iterator<auto(TT)>; predicate: block<(arg:TT):bool>): iterator<TT>
linq.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.7.5. take

linq.take(src: array<auto(TT)>; from: range): array<TT>

Yields a range of elements from an array

Arguments:

  • src : array<auto(TT)>

  • from : range

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

6.3.7.6. take_inplace

linq.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

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

6.3.7.7. take_last

linq.take_last(src: iterator<auto(TT)>; total: int): iterator<TT>

Yields only the last total elements from an iterator

Arguments:

  • src : iterator<auto(TT)>

  • total : int

linq.take_last(arr: array<auto(TT)>; total: int): array<TT>
linq.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

linq.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.7.8. take_to_array

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

Yields only the first total elements and returns an array

Arguments:

  • src : iterator<auto(TT)>

  • total : int

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

6.3.7.9. take_while

linq.take_while(src: iterator<auto(TT)>; predicate: block<(arg:TT):bool>): iterator<TT>

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

Arguments:

  • src : iterator<auto(TT)>

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

linq.take_while(src: array<auto(TT)>; predicate: block<(arg:TT):bool>): array<TT>
linq.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.8. Join and group operations

6.3.8.1. group_by

linq.group_by(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

Arguments:

  • source : iterator<auto(TT)>

  • key : auto

  • element_selector : auto

  • result_selector : auto

linq.group_by(source: array<auto(TT)>; key: auto; element_selector: auto; result_selector: auto): auto
linq.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.8.2. group_join

linq.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 -&>>))>

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

Arguments:

  • srca : iterator<auto(TA)>

  • srcb : iterator<auto(TB)>

  • keya : auto

  • keyb : auto

  • result : auto

linq.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 -&>>))>
linq.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 -&>>))>

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

Arguments:

  • srca : iterator<auto(TA)>

  • srcb : iterator<auto(TB)>

  • keya : auto

  • keyb : auto

  • result : auto

6.3.8.3. join

linq.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

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

Joins two iterators based on matching keys (inner join) and returns an array

Arguments:

  • srca : iterator<auto(TA)>

  • srcb : iterator<auto(TB)>

  • keya : auto

  • keyb : auto

  • result : auto

6.3.9. Querying data

6.3.9.1. all

linq.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>

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

6.3.9.2. any

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

Returns true if any element in the array satisfies the predicate

Arguments:

  • src : array<auto(TT)>

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

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

6.3.9.3. contains

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

Returns true if the element is present in the iterator

Arguments:

  • src : iterator<auto(TT)>

  • element : TT

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

6.3.10. Element operations

6.3.10.1. element_at

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

Returns the element at the specified index

Arguments:

  • src : iterator<auto(TT)>

  • index : int

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

6.3.10.2. element_at_or_default

linq.element_at_or_default(src: iterator<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 : iterator<auto(TT)>

  • index : int

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

6.3.10.3. first

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

Returns the first element of an iterator

Arguments:

  • src : iterator<auto(TT)>

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

6.3.10.4. first_or_default

linq.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

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

6.3.10.5. last

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

Returns the last element of an iterator

Arguments:

  • src : iterator<auto(TT)>

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

6.3.10.6. last_or_default

linq.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

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

6.3.10.7. single

linq.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)>

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

6.3.10.8. single_or_default

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

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

Arguments:

  • src : iterator<auto(TT)>

  • defaultValue : TT

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

6.3.11. Transform operations

6.3.11.1. select

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

Projects each element of an array into a new form

Arguments:

  • src : array<auto(TT)>

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

6.3.11.2. select_many

linq.select_many(src: iterator<auto(TT)>; result_selector: auto) : iterator<typedecl(result_selector(iter_type(type<TT>)))>

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

Arguments:

  • src : iterator<auto(TT)>

  • result_selector : auto

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

6.3.11.3. select_many_to_array

linq.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

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

6.3.11.4. select_to_array

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

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

Arguments:

  • src : iterator<auto(TT)>

  • result_selector : auto

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

6.3.11.5. zip

linq.zip(a: iterator<auto(TT)>; b: iterator<auto(UU)>): iterator<tuple<TT;UU>>

Merges two iterators into an iterator of tuples

Arguments:

  • a : iterator<auto(TT)>

  • b : iterator<auto(UU)>

linq.zip(a: array<auto(TT)>; b: array<auto(UU)>): array<tuple<TT;UU>>
linq.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>))>
linq.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>))>
linq.zip(a: array<auto(TT)>; b: array<auto(UU)>; c: array<auto(WW)>): array<tuple<TT;UU;WW>>
linq.zip(a: iterator<auto(TT)>; b: iterator<auto(UU)>; c: iterator<auto(WW)>): iterator<tuple<TT;UU;WW>>

6.3.11.6. zip_to_array

linq.zip_to_array(a: iterator<auto(TT)>; b: iterator<auto(UU)>; c: iterator<auto(WW)>): array<tuple<TT;UU;WW>>

Merges three iterators into an array of tuples

Arguments:

  • a : iterator<auto(TT)>

  • b : iterator<auto(UU)>

  • c : iterator<auto(WW)>

linq.zip_to_array(a: iterator<auto(TT)>; b: iterator<auto(UU)>): array<tuple<TT;UU>>
linq.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>))>

6.3.12. Conversion operations

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

Converts an array to an iterator

Arguments:

  • a : array<auto(TT)>

linq.to_sequence_move(a: array<auto(TT)>): iterator<TT>

Converts an array to an iterator, captures input

Arguments:

  • a : array<auto(TT)>

6.3.12.1. to_table

linq.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>

linq.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.13. Comparators and keys

6.3.13.1. less

linq.less(a: tuple<auto(TT)>; b: tuple<auto(TT)>): bool

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

Arguments:

  • a : tuple<auto(TT)>

  • b : tuple<auto(TT)>

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

6.3.13.2. sequence_equal

linq.sequence_equal(first: iterator<auto(TT)>; second: iterator<auto(TT)>): bool

Checks if two sequences are equal

Arguments:

  • first : iterator<auto(TT)>

  • second : iterator<auto(TT)>

linq.sequence_equal(first: array<auto(TT)>; second: array<auto(TT)>): bool

6.3.13.3. sequence_equal_by

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

Checks if two sequences are equal by key

Arguments:

  • first : iterator<auto(TT)>

  • second : iterator<auto(TT)>

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

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