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

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