xtd::linq::enumerable Class Reference

Inheritance diagram for xtd::linq::enumerable:

Definition

Provides a set of static methods for querying objects that implement ienumerable <type_t>.

Definition

template<typename type_t>
class enumerable : public xtd::static_object;

Header

#include <xtd/linq/enumerable>

Namespace

xtd::linq

Library

xtd.core

Public Aliases
template<typename type_t>
using	enumerator
	Represents the enumerator value type.
template<typename type_t>
using	iequality_comparer
	Represents the ienumerable value type.
template<typename type_t>
using	ienumerable
	Represents the ienumerable value type.
template<typename type_t>
using	list
	Represents the list value type.
template<typename key_t, typename value_t>
using	key_value_pair
	Represents the key value pair value type.

Public Static Methods
template<xtd::iterable source_t, xtd::func_callable< xtd::iterable_value_type< source_t >, xtd::iterable_value_type< source_t >, xtd::iterable_value_type< source_t > > func_t>
static auto	aggregate (source_t &&source, func_t &&funcfunc) -> xtd::iterable_value_type< source_t >
	Applies an accumulator function over a sequence.
template<typename accumulate_t, xtd::iterable source_t, xtd::func_callable< accumulate_t, accumulate_t, xtd::iterable_value_type< source_t > > func_t>
static auto	aggregate (source_t &&source, accumulate_t &&seed, func_t &&funcfunc) -> accumulate_t
	Applies an accumulator function over a sequence. The specified seed value is used as the initial accumulator value.
template<typename result_t, typename accumulate_t, xtd::iterable source_t, xtd::func_callable< accumulate_t, accumulate_t, xtd::iterable_value_type< source_t > > func_t, xtd::func_callable< result_t, accumulate_t > result_selector_t>
static auto	aggregate (source_t &&source, accumulate_t &&seed, func_t &&funcfunc, result_selector_t &&result_selector) -> result_t
	Applies an accumulator function over a sequence. The specified seed value is used as the initial accumulator value, and the specified function is used to select the result value.
template<xtd::iterable source_t, xtd::predicate_callable< xtd::iterable_value_type< source_t > > predicate_t>
static auto	all (source_t &&source, predicate_t &&predicatepredicate) -> bool
	Determines whether all elements of a sequence satisfy a condition.
template<xtd::iterable source_t>
static auto	any (source_t &&source) noexcept -> bool
	Determines whether a sequence contains any elements.
template<xtd::iterable source_t, xtd::predicate_callable< xtd::iterable_value_type< source_t > > predicate_t>
static auto	any (source_t &&source, predicate_t &&predicatepredicate) -> bool
	Determines whether any element of a sequence satisfies a condition.
template<xtd::iterable source_t>
static auto	append (source_t &&source, xtd::iterable_value_type< source_t > &&element) noexcept -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >
	Appends a value to the end of the sequence.
template<xtd::iterable source_t>
static auto	as_enumerable (source_t &&source) noexcept
	Returns the input typed as xtd::collections::generic::ienumerable <type_t>.
template<xtd::iterable source_t>
static auto	as_enumerable (const source_t &source) noexcept -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >
	Returns the input typed as xtd::collections::generic::ienumerable <type_t>.
template<xtd::iterable source_t>
static auto	as_enumerable (source_t &source) noexcept -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >
	Returns the input typed as xtd::collections::generic::ienumerable <type_t>.
template<typename value_t>
static auto	as_enumerable (std::initializer_list< value_t > source) noexcept -> xtd::collections::generic::enumerable_generator< value_t >
	Returns the input typed as xtd::collections::generic::ienumerable <type_t>.
template<std::forward_iterator iterator_t>
static auto	as_enumerable (iterator_t first, iterator_t last) noexcept -> xtd::collections::generic::enumerable_generator< typename std::decay< decltype(*first)>::type >
	Returns the input typed as xtd::collections::generic::ienumerable <type_t>.
template<std::forward_iterator iterator_t>
static auto	as_enumerable (iterator_t iteratoriterator, xtd::usize length) noexcept -> xtd::collections::generic::enumerable_generator< typename std::decay< decltype(*iteratoriterator)>::type >
	Returns the input typed as xtd::collections::generic::ienumerable <type_t>.
template<typename value_t, xtd::usize length>
static auto	as_enumerable (const value_t(&array)[length]) noexcept -> xtd::collections::generic::enumerable_generator< value_t >
	Returns the input typed as xtd::collections::generic::ienumerable <type_t>.
template<typename value_t, xtd::usize length>
static auto	as_enumerable (value_t(&array)[length]) noexcept -> xtd::collections::generic::enumerable_generator< value_t >
	Returns the input typed as xtd::collections::generic::ienumerable <type_t>.
template<xtd::iterable source_t> requires xtd::real_decimal<xtd::iterable_value_type<source_t>>
static auto	average (source_t &&source) -> xtd::decimal
	Computes the average of a sequence of xtd::decimal values.
template<xtd::iterable source_t> requires xtd::real_double<xtd::iterable_value_type<source_t>>
static auto	average (source_t &&source) -> double
	Computes the average of a sequence of double values.
template<xtd::iterable source_t> requires xtd::real_single<xtd::iterable_value_type<source_t>>
static auto	average (source_t &&source) -> xtd::single
	Computes the average of a sequence of float values.
template<xtd::iterable source_t> requires xtd::signed_integer_32<xtd::iterable_value_type<source_t>>
static auto	average (source_t &&source) -> double
	Computes the average of a sequence of xtd::int32 values.
template<xtd::iterable source_t> requires xtd::signed_integer_64<xtd::iterable_value_type<source_t>>
static auto	average (source_t &&source) -> double
	Computes the average of a sequence of xtd::int64 values.
template<xtd::iterable source_t> requires std::same_as<xtd::iterable_value_type<source_t>, xtd::optional<xtd::decimal>>
static auto	average (source_t &&source) -> xtd::optional< xtd::decimal >
	Computes the average of a sequence of optional xtd::decimal values.
template<xtd::iterable source_t> requires std::same_as<xtd::iterable_value_type<source_t>, xtd::optional<double>>
static auto	average (source_t &&source) -> xtd::optional< double >
	Computes the average of a sequence of optional double values.
template<xtd::iterable source_t> requires std::same_as<xtd::iterable_value_type<source_t>, xtd::optional<xtd::single>>
static auto	average (source_t &&source) -> xtd::optional< xtd::single >
	Computes the average of a sequence of optional float values.
template<xtd::iterable source_t> requires std::same_as<xtd::iterable_value_type<source_t>, xtd::optional<xtd::int32>>
static auto	average (source_t &&source) -> xtd::optional< double >
	Computes the average of a sequence of optional xtd::int32 values.
template<xtd::iterable source_t> requires std::same_as<xtd::iterable_value_type<source_t>, xtd::optional<xtd::int64>>
static auto	average (source_t &&source) -> xtd::optional< double >
	Computes the average of a sequence of optional xtd::int64 values.
template<typename result_t, xtd::iterable source_t>
static auto	cast (source_t &&source) -> xtd::collections::generic::enumerable_generator< result_t >
	Casts the elements of an xtd::collections::generic::ienumerable to the specified type.
template<xtd::iterable source_t>
static auto	chunk (source_t &&source, xtd::usize size) -> xtd::collections::generic::enumerable_generator< xtd::array< xtd::iterable_value_type< source_t > > >
	Splits the elements of a sequence into chunks of size at most size.
template<xtd::iterable first_t, xtd::iterable second_t>
static auto	concat (first_t &&first, second_t &&second) noexcept -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< first_t > >
	Concatenates two sequences.
template<xtd::iterable source_t>
static auto	contains (source_t &&source, const xtd::iterable_value_type< source_t > &value) noexcept -> bool
	Determines whether a sequence contains a specified element by using the default equality comparer.
template<xtd::iterable source_t>
static auto	contains (source_t &&source, const xtd::iterable_value_type< source_t > &value, const iequality_comparer< xtd::iterable_value_type< source_t > > &comparer) noexcept -> bool
	Determines whether a sequence contains a specified element by using a specified equality comparer.
template<xtd::iterable source_t, xtd::func_callable< bool, xtd::iterable_value_type< source_t >, xtd::iterable_value_type< source_t > > equater_t>
static auto	contains (source_t &&source, const xtd::iterable_value_type< source_t > &value, equater_t &&equater) noexcept -> bool
	Determines whether a sequence contains a specified element by using a specified equality comparer.
template<xtd::iterable source_t>
static auto	count (source_t &&source) noexcept -> xtd::usize
	Returns the number of elements in a sequence.
template<xtd::iterable source_t, xtd::predicate_callable< xtd::iterable_value_type< source_t > > predicate_t>
static auto	count (source_t &&source, predicate_t &&predicatepredicate) noexcept -> xtd::usize
	Returns a number that represents how many elements in the specified sequence satisfy a condition.
template<xtd::iterable source_t>
static auto	count (source_t &&source, xtd::iterable_value_type< source_t > &&value) noexcept -> xtd::usize
	Returns the number of elements with the specified value.
template<typename key_t, xtd::iterable source_t, xtd::callable< key_t, xtd::iterable_value_type< source_t > > key_selector_t>
static auto	count_by (source_t &&source, key_selector_t &&key_selector) noexcept -> xtd::collections::generic::enumerable_generator< xtd::collections::generic::key_value_pair< key_t, xtd::usize > >
	Returns the count of elements in the source sequence grouped by key.
template<typename key_t, xtd::iterable source_t, xtd::callable< key_t, xtd::iterable_value_type< source_t > > key_selector_t>
static auto	count_by (source_t &&source, key_selector_t &&key_selector, const iequality_comparer< key_t > &key_comparer) noexcept -> xtd::collections::generic::enumerable_generator< xtd::collections::generic::key_value_pair< key_t, xtd::usize > >
	Returns the count of elements in the source sequence grouped by key.
template<typename key_t, xtd::iterable source_t, xtd::callable< key_t, xtd::iterable_value_type< source_t > > key_selector_t, xtd::callable< bool, key_t, key_t > key_equater_t>
static auto	count_by (source_t &&source, key_selector_t &&key_selector, key_equater_t &&key_equater) noexcept -> xtd::collections::generic::enumerable_generator< xtd::collections::generic::key_value_pair< key_t, xtd::usize > >
	Returns the count of elements in the source sequence grouped by key.
template<xtd::iterable source_t>
static auto	default_if_empty (source_t &&source) noexcept -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >
	Returns the elements of the specified sequence or the type parameter's default value in a singleton collection if the sequence is empty.
template<xtd::iterable source_t>
static auto	default_if_empty (source_t &&source, const xtd::iterable_value_type< source_t > &default_value) noexcept -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >
	Returns the elements of the specified sequence or the specified value in a singleton collection if the sequence is empty.
template<xtd::iterable source_t>
static auto	distinct (source_t &&source) noexcept -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >
	Returns distinct elements from a sequence by using the default equality comparer to compare values.
template<xtd::iterable source_t>
static auto	distinct (source_t &&source, const iequality_comparer< source_t > &comparer) noexcept -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >
	Returns distinct elements from a sequence by using a specified xtd::collections::generic::iequality_comparer <type_t> to compare values.
template<xtd::iterable source_t, xtd::func_callable< bool, xtd::iterable_value_type< source_t >, xtd::iterable_value_type< source_t > > equater_t>
static auto	distinct (source_t &&source, equater_t &&equater) noexcept -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >
	Returns distinct elements from a sequence by using a specified xtd::collections::generic::iequality_comparer <type_t> to compare values.
template<xtd::iterable source_t, xtd::predicate_callable< xtd::iterable_value_type< source_t > > prediacte_t>
static auto	first_or_default (source_t &&source, prediacte_t &&predicatepredicate, xtd::iterable_value_type< source_t > &&default_value) noexcept -> xtd::iterable_value_type< source_t >
	Returns the first element of the sequence that satisfies a condition, or a specified default value if no such element is found.
template<xtd::iterable source_t, xtd::predicate_callable< xtd::iterable_value_type< source_t > > prediacte_t>
static auto	first_or_default (source_t &&source, prediacte_t &&predicatepredicate) noexcept -> xtd::iterable_value_type< source_t >
	Returns the first element of the sequence that satisfies a condition or a default value if no such element is found.
template<xtd::iterable source_t>
static auto	first_or_default (source_t &&source, xtd::iterable_value_type< source_t > &&default_value) noexcept -> xtd::iterable_value_type< source_t >
	Returns the first element of the sequence that satisfies a condition or a default value if no such element is found.
template<xtd::iterable source_t>
static auto	first_or_default (source_t &&source) noexcept -> xtd::iterable_value_type< source_t >
	Returns the first element of the sequence that satisfies a condition or a default value if no such element is found.
template<xtd::iterable source_t>
static auto	from (source_t &&source) noexcept
	Returns the input typed as xtd::collections::generic::ienumerable <type_t>.
template<xtd::iterable source_t>
static auto	from (const source_t &source) noexcept -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >
	Returns the input typed as xtd::collections::generic::ienumerable <type_t>.
template<xtd::iterable source_t>
static auto	from (source_t &source) noexcept -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >
	Returns the input typed as xtd::collections::generic::ienumerable <type_t>.
template<typename value_t>
static auto	from (std::initializer_list< value_t > source) noexcept -> xtd::collections::generic::enumerable_generator< value_t >
	Returns the input typed as xtd::collections::generic::ienumerable <type_t>.
template<std::forward_iterator iterator_t>
static auto	from (iterator_t first, iterator_t last) noexcept -> xtd::collections::generic::enumerable_generator< typename std::decay< decltype(*first)>::type >
	Returns the input typed as xtd::collections::generic::ienumerable <type_t>.
template<std::forward_iterator iterator_t>
static auto	from (iterator_t iteratoriterator, xtd::usize length) noexcept -> xtd::collections::generic::enumerable_generator< typename std::decay< decltype(*iteratoriterator)>::type >
	Returns the input typed as xtd::collections::generic::ienumerable <type_t>.
template<typename value_t, xtd::usize length>
static auto	from (const value_t(&array)[length]) noexcept -> xtd::collections::generic::enumerable_generator< value_t >
	Returns the input typed as xtd::collections::generic::ienumerable <type_t>.
template<typename value_t, xtd::usize length>
static auto	from (value_t(&array)[length]) noexcept -> xtd::collections::generic::enumerable_generator< value_t >
	Returns the input typed as xtd::collections::generic::ienumerable <type_t>.
template<xtd::iterable source_t> requires xtd::numeric<xtd::iterable_value_type<source_t>>
static auto	max (source_t &&source) -> xtd::iterable_value_type< source_t >
	Returns the maximum value in a sequence of xtd::numeric values.
template<xtd::iterable source_t, xtd::callable< xtd::iterable_value_type< source_t >, xtd::iterable_value_type< source_t > > selector_t> requires xtd::numeric<xtd::iterable_value_type<source_t>>
static auto	max (source_t &&source, selector_t &&selector) -> xtd::iterable_value_type< source_t >
	Returns the maximum value in a sequence of xtd::numeric values.
template<typename result_t, xtd::iterable source_t, xtd::callable< result_t, xtd::iterable_value_type< source_t > > selector_t> requires xtd::numeric<xtd::iterable_value_type<source_t>>
static auto	max (source_t &&source, selector_t &&selector) -> result_t
	Returns the maximum value in a sequence of xtd::numeric values.
template<xtd::iterable source_t> requires xtd::numeric<xtd::iterable_value_type<source_t>>
static auto	min (source_t &&source) -> xtd::iterable_value_type< source_t >
	Returns the minimum value in a sequence of xtd::numeric values.
template<xtd::iterable source_t, xtd::callable< xtd::iterable_value_type< source_t >, xtd::iterable_value_type< source_t > > selector_t> requires xtd::numeric<xtd::iterable_value_type<source_t>>
static auto	min (source_t &&source, selector_t &&selector) -> xtd::iterable_value_type< source_t >
	Returns the minimum value in a sequence of xtd::numeric values.
template<typename result_t, xtd::iterable source_t, xtd::callable< result_t, xtd::iterable_value_type< source_t > > selector_t> requires xtd::numeric<xtd::iterable_value_type<source_t>>
static auto	min (source_t &&source, selector_t &&selector) -> result_t
	Returns the minimum value in a sequence of xtd::numeric values.
template<xtd::iterable source_t>
static auto	order (source_t &&source) -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >
	Sorts the elements of a sequence in ascending order.
template<xtd::iterable source_t>
static auto	order (source_t &&source, const xtd::collections::generic::icomparer< xtd::iterable_value_type< source_t > > &comparer) -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >
	Sorts the elements of a sequence in ascending order.
template<xtd::iterable source_t, xtd::func_callable< bool, xtd::iterable_value_type< source_t >, xtd::iterable_value_type< source_t > > lesser_t>
static auto	order (source_t &&source, lesser_t &&lesser) -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >
	Sorts the elements of a sequence in ascending order.
template<typename key_t, xtd::iterable source_t, xtd::callable< key_t, xtd::iterable_value_type< source_t > > key_selector_t>
static auto	order_by (source_t &&source, key_selector_t &&key_selector) -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >
	Sorts the elements of a sequence in ascending order according to a key.
template<xtd::iterable source_t, xtd::callable< xtd::iterable_value_type< source_t >, xtd::iterable_value_type< source_t > > key_selector_t>
static auto	order_by (source_t &&source, key_selector_t &&key_selector) -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >
	Sorts the elements of a sequence in ascending order according to a key.
template<typename key_t, xtd::iterable source_t, xtd::callable< key_t, xtd::iterable_value_type< source_t > > key_selector_t>
static auto	order_by_descending (source_t &&source, key_selector_t &&key_selector) -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >
	Sorts the elements of a sequence in descending order according to a key.
template<xtd::iterable source_t, xtd::callable< xtd::iterable_value_type< source_t >, xtd::iterable_value_type< source_t > > key_selector_t>
static auto	order_by_descending (source_t &&source, key_selector_t &&key_selector) -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >
	Sorts the elements of a sequence in descending order according to a key.
template<xtd::integer integer_t>
static auto	range (integer_t count) -> xtd::collections::generic::enumerable_generator< integer_t >
	Generates a sequence of integral numbers within a specified range.
template<xtd::integer integer_t>
static auto	range (integer_t start, integer_t count) -> xtd::collections::generic::enumerable_generator< integer_t >
	Generates a sequence of integral numbers within a specified range.
template<xtd::integer integer_t>
static auto	range (integer_t start, integer_t count, integer_t step) -> xtd::collections::generic::enumerable_generator< integer_t >
	Generates a sequence of integral numbers within a specified range and step.
template<typename result_t, xtd::iterable source_t>
static auto	select (source_t &&source, auto &&selector) -> xtd::collections::generic::enumerable_generator< result_t >
	Projects each element of a sequence into a new form.
template<xtd::iterable source_t>
static auto	select (source_t &&source, auto &&selector) -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >
	Projects each element of a sequence into a new form by incorporating the element's index.
template<xtd::forward_iterable source_t>
static auto	shuffle (source_t &&source) -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >
	Shuffles the order of the elements of a sequence.
template<xtd::iterable source_t>
static auto	skip (source_t &&source, xtd::usize count) -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >
	Bypasses a specified number of elements in a sequence and then returns the remaining elements.
template<xtd::iterable source_t>
static auto	skip_while (source_t &&source, auto &&predicatepredicate) -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >
	Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements.
template<xtd::iterable source_t>
static auto	take (source_t &&source, xtd::usize count) -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >
	Returns a specified number of contiguous elements from the start of a sequence.
template<xtd::iterable source_t>
static auto	take (source_t &&source, const xtd::range &range) -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >
	Returns a specified number of contiguous elements from the start of a sequence.
template<xtd::iterable source_t>
static auto	take_while (source_t &&source, auto &&predicatepredicate) -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >
	Returns elements from a sequence as long as a specified condition is true, and then skips the remaining elements.
template<typename source_t>
static auto	to_array (const ienumerable< source_t > &source)
	Creates a xtd::array <type_t> from an xtd::collections::generic::ienumerable <type_t>.
template<typename source_t>
static auto	to_list (const ienumerable< source_t > &source)
	Creates a xtd::collections::generic::list <type_t> from an xtd::collections::generic::ienumerable <type_t>.
template<xtd::iterable source_t>
static auto	where (source_t &&source, auto &&predicatepredicate) -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >
	Filters a sequence of values based on a predicate.

Member Typedef Documentation

enumerator

template<typename type_t>

using xtd::linq::enumerable::enumerator

Represents the enumerator value type.

iequality_comparer

template<typename type_t>

using xtd::linq::enumerable::iequality_comparer

Represents the ienumerable value type.

ienumerable

template<typename type_t>

using xtd::linq::enumerable::ienumerable

Represents the ienumerable value type.

list

template<typename type_t>

using xtd::linq::enumerable::list

Represents the list value type.

key_value_pair

template<typename key_t, typename value_t>

using xtd::linq::enumerable::key_value_pair

Represents the key value pair value type.

Member Function Documentation

aggregate() [1/3]

template<xtd::iterable source_t, xtd::func_callable< xtd::iterable_value_type< source_t >, xtd::iterable_value_type< source_t >, xtd::iterable_value_type< source_t > > func_t>

auto xtd::linq::enumerable::aggregate ( source_t && source, func_t && func ) -> xtd::iterable_value_type< source_t >

staticnodiscard

Applies an accumulator function over a sequence.

Template Parameters

source_t

The type of the elements of source.

Parameters

source	An xtd::collections::generic::ienumerable <type_t> to aggregate over.
func	An accumulator function to be invoked on each element.

Returns

The final accumulator value.

Examples

The following code example demonstrates how to reverse the order of words in a string by using enumerable::aggregate.

#include <xtd/xtd>
 
auto main() -> int {
  auto sentence = "the quick brown fox jumps over the lazy dog"_s;
  
  // Split the string into individual words.
  auto words = sentence.split(' ');
  
  // Prepend each word to the beginning of the new sentence to reverse the word order.
  auto reversed = words.aggregate(_2 + " " + _1);
 
  console::write_line(reversed.quoted());
}
 
// This code produces the following output :
//
// "dog lazy the over jumps fox brown quick the"

aggregate() [2/3]

template<typename accumulate_t, xtd::iterable source_t, xtd::func_callable< accumulate_t, accumulate_t, xtd::iterable_value_type< source_t > > func_t>

auto xtd::linq::enumerable::aggregate ( source_t && source, accumulate_t && seed, func_t && func ) -> accumulate_t

staticnodiscard

Applies an accumulator function over a sequence. The specified seed value is used as the initial accumulator value.

Template Parameters

accumulate_t	The type of the accumulator value.
source_t	The type of the elements of source.

Parameters

source	An xtd::collections::generic::ienumerable <type_t> to aggregate over.
seed	The initial accumulator value.
func	An accumulator function to be invoked on each element.

Returns

The final accumulator value.

Examples

The following code example demonstrates how to use xtd::linq::enumerable::aggregate to apply an accumulator function and use a seed value.

#include <xtd/xtd>
 
auto main() -> int {
  auto ints = array {4, 8, 8, 3, 9, 0, 7, 8, 2};
  
  // Count the even numbers in the array, using a seed value of 0.
  auto num_even = ints.aggregate(0, [](auto&& total, auto&& next) {
    return next % 2 == 0 ? total + 1 : total;
  });
 
  console::write_line("The number of even integers is: {}", num_even);
}
 
// This code produces the following output :
//
// The number of even integers is: 6

aggregate() [3/3]

template<typename result_t, typename accumulate_t, xtd::iterable source_t, xtd::func_callable< accumulate_t, accumulate_t, xtd::iterable_value_type< source_t > > func_t, xtd::func_callable< result_t, accumulate_t > result_selector_t>

auto xtd::linq::enumerable::aggregate ( source_t && source, accumulate_t && seed, func_t && func, result_selector_t && result_selector ) -> result_t

staticnodiscard

Applies an accumulator function over a sequence. The specified seed value is used as the initial accumulator value, and the specified function is used to select the result value.

Template Parameters

result_t	The type of the resulting value.
accumulate_t	The type of the accumulator value.
source_t	The type of the elements of source.

Parameters

source	An xtd::collections::generic::ienumerable <type_t> to aggregate over.
seed	The initial accumulator value.
func	An accumulator function to be invoked on each element.
result_Selector	A function to transform the final accumulator value into the result value.

Returns

The transformed final accumulator value.

Examples

The following code example demonstrates how to use xtd::linq::enumerable::aggregate to apply an accumulator function and use a seed value.

#include <xtd/xtd>
 
auto main() -> int {
  auto fruits = array<string> {"apple", "mango", "orange", "passionfruit", "grape"};
  
  // Determine whether any string in the array is longer than "banana".
  auto longest_name = fruits.aggregate("bananas",
     [](auto&& longest, auto&& next) {return next.length() > longest.length() ? next : longest;},
     // Return the final result as an upper case string.
     [](auto&& fruit) {return fruit.to_upper();});
 
  console::write_line("The fruit with the longest name is {}", longest_name);
}
 
// This code produces the following output :
//
// The fruit with the longest name is PASSIONFRUIT

all()

template<xtd::iterable source_t, xtd::predicate_callable< xtd::iterable_value_type< source_t > > predicate_t>

auto xtd::linq::enumerable::all ( source_t && source, predicate_t && predicate ) -> bool

staticnodiscard

Determines whether all elements of a sequence satisfy a condition.

Template Parameters

source_t

The type of the elements of source.

Parameters

source	An xtd::collections::generic::ienumerable <type_t> that contains the elements to apply the predicate to.
predicate	A function to test each element for a condition.

Returns

true if every element of the source sequence passes the test in the specified predicate, or if the sequence is empty; otherwise, false.

Examples

The following code example demonstrates how to use xtd::linq::enumerable::all <source_t> to determine whether all the elements in a sequence satisfy a condition. Variable all_start_with_B is true if all the pet names start with "B" or if the pets array is empty.

#include <xtd/xtd>
 
auto main() -> int {
  struct pet : public object {
    pet() = default;
    pet(const string& name, int age) : name {name}, age {age} {}
    
    string name;
    int age = 0;
  };
  
  // Create an array of pets.
  auto pets = array {
    pet {"Barley", 10},
    pet {"Boots", 4},
    pet {"Whiskers", 6}
  };
  
  // Determine whether all pet names in the array start with 'B'.
  bool all_start_with_b = pets.all([](auto&& pet) {
    return pet.name.starts_with("B");
  });
  
  console::write_line("{} pet names start with 'B'.", all_start_with_b ? "All" : "Not all");
}
 
// This code produces the following output :
//
// Not all pet names start with 'B'.

any() [1/2]

template<xtd::iterable source_t>

auto xtd::linq::enumerable::any ( source_t && source ) -> bool

staticnodiscardnoexcept

Determines whether a sequence contains any elements.

Template Parameters

source_t

The type of the elements of source.

Parameters

source	The xtd::collections::generic::ienumerable <type_t> to check for emptiness.
last	The last iterator.

Returns

true if the source sequence contains any elements; otherwise, false.

Examples

The following code example demonstrates how to use Any to determine whether a sequence contains any elements.

#include <xtd/xtd>
 
auto main() -> int {
  auto numbers = list {1, 2};
  auto has_elements = numbers.any();
  
  console::write_line("The list {0} empty.", has_elements ? "is not" : "is");
}
 
// This code produces the following output :
//
// The list is not empty.

any() [2/2]

template<xtd::iterable source_t, xtd::predicate_callable< xtd::iterable_value_type< source_t > > predicate_t>

auto xtd::linq::enumerable::any ( source_t && source, predicate_t && predicate ) -> bool

staticnodiscard

Determines whether any element of a sequence satisfies a condition.

Template Parameters

source_t

The type of the elements of source.

Parameters

source	An xtd::collections::generic::ienumerable <type_t> that contains the elements to apply the predicate to.
predicate	A function to test each element for a condition.

Returns

true if every element of the source sequence passes the test in the specified predicate, or if the sequence is empty; otherwise, false.

Examples

The following code example demonstrates how to use xtd::linq::enumerable::all <source_t> to determine whether all the elements in a sequence satisfy a condition. Variable all_start_with_B is true if all the pet names start with "B" or if the pets array is empty.

#include <xtd/xtd>
 
auto main() -> int {
  struct pet : public object {
    pet() = default;
    pet(const string& name, int age) : name {name}, age {age} {}
    
    string name;
    int age = 0;
  };
  
  // Create an array of pets.
  auto pets = array {
    pet {"Barley", 10},
    pet {"Boots", 4},
    pet {"Whiskers", 6}
  };
  
  // Determine whether all pet names in the array start with 'B'.
  bool all_start_with_b = pets.all([](auto&& pet) {
    return pet.name.starts_with("B");
  });
  
  console::write_line("{} pet names start with 'B'.", all_start_with_b ? "All" : "Not all");
}
 
// This code produces the following output :
//
// Not all pet names start with 'B'.

append()

template<xtd::iterable source_t>

auto xtd::linq::enumerable::append ( source_t && source, xtd::iterable_value_type< source_t > && element ) -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >

staticnodiscardnoexcept

Appends a value to the end of the sequence.

Template Parameters

source_t

The type of the elements of source.

Parameters

source	A sequence of values.
element	The value to append to source.

Returns

A new sequence that ends with element.

Examples

The following code example demonstrates how to use Append to append a value to the end of the sequence.

#include <xtd/xtd>
 
auto main() -> int {
  // Creating a list of numbers
  auto numbers = list {1, 2, 3, 4};
  
  // Trying to append any value of the same type
  auto __ = numbers.append(5);
  
  // It doesn't work because the original list has not been changed
  console::write_line(string::join(", ", numbers));
  
  // It works now because we are using a changed copy of the original list
  console::write_line(string::join(", ", numbers.append(5)));
  
  // If you prefer, you can create a new list explicitly
  auto new_numbers = numbers.append(5).to_list();
  
  // And then write to the console output
  console::write_line(string::join(", ", new_numbers));
}
 
// This code produces the following output :
//
// 1, 2, 3, 4
// 1, 2, 3, 4, 5
// 1, 2, 3, 4, 5

as_enumerable() [1/8]

template<xtd::iterable source_t>

auto xtd::linq::enumerable::as_enumerable ( source_t && source )

staticnodiscardnoexcept

Returns the input typed as xtd::collections::generic::ienumerable <type_t>.

Template Parameters

source_t

The type of the elements of source.

Parameters

source

A sequence of values.

Returns

The input sequence typed as xtd::collections::generic::ienumerable <type_t>.

Examples

The following code example demonstrates how to use as_enumerable <source_t>(ienumerable <source_t>) to hide a type's custom Where method when the standard query operator implementation is desired.

Note

Need to include list file #include <xtd/collections/generic/list>.

as_enumerable() [2/8]

template<xtd::iterable source_t>

auto xtd::linq::enumerable::as_enumerable ( const source_t & source ) -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >

staticnodiscardnoexcept

Returns the input typed as xtd::collections::generic::ienumerable <type_t>.

Template Parameters

source_t

The type of the elements of source.

Parameters

source

A sequence of values.

Returns

The input sequence typed as xtd::collections::generic::ienumerable <type_t>.

Examples

The following code example demonstrates how to use as_enumerable <source_t>(ienumerable <source_t>) to hide a type's custom Where method when the standard query operator implementation is desired.

as_enumerable() [3/8]

template<xtd::iterable source_t>

auto xtd::linq::enumerable::as_enumerable ( source_t & source ) -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >

staticnodiscardnoexcept

Returns the input typed as xtd::collections::generic::ienumerable <type_t>.

Template Parameters

source_t

The type of the elements of source.

Parameters

source

A sequence of values.

Returns

The input sequence typed as xtd::collections::generic::ienumerable <type_t>.

Examples

The following code example demonstrates how to use as_enumerable <source_t>(ienumerable <source_t>) to hide a type's custom Where method when the standard query operator implementation is desired.

as_enumerable() [4/8]

template<typename value_t>

auto xtd::linq::enumerable::as_enumerable ( std::initializer_list< value_t > source ) -> xtd::collections::generic::enumerable_generator< value_t >

staticnodiscardnoexcept

Returns the input typed as xtd::collections::generic::ienumerable <type_t>.

Template Parameters

source_t

The type of the elements of source.

Parameters

source

A sequence of values.

Returns

The input sequence typed as xtd::collections::generic::ienumerable <type_t>.

Examples

The following code example demonstrates how to use as_enumerable <source_t>(ienumerable <source_t>) to hide a type's custom Where method when the standard query operator implementation is desired.

as_enumerable() [5/8]

template<std::forward_iterator iterator_t>

auto xtd::linq::enumerable::as_enumerable ( iterator_t first, iterator_t last ) -> xtd::collections::generic::enumerable_generator< typename std::decay< decltype(*first)>::type >

staticnodiscardnoexcept

Returns the input typed as xtd::collections::generic::ienumerable <type_t>.

Template Parameters

input_iterator_t

The type of the source iterators.

Parameters

first	The first iterator.
last	The last iterator.

Returns

The input sequence typed as xtd::collections::generic::ienumerable <type_t>.

Examples

The following code example demonstrates how to use as_enumerable <source_t>(ienumerable <source_t>) to hide a type's custom Where method when the standard query operator implementation is desired.

as_enumerable() [6/8]

template<std::forward_iterator iterator_t>

auto xtd::linq::enumerable::as_enumerable ( iterator_t iterator, xtd::usize length ) -> xtd::collections::generic::enumerable_generator< typename std::decay< decltype(*iterator)>::type >

staticnodiscardnoexcept

Returns the input typed as xtd::collections::generic::ienumerable <type_t>.

Template Parameters

input_iterator_t

The type of the source iterators.

Parameters

iterator	The iterator.
legnth	The le,gth to iterate.

Returns

The input sequence typed as xtd::collections::generic::ienumerable <type_t>.

Examples

The following code example demonstrates how to use as_enumerable <source_t>(ienumerable <source_t>) to hide a type's custom Where method when the standard query operator implementation is desired.

as_enumerable() [7/8]

template<typename value_t, xtd::usize length>

auto xtd::linq::enumerable::as_enumerable ( const value_t(&) array[length] ) -> xtd::collections::generic::enumerable_generator< value_t >

staticnodiscardnoexcept

Returns the input typed as xtd::collections::generic::ienumerable <type_t>.

Template Parameters

source_t

The type of the source array.

Parameters

array	The native array.
legnth	The length of the array.

Returns

The input sequence typed as xtd::collections::generic::ienumerable <type_t>.

Examples

The following code example demonstrates how to use as_enumerable <source_t>(ienumerable <source_t>) to hide a type's custom Where method when the standard query operator implementation is desired.

as_enumerable() [8/8]

template<typename value_t, xtd::usize length>

auto xtd::linq::enumerable::as_enumerable ( value_t(&) array[length] ) -> xtd::collections::generic::enumerable_generator< value_t >

staticnodiscardnoexcept

Returns the input typed as xtd::collections::generic::ienumerable <type_t>.

Template Parameters

source_t

The type of the source array.

Parameters

array	The native array.
legnth	The length of the array.

Returns

The input sequence typed as xtd::collections::generic::ienumerable <type_t>.

Examples

The following code example demonstrates how to use as_enumerable <source_t>(ienumerable <source_t>) to hide a type's custom Where method when the standard query operator implementation is desired.

average() [1/10]

template<xtd::iterable source_t>
requires xtd::real_decimal<xtd::iterable_value_type<source_t>>

auto xtd::linq::enumerable::average ( source_t && source ) -> xtd::decimal

staticnodiscard

Computes the average of a sequence of xtd::decimal values.

Parameters

source

A sequence of xtd::decimal values to calculate the average of.

Returns

The average of the sequence of values.

Exceptions

xtd::invalid_operation_exception

`source` contains no elements.

average() [2/10]

template<xtd::iterable source_t>
requires xtd::real_double<xtd::iterable_value_type<source_t>>

auto xtd::linq::enumerable::average ( source_t && source ) -> double

staticnodiscard

Computes the average of a sequence of double values.

Parameters

source

A sequence of double values to calculate the average of.

Returns

The average of the sequence of values.

Exceptions

xtd::invalid_operation_exception

`source` contains no elements.

average() [3/10]

template<xtd::iterable source_t>
requires xtd::real_single<xtd::iterable_value_type<source_t>>

auto xtd::linq::enumerable::average ( source_t && source ) -> xtd::single

staticnodiscard

Computes the average of a sequence of float values.

Parameters

source

A sequence of float values to calculate the average of.

Returns

The average of the sequence of values.

Exceptions

xtd::invalid_operation_exception

`source` contains no elements.

average() [4/10]

template<xtd::iterable source_t>
requires xtd::signed_integer_32<xtd::iterable_value_type<source_t>>

auto xtd::linq::enumerable::average ( source_t && source ) -> double

staticnodiscard

Computes the average of a sequence of xtd::int32 values.

Parameters

source

A sequence of xtd::int32 values to calculate the average of.

Returns

The average of the sequence of values.

Exceptions

xtd::invalid_operation_exception

`source` contains no elements.

average() [5/10]

template<xtd::iterable source_t>
requires xtd::signed_integer_64<xtd::iterable_value_type<source_t>>

auto xtd::linq::enumerable::average ( source_t && source ) -> double

staticnodiscard

Computes the average of a sequence of xtd::int64 values.

Parameters

source

A sequence of xtd::int64 values to calculate the average of.

Returns

The average of the sequence of values.

Exceptions

xtd::invalid_operation_exception

`source` contains no elements.

average() [6/10]

template<xtd::iterable source_t>
requires std::same_as<xtd::iterable_value_type<source_t>, xtd::optional<xtd::decimal>>

auto xtd::linq::enumerable::average ( source_t && source ) -> xtd::optional< xtd::decimal >

staticnodiscard

Computes the average of a sequence of optional xtd::decimal values.

Parameters

source

A sequence of optional xtd::decimal values to calculate the average of.

Returns

The average of the sequence of values, or xtd::nullopt if the source sequence is empty or contains only values that are xtd::nullopt.

average() [7/10]

template<xtd::iterable source_t>
requires std::same_as<xtd::iterable_value_type<source_t>, xtd::optional<double>>

auto xtd::linq::enumerable::average ( source_t && source ) -> xtd::optional< double >

staticnodiscard

Computes the average of a sequence of optional double values.

Parameters

source

A sequence of optional double values to calculate the average of.

Returns

The average of the sequence of values, or xtd::nullopt if the source sequence is empty or contains only values that are xtd::nullopt.

average() [8/10]

template<xtd::iterable source_t>
requires std::same_as<xtd::iterable_value_type<source_t>, xtd::optional<xtd::single>>

auto xtd::linq::enumerable::average ( source_t && source ) -> xtd::optional< xtd::single >

staticnodiscard

Computes the average of a sequence of optional float values.

Parameters

source

A sequence of optional float values to calculate the average of.

Returns

The average of the sequence of values, or xtd::nullopt if the source sequence is empty or contains only values that are xtd::nullopt.

average() [9/10]

template<xtd::iterable source_t>
requires std::same_as<xtd::iterable_value_type<source_t>, xtd::optional<xtd::int32>>

auto xtd::linq::enumerable::average ( source_t && source ) -> xtd::optional< double >

staticnodiscard

Computes the average of a sequence of optional xtd::int32 values.

Parameters

source

A sequence of optional xtd::int32 values to calculate the average of.

Returns

The average of the sequence of values, or xtd::nullopt if the source sequence is empty or contains only values that are xtd::nullopt.

average() [10/10]

template<xtd::iterable source_t>
requires std::same_as<xtd::iterable_value_type<source_t>, xtd::optional<xtd::int64>>

auto xtd::linq::enumerable::average ( source_t && source ) -> xtd::optional< double >

staticnodiscard

Computes the average of a sequence of optional xtd::int64 values.

Parameters

source

A sequence of optional xtd::int64 values to calculate the average of.

Returns

The average of the sequence of values, or xtd::nullopt if the source sequence is empty or contains only values that are xtd::nullopt.

cast()

template<typename result_t, xtd::iterable source_t>

auto xtd::linq::enumerable::cast ( source_t && source ) -> xtd::collections::generic::enumerable_generator< result_t >

staticnodiscard

Casts the elements of an xtd::collections::generic::ienumerable to the specified type.

Template Parameters

result_t	The type of the resulting value.
source_t	The type of the elements of source.

Parameters

source

The xtd::collections::generic::ienumerable that contains the elements to be cast to type result_t.

Returns

An xtd::collections::generic::ienumerable <type_t> that contains each element of the source sequence cast to the specified type.

Exceptions

xtd::invalid_cast_exception

An element in the sequence cannot be cast to type `result_t`.

Remarks

The xtd::as include file #include <xtd/as> is needeed to use this method.

chunk()

template<xtd::iterable source_t>

auto xtd::linq::enumerable::chunk ( source_t && source, xtd::usize size ) -> xtd::collections::generic::enumerable_generator< xtd::array< xtd::iterable_value_type< source_t > > >

staticnodiscard

Splits the elements of a sequence into chunks of size at most size.

Template Parameters

source_t

The type of the elements of source.

Parameters

source	A sequence of values to chunk.
size	The maximum size of each chunk.

Returns

A sequence of chunks of size at most size. @zxception xtd::argument_out_of_range_exception size is equal to 0.

Note

Need to include array file #include <xtd/array>.

concat()

template<xtd::iterable first_t, xtd::iterable second_t>

auto xtd::linq::enumerable::concat ( first_t && first, second_t && second ) -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< first_t > >

staticnodiscardnoexcept

Concatenates two sequences.

Template Parameters

source_t

The type of the elements of source.

Parameters

first	The first sequence to concatenate.
second	The sequence to concatenate to the first sequence.

Returns

An xtd::collections::generic::ienumerable <type_t> that contains the concatenated elements of the two input sequences.

contains() [1/3]

template<xtd::iterable source_t>

auto xtd::linq::enumerable::contains ( source_t && source, const xtd::iterable_value_type< source_t > & value ) -> bool

staticnodiscardnoexcept

Determines whether a sequence contains a specified element by using the default equality comparer.

Template Parameters

source_t

The type of the elements of source.

Parameters

source	A sequence in which to locate a value.
value	The value to locate in the sequence.

Returns

true if the source sequence contains an element that has the specified value; otherwise, false.

contains() [2/3]

template<xtd::iterable source_t>

auto xtd::linq::enumerable::contains ( source_t && source, const xtd::iterable_value_type< source_t > & value, const iequality_comparer< xtd::iterable_value_type< source_t > > & comparer ) -> bool

staticnodiscardnoexcept

Determines whether a sequence contains a specified element by using a specified equality comparer.

Template Parameters

source_t

The type of the elements of source.

Parameters

source	A sequence in which to locate a value.
value	The value to locate in the sequence.
comparer	An equality comparer to compare values.

Returns

true if the source sequence contains an element that has the specified value; otherwise, false.

contains() [3/3]

template<xtd::iterable source_t, xtd::func_callable< bool, xtd::iterable_value_type< source_t >, xtd::iterable_value_type< source_t > > equater_t>

auto xtd::linq::enumerable::contains ( source_t && source, const xtd::iterable_value_type< source_t > & value, equater_t && equater ) -> bool

staticnodiscardnoexcept

Determines whether a sequence contains a specified element by using a specified equality comparer.

Template Parameters

source_t

The type of the elements of source.

Parameters

source	A sequence in which to locate a value.
value	The value to locate in the sequence.
equater	An equality comparer to compare values.

Returns

true if the source sequence contains an element that has the specified value; otherwise, false.

count() [1/3]

template<xtd::iterable source_t>

auto xtd::linq::enumerable::count ( source_t && source ) -> xtd::usize

staticnodiscardnoexcept

Returns the number of elements in a sequence.

Template Parameters

source_t

The type of the elements of source.

Parameters

source

A sequence that contains elements to be counted.

Returns

The number of elements in the input sequence.

Examples

The following code example demonstrates how to use xtd::linq::enumerable::count <source_t>(const ienumerable <source_t>&) to count the elements in a sequence.

#include <xtd/xtd>
 
auto main() -> int {
  auto fruits = array {"apple", "banana", "mango", "orange", "passionfruit", "grape"};
  
  auto number_of_fruits = fruits.enumerable::count();
  console::write_line("There are {0} fruits in the collection.", number_of_fruits);
}
 
// This code produces the following output :
//
// There are 6 fruits in the collection.

count() [2/3]

template<xtd::iterable source_t, xtd::predicate_callable< xtd::iterable_value_type< source_t > > predicate_t>

auto xtd::linq::enumerable::count ( source_t && source, predicate_t && predicate ) -> xtd::usize

staticnodiscardnoexcept

Returns a number that represents how many elements in the specified sequence satisfy a condition.

Template Parameters

source_t

The type of the elements of source.

Parameters

source	A sequence that contains elements to be tested and counted.
predicate	A function to test each element for a condition.

Returns

A number that represents how many elements in the sequence satisfy the condition in the predicate function.

Examples

The following code example demonstrates how to use xtd::linq::enumerable::count <source_t>(const ienumerable <source_t>&, const std::function <bool(const source_t&)>&) to count the elements in a sequence that satisfy a condition.

#include <xtd/xtd>
 
struct pet {
  string name;
  bool vaccinated = false;
};
 
auto main() -> int {
  auto pets = array {
    pet {.name = "Barley", .vaccinated = true},
    pet {.name = "Boots", .vaccinated = false},
    pet {.name = "Whiskers", .vaccinated = false}
  };
  
  auto number_unvaccinated = pets.count(_*member(&pet::vaccinated) == false);
  console::write_line("There are {} unvaccinated animals.", number_unvaccinated);
}
 
// This code produces the following output :
//
// There are 2 unvaccinated animals.

count() [3/3]

template<xtd::iterable source_t>

auto xtd::linq::enumerable::count ( source_t && source, xtd::iterable_value_type< source_t > && value ) -> xtd::usize

staticnodiscardnoexcept

Returns the number of elements with the specified value.

Template Parameters

source_t

The type of the elements of source.

Parameters

source	A sequence that contains elements to be tested and counted.
value	The value to search for.

Returns

A number representing the number of elements in the sequence that are equal to the value.

count_by() [1/3]

template<typename key_t, xtd::iterable source_t, xtd::callable< key_t, xtd::iterable_value_type< source_t > > key_selector_t>

auto xtd::linq::enumerable::count_by ( source_t && source, key_selector_t && key_selector ) -> xtd::collections::generic::enumerable_generator< xtd::collections::generic::key_value_pair< key_t, xtd::usize > >

staticnodiscardnoexcept

Returns the count of elements in the source sequence grouped by key.

Template Parameters

source_t	The type of the elements of source.
key_t	The type of the key returned by key_selector.

Parameters

source	A sequence that contains elements to be counted.
key_selector	A function to extract the key for each element.

Returns

An enumerable containing the frequencies of each key occurrence in source.

Examples

The following code example demonstrates how to use xtd::linq::enumerable::count_by <source_t>(const ienumerable <source_t>&, const std::function <key_t(const source_t&)>&) to count the number of elements in a sequence grouped by key.

#include <xtd/xtd>
 
struct student {
  string name;
  string score;
};
 
auto main() -> int {
  auto students = array<student> {
    {"Alice", "A"},
    {"Bob", "B"},
    {"Charlie", "C"},
    {"David", "B"},
    {"Eve", "A"}
  };
  
  auto query = students.count_by<string>(_*member(&student::score));
 
  for (const auto& [score, count] : query)
    console::write_line("Students with a {}-score: {}", score, count);
}
 
// This code produces the following output :
//
// Students with a A-score: 2
// Students with a B-score: 2
// Students with a C-score: 1

count_by() [2/3]

template<typename key_t, xtd::iterable source_t, xtd::callable< key_t, xtd::iterable_value_type< source_t > > key_selector_t>

auto xtd::linq::enumerable::count_by ( source_t && source, key_selector_t && key_selector, const iequality_comparer< key_t > & key_comparer ) -> xtd::collections::generic::enumerable_generator< xtd::collections::generic::key_value_pair< key_t, xtd::usize > >

staticnodiscardnoexcept

Returns the count of elements in the source sequence grouped by key.

Template Parameters

source_t	The type of the elements of source.
key_t	The type of the key returned by key_selector.

Parameters

source	A sequence that contains elements to be counted.
key_selector	A function to extract the key for each element.
key_comparer	An equality comparer to compare keys.

Returns

An enumerable containing the frequencies of each key occurrence in source.

Examples

The following code example demonstrates how to use xtd::linq::enumerable::count_by <source_t>(const ienumerable <source_t>&, const std::function <key_t(const source_t&)>&) to count the number of elements in a sequence grouped by key.

#include <xtd/xtd>
 
struct student {
  string name;
  string score;
};
 
auto main() -> int {
  auto students = array<student> {
    {"Alice", "A"},
    {"Bob", "B"},
    {"Charlie", "C"},
    {"David", "B"},
    {"Eve", "A"}
  };
  
  auto query = students.count_by<string>(_*member(&student::score));
 
  for (const auto& [score, count] : query)
    console::write_line("Students with a {}-score: {}", score, count);
}
 
// This code produces the following output :
//
// Students with a A-score: 2
// Students with a B-score: 2
// Students with a C-score: 1

count_by() [3/3]

template<typename key_t, xtd::iterable source_t, xtd::callable< key_t, xtd::iterable_value_type< source_t > > key_selector_t, xtd::callable< bool, key_t, key_t > key_equater_t>

auto xtd::linq::enumerable::count_by ( source_t && source, key_selector_t && key_selector, key_equater_t && key_equater ) -> xtd::collections::generic::enumerable_generator< xtd::collections::generic::key_value_pair< key_t, xtd::usize > >

staticnodiscardnoexcept

Returns the count of elements in the source sequence grouped by key.

Template Parameters

source_t	The type of the elements of source.
key_t	The type of the key returned by key_selector.

Parameters

source	A sequence that contains elements to be counted.
key_selector	A function to extract the key for each element.
key_equater	An equality comparer to compare keys.

Returns

An enumerable containing the frequencies of each key occurrence in source.

Examples

The following code example demonstrates how to use xtd::linq::enumerable::count_by <source_t>(const ienumerable <source_t>&, const std::function <key_t(const source_t&)>&) to count the number of elements in a sequence grouped by key.

#include <xtd/xtd>
 
struct student {
  string name;
  string score;
};
 
auto main() -> int {
  auto students = array<student> {
    {"Alice", "A"},
    {"Bob", "B"},
    {"Charlie", "C"},
    {"David", "B"},
    {"Eve", "A"}
  };
  
  auto query = students.count_by<string>(_*member(&student::score));
 
  for (const auto& [score, count] : query)
    console::write_line("Students with a {}-score: {}", score, count);
}
 
// This code produces the following output :
//
// Students with a A-score: 2
// Students with a B-score: 2
// Students with a C-score: 1

Note

Need to include list file #include <xtd/collections/generic/list>.

default_if_empty() [1/2]

template<xtd::iterable source_t>

auto xtd::linq::enumerable::default_if_empty ( source_t && source ) -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >

staticnodiscardnoexcept

Returns the elements of the specified sequence or the type parameter's default value in a singleton collection if the sequence is empty.

Template Parameters

source_t

The type of the elements of source.

Parameters

source

The sequence to return a default value for if it is empty.

Returns

An xtd::collections::generic::ienumerable <type_t> that contains default_value if source is empty; otherwise, source.

Examples

The following code example demonstrates how to use xtd::linq::enumerable::default_if_empty <source_t>(const ienumerable <source_t>&) to return a default value if a sequence is empty.

#include <xtd/xtd>
 
struct pet {
  string name;
  int age = 0;
  
  friend bool operator ==(const pet& lhs, const pet& rhs) noexcept {
    return lhs.name == rhs.name && lhs.age == rhs.age;
  }
};
 
auto main() -> int {
  auto pets1 = array<pet> {
    {.name="Barley", .age=8},
    {.name="Boots", .age=4},
    {.name="Whiskers", .age=1}
  };
  for (const auto& [name, age] : pets1.default_if_empty())
    console::write_line("pet {{name={}, age={}}}", name, age);
  console::write_line();
  
  auto pets2 = array<pet> {};
  for (const auto& [name, age] : pets2.default_if_empty())
    console::write_line("pet {{name={}, age={}}}", name, age);
  console::write_line();
}
 
// This code produces the following output :
//
// pet {name=Barley, age=8}
// pet {name=Boots, age=4}
// pet {name=Whiskers, age=1}
//
// pet {name=, age=0}
//

default_if_empty() [2/2]

template<xtd::iterable source_t>

auto xtd::linq::enumerable::default_if_empty ( source_t && source, const xtd::iterable_value_type< source_t > & default_value ) -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >

staticnodiscardnoexcept

Returns the elements of the specified sequence or the specified value in a singleton collection if the sequence is empty.

Template Parameters

source_t

The type of the elements of source.

Parameters

source	The sequence to return a default value for if it is empty.
default_value	The value to return if the sequence is empty.

Returns

An xtd::collections::generic::ienumerable <type_t> that contains default_value if source is empty; otherwise, source.

Examples

The following code example demonstrates how to use xtd::linq::enumerable::default_if_empty <source_t>(const ienumerable <source_t>&, const source_t&) to return a default value if a sequence is empty.

#include <xtd/xtd>
 
struct pet {
  string name;
  int age = 0;
  
  static const pet default_pet;
  
  friend bool operator ==(const pet& lhs, const pet& rhs) noexcept {
    return lhs.name == rhs.name && lhs.age == rhs.age;
  }
};
 
const pet pet::default_pet {.name = "Default pet", .age = 0};
 
auto main() -> int {
  auto pets1 = array<pet> {
    {.name="Barley", .age=8},
    {.name="Boots", .age=4},
    {.name="Whiskers", .age=1}
  };
  for (const auto& [name, age] : pets1.default_if_empty(pet::default_pet))
    console::write_line("pet {{name={}, age={}}}", name, age);
  console::write_line();
  
  auto pets2 = array<pet> {};
  for (const auto& [name, age] : pets2.default_if_empty(pet::default_pet))
    console::write_line("pet {{name={}, age={}}}", name, age);
  console::write_line();
}
 
// This code produces the following output :
//
// pet {name=Barley, age=8}
// pet {name=Boots, age=4}
// pet {name=Whiskers, age=1}
//
// pet {name=Default pet, age=0}
//

distinct() [1/3]

template<xtd::iterable source_t>

auto xtd::linq::enumerable::distinct ( source_t && source ) -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >

staticnodiscardnoexcept

Returns distinct elements from a sequence by using the default equality comparer to compare values.

Parameters

source

The sequence to remove duplicate elements from.

Returns

An enumerable distinct elements from the source sequence.

Note

Need to include list file #include <xtd/collections/generic/list>.

distinct() [2/3]

template<xtd::iterable source_t>

auto xtd::linq::enumerable::distinct ( source_t && source, const iequality_comparer< source_t > & comparer ) -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >

staticnodiscardnoexcept

Returns distinct elements from a sequence by using a specified xtd::collections::generic::iequality_comparer <type_t> to compare values.

Parameters

source	The sequence to remove duplicate elements from.
comparer	An xtd::collections::generic::iequality_comparer <type_t> to compare values.

Returns

An enumerable distinct elements from the source sequence.

distinct() [3/3]

template<xtd::iterable source_t, xtd::func_callable< bool, xtd::iterable_value_type< source_t >, xtd::iterable_value_type< source_t > > equater_t>

auto xtd::linq::enumerable::distinct ( source_t && source, equater_t && equater ) -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >

staticnodiscardnoexcept

Returns distinct elements from a sequence by using a specified xtd::collections::generic::iequality_comparer <type_t> to compare values.

Parameters

source	The sequence to remove duplicate elements from.
equater	An equality comparer to compare values.

Returns

An enumerable distinct elements from the source sequence.

Note

Need to include list file #include <xtd/collections/generic/list>.

first_or_default() [1/4]

template<xtd::iterable source_t, xtd::predicate_callable< xtd::iterable_value_type< source_t > > prediacte_t>

auto xtd::linq::enumerable::first_or_default ( source_t && source, prediacte_t && predicate, xtd::iterable_value_type< source_t > && default_value ) -> xtd::iterable_value_type< source_t >

staticnodiscardnoexcept

Returns the first element of the sequence that satisfies a condition, or a specified default value if no such element is found.

Template Parameters

source_t

The type of the elements of source.

Parameters

source	A sequence of values to return an element from.
predicate	A function to test each element for a condition.
default_value	The default value to return if the sequence is empty.

Returns

default_value if source is empty or if no element passes the test specified by predicate; otherwise, the first element in source that passes the test specified by predicate.

first_or_default() [2/4]

template<xtd::iterable source_t, xtd::predicate_callable< xtd::iterable_value_type< source_t > > prediacte_t>

auto xtd::linq::enumerable::first_or_default ( source_t && source, prediacte_t && predicate ) -> xtd::iterable_value_type< source_t >

staticnodiscardnoexcept

Returns the first element of the sequence that satisfies a condition or a default value if no such element is found.

Template Parameters

source_t

The type of the elements of source.

Parameters

source	A sequence of values to return an element from.
predicate	A function to test each element for a condition.

Returns

default source_t {} if source is empty or if no element passes the test specified by predicate; otherwise, the first element in source that passes the test specified by predicate.

first_or_default() [3/4]

template<xtd::iterable source_t>

auto xtd::linq::enumerable::first_or_default ( source_t && source, xtd::iterable_value_type< source_t > && default_value ) -> xtd::iterable_value_type< source_t >

staticnodiscardnoexcept

Returns the first element of the sequence that satisfies a condition or a default value if no such element is found.

Template Parameters

source_t

The type of the elements of source.

Parameters

source	A sequence of values to return an element from.
default_value	The default value to return if the sequence is empty.

Returns

default_value if source is empty or if no element passes the test specified by predicate; otherwise, the first element in source that passes the test specified by predicate.

first_or_default() [4/4]

template<xtd::iterable source_t>

auto xtd::linq::enumerable::first_or_default ( source_t && source ) -> xtd::iterable_value_type< source_t >

staticnodiscardnoexcept

Returns the first element of the sequence that satisfies a condition or a default value if no such element is found.

Template Parameters

source_t

The type of the elements of source.

Parameters

source

A sequence of values to return an element from.

Returns

default source_t {} if source is empty or if no element passes the test specified by predicate; otherwise, the first element in source that passes the test specified by predicate.

from() [1/8]

template<xtd::iterable source_t>

auto xtd::linq::enumerable::from ( source_t && source )

staticnodiscardnoexcept

Returns the input typed as xtd::collections::generic::ienumerable <type_t>.

Template Parameters

source_t

The type of the elements of source.

Parameters

source

A sequence of values.

Returns

The input sequence typed as xtd::collections::generic::ienumerable <type_t>.

Remarks

Same as as_enemerable(const ienumerable<source_t>& source).

Examples

The following code example demonstrates how to use xtd::linq::from to create a sequence of values.

#include <xtd/xtd>
 
auto main() -> int {
  auto items = array {"One", "Two", "Three", "Four", "Five"};
  const auto& enumerable = from(items);
  auto enumerator = enumerable.get_enumerator();
  
  while (enumerator.move_next())
    console::write_line(enumerator.current());
}
 
// This code produces the following output :
//
// One
// Two
// Three
// Four
// Five
 

Note

Need to include list file #include <xtd/collections/generic/list>.

from() [2/8]

template<xtd::iterable source_t>

auto xtd::linq::enumerable::from ( const source_t & source ) -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >

staticnodiscardnoexcept

Returns the input typed as xtd::collections::generic::ienumerable <type_t>.

Template Parameters

source_t

The type of the elements of source.

Parameters

source

A sequence of values.

Returns

The input sequence typed as xtd::collections::generic::ienumerable <type_t>.

Remarks

Same as as_enemerable(const ienumerable<source_t>& source).

Examples

The following code example demonstrates how to use xtd::linq::from to create a sequence of values.

#include <xtd/xtd>
 
auto main() -> int {
  auto items = array {"One", "Two", "Three", "Four", "Five"};
  const auto& enumerable = from(items);
  auto enumerator = enumerable.get_enumerator();
  
  while (enumerator.move_next())
    console::write_line(enumerator.current());
}
 
// This code produces the following output :
//
// One
// Two
// Three
// Four
// Five
 

from() [3/8]

template<xtd::iterable source_t>

auto xtd::linq::enumerable::from ( source_t & source ) -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >

staticnodiscardnoexcept

Returns the input typed as xtd::collections::generic::ienumerable <type_t>.

Template Parameters

source_t

The type of the elements of source.

Parameters

source

A sequence of values.

Returns

The input sequence typed as xtd::collections::generic::ienumerable <type_t>.

Remarks

Same as as_enemerable(const ienumerable<source_t>& source).

Examples

The following code example demonstrates how to use xtd::linq::from to create a sequence of values.

#include <xtd/xtd>
 
auto main() -> int {
  auto items = std::vector {"One", "Two", "Three", "Four", "Five"};
  const auto& enumerable = from(items);
  auto enumerator = enumerable.get_enumerator();
  
  while (enumerator.move_next())
    console::write_line(enumerator.current());
}
 
// This code produces the following output :
//
// One
// Two
// Three
// Four
// Five
 

from() [4/8]

template<typename value_t>

auto xtd::linq::enumerable::from ( std::initializer_list< value_t > source ) -> xtd::collections::generic::enumerable_generator< value_t >

staticnodiscardnoexcept

Returns the input typed as xtd::collections::generic::ienumerable <type_t>.

Template Parameters

source_t

The type of the elements of source.

Parameters

source

A sequence of values.

Returns

The input sequence typed as xtd::collections::generic::ienumerable <type_t>.

Remarks

Same as as_enemerable(std::initializer_list<source_t> source).

Examples

The following code example demonstrates how to use xtd::linq::from to create a sequence of values.

#include <xtd/xtd>
 
auto main() -> int {
  auto items = std::initializer_list<string> {"One", "Two", "Three", "Four", "Five"};
  const auto& enumerable = from(items);
  auto enumerator = enumerable.get_enumerator();
  
  while (enumerator.move_next())
    console::write_line(enumerator.current());
}
 
// This code produces the following output :
//
// One
// Two
// Three
// Four
// Five
 

from() [5/8]

template<std::forward_iterator iterator_t>

auto xtd::linq::enumerable::from ( iterator_t first, iterator_t last ) -> xtd::collections::generic::enumerable_generator< typename std::decay< decltype(*first)>::type >

staticnodiscardnoexcept

Returns the input typed as xtd::collections::generic::ienumerable <type_t>.

Template Parameters

input_iterator_t

The type of the source iterators.

Parameters

first	The first iterator.
last	The last iterator.

Returns

The input sequence typed as xtd::collections::generic::ienumerable <type_t>.

Example

The following code example demonstrates how to use as_enumerable <source_t>(ienumerable <source_t>) to hide a type's custom Where method when the standard query operator implementation is desired.

Remarks

Same as as_enemerable(input_iterator_t first, input_iterator_t last).

Examples

The following code example demonstrates how to use xtd::linq::from to create a sequence of values.

#include <xtd/xtd>
 
auto main() -> int {
  auto items = std::vector {"One", "Two", "Three", "Four", "Five"};
  const auto& enumerable = from(items.begin(), items.end());
  auto enumerator = enumerable.get_enumerator();
  
  while (enumerator.move_next())
    console::write_line(enumerator.current());
}
 
// This code produces the following output :
//
// One
// Two
// Three
// Four
// Five
 

from() [6/8]

template<std::forward_iterator iterator_t>

auto xtd::linq::enumerable::from ( iterator_t iterator, xtd::usize length ) -> xtd::collections::generic::enumerable_generator< typename std::decay< decltype(*iterator)>::type >

staticnodiscardnoexcept

Returns the input typed as xtd::collections::generic::ienumerable <type_t>.

Template Parameters

input_iterator_t

The type of the source iterators.

Parameters

iterator	The iterator.
legnth	The le,gth to iterate.

Returns

The input sequence typed as xtd::collections::generic::ienumerable <type_t>.

Remarks

Same as as_enemerable(input_iterator_t iterator, xtd::usize length).

Examples

The following code example demonstrates how to use xtd::linq::from to create a sequence of values.

#include <xtd/xtd>
 
auto main() -> int {
  auto items = std::vector {"One", "Two", "Three", "Four", "Five"};
  const auto& enumerable = from(items.begin(), 5);
  auto enumerator = enumerable.get_enumerator();
  
  while (enumerator.move_next())
    console::write_line(enumerator.current());
}
 
// This code produces the following output :
//
// One
// Two
// Three
// Four
// Five
 

from() [7/8]

template<typename value_t, xtd::usize length>

auto xtd::linq::enumerable::from ( const value_t(&) array[length] ) -> xtd::collections::generic::enumerable_generator< value_t >

staticnodiscardnoexcept

Returns the input typed as xtd::collections::generic::ienumerable <type_t>.

Template Parameters

source_t

The type of the source array.

Parameters

array	The native array.
legnth	The length of the array.

Returns

The input sequence typed as xtd::collections::generic::ienumerable <type_t>.

Remarks

Same as as_enemerable(const source_t (&array)[length]).

Examples

The following code example demonstrates how to use xtd::linq::from to create a sequence of values.

#include <xtd/xtd>
 
auto main() -> int {
  const char* items[] = {"One", "Two", "Three", "Four", "Five"};
  const auto& enumerable = from(items);
  auto enumerator = enumerable.get_enumerator();
  
  while (enumerator.move_next())
    console::write_line(enumerator.current());
}
 
// This code produces the following output :
//
// One
// Two
// Three
// Four
// Five
 

from() [8/8]

template<typename value_t, xtd::usize length>

auto xtd::linq::enumerable::from ( value_t(&) array[length] ) -> xtd::collections::generic::enumerable_generator< value_t >

staticnodiscardnoexcept

Returns the input typed as xtd::collections::generic::ienumerable <type_t>.

Template Parameters

source_t

The type of the source array.

Parameters

array	The native array.
legnth	The length of the array.

Returns

The input sequence typed as xtd::collections::generic::ienumerable <type_t>.

Remarks

Same as as_enemerable(const source_t (&array)[length]).

Examples

The following code example demonstrates how to use xtd::linq::from to create a sequence of values.

#include <xtd/xtd>
 
auto main() -> int {
  const char* items[] = {"One", "Two", "Three", "Four", "Five"};
  const auto& enumerable = from(items);
  auto enumerator = enumerable.get_enumerator();
  
  while (enumerator.move_next())
    console::write_line(enumerator.current());
}
 
// This code produces the following output :
//
// One
// Two
// Three
// Four
// Five
 

max() [1/3]

template<xtd::iterable source_t>
requires xtd::numeric<xtd::iterable_value_type<source_t>>

auto xtd::linq::enumerable::max ( source_t && source ) -> xtd::iterable_value_type< source_t >

staticnodiscard

Returns the maximum value in a sequence of xtd::numeric values.

Parameters

sources

A sequence of xtd::numeric values to determine the maximum value of.

Returns

A value of xtd::numeric that corresponds to the maximum value in the sequence.

max() [2/3]

template<xtd::iterable source_t, xtd::callable< xtd::iterable_value_type< source_t >, xtd::iterable_value_type< source_t > > selector_t>
requires xtd::numeric<xtd::iterable_value_type<source_t>>

auto xtd::linq::enumerable::max ( source_t && source, selector_t && selector ) -> xtd::iterable_value_type< source_t >

staticnodiscard

Returns the maximum value in a sequence of xtd::numeric values.

Parameters

sources	A sequence of xtd::numeric values to determine the maximum value of.
selector	A transform function to apply to each element.

Returns

A value of xtd::numeric that corresponds to the maximum value in the sequence.

max() [3/3]

template<typename result_t, xtd::iterable source_t, xtd::callable< result_t, xtd::iterable_value_type< source_t > > selector_t>
requires xtd::numeric<xtd::iterable_value_type<source_t>>

auto xtd::linq::enumerable::max ( source_t && source, selector_t && selector ) -> result_t

staticnodiscard

Returns the maximum value in a sequence of xtd::numeric values.

Parameters

sources	A sequence of xtd::numeric values to determine the maximum value of.
selector	A transform function to apply to each element.

Returns

A value of xtd::numeric that corresponds to the maximum value in the sequence.

min() [1/3]

template<xtd::iterable source_t>
requires xtd::numeric<xtd::iterable_value_type<source_t>>

auto xtd::linq::enumerable::min ( source_t && source ) -> xtd::iterable_value_type< source_t >

staticnodiscard

Returns the minimum value in a sequence of xtd::numeric values.

Parameters

sources

A sequence of xtd::numeric values to determine the minimum value of.

Returns

A value of xtd::numeric that corresponds to the minimum value in the sequence.

min() [2/3]

template<xtd::iterable source_t, xtd::callable< xtd::iterable_value_type< source_t >, xtd::iterable_value_type< source_t > > selector_t>
requires xtd::numeric<xtd::iterable_value_type<source_t>>

auto xtd::linq::enumerable::min ( source_t && source, selector_t && selector ) -> xtd::iterable_value_type< source_t >

staticnodiscard

Returns the minimum value in a sequence of xtd::numeric values.

Parameters

sources	A sequence of xtd::numeric values to determine the minimum value of.
selector	A transform function to apply to each element.

Returns

A value of xtd::numeric that corresponds to the minimum value in the sequence.

min() [3/3]

template<typename result_t, xtd::iterable source_t, xtd::callable< result_t, xtd::iterable_value_type< source_t > > selector_t>
requires xtd::numeric<xtd::iterable_value_type<source_t>>

auto xtd::linq::enumerable::min ( source_t && source, selector_t && selector ) -> result_t

staticnodiscard

Returns the minimum value in a sequence of xtd::numeric values.

Parameters

sources	A sequence of xtd::numeric values to determine the minimum value of.
selector	A transform function to apply to each element.

Returns

A value of xtd::numeric that corresponds to the minimum value in the sequence.

order() [1/3]

template<xtd::iterable source_t>

auto xtd::linq::enumerable::order ( source_t && source ) -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >

staticnodiscard

Sorts the elements of a sequence in ascending order.

Parameters

source

A sequence of values to order.

Returns

An xtd::collections::generic::ienumerable <source_t> whose elements are sorted.

order() [2/3]

template<xtd::iterable source_t>

auto xtd::linq::enumerable::order ( source_t && source, const xtd::collections::generic::icomparer< xtd::iterable_value_type< source_t > > & comparer ) -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >

staticnodiscard

Sorts the elements of a sequence in ascending order.

Parameters

source	A sequence of values to order.
comparer	An xtd::collections::generic::icomparer <source_t> to compare keys.

Returns

An xtd::collections::generic::ienumerable <source_t> whose elements are sorted.

order() [3/3]

template<xtd::iterable source_t, xtd::func_callable< bool, xtd::iterable_value_type< source_t >, xtd::iterable_value_type< source_t > > lesser_t>

auto xtd::linq::enumerable::order ( source_t && source, lesser_t && lesser ) -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >

staticnodiscard

Sorts the elements of a sequence in ascending order.

Parameters

source	A sequence of values to order.
lesser	An xtd::collections::generic::icomparer <source_t> to compare keys.

Returns

An xtd::collections::generic::ienumerable <source_t> whose elements are sorted.

Note

Need to include list file #include <xtd/collections/generic/list>.

order_by() [1/2]

template<typename key_t, xtd::iterable source_t, xtd::callable< key_t, xtd::iterable_value_type< source_t > > key_selector_t>

auto xtd::linq::enumerable::order_by ( source_t && source, key_selector_t && key_selector ) -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >

staticnodiscard

Sorts the elements of a sequence in ascending order according to a key.

Parameters

source	A sequence of values to order.
key_selector	A function to extract a key from an element.

Examples

The following code example demonstrates how to use order_by<key_t, source_t>(ienumerable <source_t>, std::function<key_t(const source_t&)>) to sort the elements of a sequence.

Note

Need to include list file #include <xtd/collections/generic/list>.

order_by() [2/2]

template<xtd::iterable source_t, xtd::callable< xtd::iterable_value_type< source_t >, xtd::iterable_value_type< source_t > > key_selector_t>

auto xtd::linq::enumerable::order_by ( source_t && source, key_selector_t && key_selector ) -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >

staticnodiscard

Sorts the elements of a sequence in ascending order according to a key.

Parameters

source	A sequence of values to order.
key_selector	A function to extract a key from an element.

Examples

The following code example demonstrates how to use order_by<source_t, source_t>(ienumerable <source_t>, std::function<source_t(const source_t&)>) to sort the elements of a sequence.

Note

Need to include list file #include <xtd/collections/generic/list>.

order_by_descending() [1/2]

template<typename key_t, xtd::iterable source_t, xtd::callable< key_t, xtd::iterable_value_type< source_t > > key_selector_t>

auto xtd::linq::enumerable::order_by_descending ( source_t && source, key_selector_t && key_selector ) -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >

staticnodiscard

Sorts the elements of a sequence in descending order according to a key.

Parameters

source	A sequence of values to order.
key_selector	A function to extract a key from an element.

Examples

The following code example demonstrates how to use order_by<key_t, source_t>(ienumerable <source_t>, std::function<key_t(const source_t&)>) to sort the elements of a sequence.

Note

Need to include list file #include <xtd/collections/generic/list>.

order_by_descending() [2/2]

template<xtd::iterable source_t, xtd::callable< xtd::iterable_value_type< source_t >, xtd::iterable_value_type< source_t > > key_selector_t>

auto xtd::linq::enumerable::order_by_descending ( source_t && source, key_selector_t && key_selector ) -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >

staticnodiscard

Sorts the elements of a sequence in descending order according to a key.

Parameters

source	A sequence of values to order.
key_selector	A function to extract a key from an element.

Examples

The following code example demonstrates how to use order_by<source_t, source_t>(ienumerable <source_t>, std::function<source_t(const source_t&)>) to sort the elements of a sequence.

Note

Need to include list file #include <xtd/collections/generic/list>.

range() [1/3]

template<xtd::integer integer_t>

auto xtd::linq::enumerable::range ( integer_t count ) -> xtd::collections::generic::enumerable_generator< integer_t >

staticnodiscard

Generates a sequence of integral numbers within a specified range.

Parameters

count

The number of sequential integers to generate.

Returns

An xtd::collections::generic::ienumerable <xtd::int32> that contains a range of sequential integral numbers.

Exceptions

xtd::argument_out_of_range_exception

`count` is less than 0.

Examples

The following code example demonstrates how to use xtd::linq::enumerable::range to generate a sequence of values.

#include <xtd/xtd>
 
auto main() -> int {
  auto squares = enumerable::range(1, 10).select(_ * _);
  
  for (auto num : squares)
    console::write_line(num);
}
 
// This code produces the following output :
//
// 1
// 4
// 9
// 16
// 25
// 36
// 49
// 64
// 81
// 100

range() [2/3]

template<xtd::integer integer_t>

auto xtd::linq::enumerable::range ( integer_t start, integer_t count ) -> xtd::collections::generic::enumerable_generator< integer_t >

staticnodiscard

Generates a sequence of integral numbers within a specified range.

Parameters

start	The value of the first integer in the sequence.
count	The number of sequential integers to generate.

Returns

An xtd::collections::generic::ienumerable <xtd::int32> that contains a range of sequential integral numbers.

Exceptions

xtd::argument_out_of_range_exception

`count` is less than 0.

Examples

The following code example demonstrates how to use xtd::linq::enumerable::range to generate a sequence of values.

#include <xtd/xtd>
 
auto main() -> int {
  auto squares = enumerable::range(1, 10).select(_ * _);
  
  for (auto num : squares)
    console::write_line(num);
}
 
// This code produces the following output :
//
// 1
// 4
// 9
// 16
// 25
// 36
// 49
// 64
// 81
// 100

range() [3/3]

template<xtd::integer integer_t>

auto xtd::linq::enumerable::range ( integer_t start, integer_t count, integer_t step ) -> xtd::collections::generic::enumerable_generator< integer_t >

staticnodiscard

Generates a sequence of integral numbers within a specified range and step.

Parameters

start	The value of the first integer in the sequence.
count	The number of sequential integers to generate.
step	The integer number specifying the incrementation.

Returns

An xtd::collections::generic::ienumerable that contains a range of sequential integral numbers.

Exceptions

xtd::argument_out_of_range_exception

`count` is less than 0.

select() [1/2]

template<typename result_t, xtd::iterable source_t>

auto xtd::linq::enumerable::select ( source_t && source, auto && selector ) -> xtd::collections::generic::enumerable_generator< result_t >

staticnodiscard

Projects each element of a sequence into a new form.

Template Parameters

result_t	The type of the resulting value.
source_t	The type of the elements of source.

Parameters

source	A sequence of values to invoke a transform function on.
selector	A transform function to apply to each element.

Returns

An xtd::collections::generic::ienumerable <type_t> whose elements are the result of invoking the transform function on each element of source.

Examples

The following code example demonstrates how to use xtd::linq::enumerable::select <source_t, result_t>(const ienumerable <source_t>&, const std::function <result_t(const source_t&)>&) to project over a sequence of values.

#include <xtd/xtd>
 
auto main() -> int {
  auto fruits = array<string> {"apple", "banana", "mango", "orange", "passionfruit", "grape"};
  
  const auto& query = fruits.select<std::tuple<usize, string>>([](auto&& fruit, auto index) {
    return std::make_tuple(index, fruit.substring(0, index));
  });
 
  for (const auto& [index, str] : query)
    console::write_line("{{ index = {}, str = {} }}", index, str);
}
 
// This code produces the following output :
//
// { index = 0, str =  }
// { index = 1, str = b }
// { index = 2, str = ma }
// { index = 3, str = ora }
// { index = 4, str = pass }
// { index = 5, str = grape }

select() [2/2]

template<xtd::iterable source_t>

auto xtd::linq::enumerable::select ( source_t && source, auto && selector ) -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >

staticnodiscard

Projects each element of a sequence into a new form by incorporating the element's index.

Template Parameters

result_t	The type of the resulting value.
source_t	The type of the elements of source.

Parameters

source	A sequence of values to invoke a transform function on.
selector	A transform function to apply to each source element; the second parameter of the function represents the index of the source element.

Returns

An xtd::collections::generic::ienumerable <type_t> whose elements are the result of invoking the transform function on each element of source.

Examples

The following code example demonstrates how to use xtd::linq::enumerable::select <source_t, result_t>(const ienumerable <source_t>&, const std::function <result_t(const source_t&, xtd::usize)>&) to project over a sequence of values and use the index of each element.

#include <xtd/xtd>
 
auto main() -> int {
  auto fruits = array<string> {"apple", "banana", "mango", "orange", "passionfruit", "grape"};
  
  const auto& query = fruits.select<std::tuple<usize, string>>([](auto&& fruit, auto index) {
    return std::make_tuple(index, fruit.substring(0, index));
  });
 
  for (const auto& [index, str] : query)
    console::write_line("{{ index = {}, str = {} }}", index, str);
}
 
// This code produces the following output :
//
// { index = 0, str =  }
// { index = 1, str = b }
// { index = 2, str = ma }
// { index = 3, str = ora }
// { index = 4, str = pass }
// { index = 5, str = grape }

shuffle()

template<xtd::forward_iterable source_t>

auto xtd::linq::enumerable::shuffle ( source_t && source ) -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >

inlinestaticnodiscard

Shuffles the order of the elements of a sequence.

Parameters

source

A sequence of values to shuffle.

Returns

A sequence whose elements correspond to those of the input sequence in randomized order.

Note

Need to include random file #include <xtd/random>.

skip()

template<xtd::iterable source_t>

auto xtd::linq::enumerable::skip ( source_t && source, xtd::usize count ) -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >

staticnodiscard

Bypasses a specified number of elements in a sequence and then returns the remaining elements.

Parameters

source	A sequznce of values to return elements from.
count	The number of elements to skip before returning the remaining elements.

Returns

A sequence that contains the elements that occur after the specified index in the input sequence.

skip_while()

template<xtd::iterable source_t>

auto xtd::linq::enumerable::skip_while ( source_t && source, auto && predicate ) -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >

staticnodiscard

Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements.

Parameters

source	A sequence of values to return elements from.
predicate	A function to test each element for a condition.

Returns

A sequence that contains the elements from the input sequence starting at the first element in the linear series that does not pass the test specified by predicate.

Examples

The following code example demonstrates how to use xtd::linq::enumerable::skip_while to skip elements of an array as long as a condition is true.

#include <xtd/xtd>
 
auto main() -> int {
  auto grades = array {59, 82, 70, 56, 92, 98, 85};
  
  auto lower_grades = grades.order(_1 > _2).skip_while(_ >= 80).to_array();
  
  println("All grades below 80:");
  for (auto grade : lower_grades)
    println(grade);
}
 
// This code produces the following output :
//
// All grades below 80:
// 70
// 59
// 56

take() [1/2]

template<xtd::iterable source_t>

auto xtd::linq::enumerable::take ( source_t && source, xtd::usize count ) -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >

staticnodiscard

Returns a specified number of contiguous elements from the start of a sequence.

Parameters

source	A sequence of values to return elements from.
count	The number of elements to return.

Returns

A sequence that contains the specified number of elements from the start of the input sequence.

take() [2/2]

template<xtd::iterable source_t>

auto xtd::linq::enumerable::take ( source_t && source, const xtd::range & range ) -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >

staticnodiscard

Returns a specified number of contiguous elements from the start of a sequence.

Parameters

source	A sequence of values to return elements from.
range	The range of elements to return.

Returns

A sequence that contains the specified number of elements from the start of the input sequence.

Note

Need to include list file #include <xtd/range>.

take_while()

template<xtd::iterable source_t>

auto xtd::linq::enumerable::take_while ( source_t && source, auto && predicate ) -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >

staticnodiscard

Returns elements from a sequence as long as a specified condition is true, and then skips the remaining elements.

Parameters

source	A sequence to return elements from.
predicate	A function to test each element for a condition.

Returns

A sequence that contains the elements from the input sequence that occur before the element at which the test no longer passes.

Examples

The following code example demonstrates how to use xtd::linq::enumerable::take_while to return elements from the start of a sequence as long as a condition is true.

#include <xtd/xtd>
 
auto main() -> int {
  auto fruits = array {"apple", "banana", "mango", "orange", "passionfruit", "grape"};
  
  auto query = fruits.take_while([](auto&& fruit) {return string::compare("orange", fruit, true) != 0;}).to_array();
  
  for (auto fruit : query)
    println(fruit);
}
 
// This code produces the following output :
//
// apple
// banana
// mango

to_array()

template<typename source_t>

auto xtd::linq::enumerable::to_array ( const ienumerable< source_t > & source )

staticnodiscard

Creates a xtd::array <type_t> from an xtd::collections::generic::ienumerable <type_t>.

Template Parameters

source_t

The type of the elements of source.

Parameters

source

The xtd::collections::generic::ienumerable <type_t> to create a xtd::collections::generic::list <type_t> from.

Returns

A xtd::array <type_t> that contains elements from the input sequence.

Remarks

The xtd::collections::generic::list include file #include <xtd/array> is needeed to use this method.

Examples

The following code example demonstrates how to use xtd::linq::enumerable::to_array to force immediate query evaluation and return a xtd::array <type_t> that contains the query results.

Note

Need to include array file #include <xtd/array>.

to_list()

template<typename source_t>

auto xtd::linq::enumerable::to_list ( const ienumerable< source_t > & source )

staticnodiscard

Creates a xtd::collections::generic::list <type_t> from an xtd::collections::generic::ienumerable <type_t>.

Template Parameters

source_t

The type of the elements of source.

Parameters

source

The xtd::collections::generic::ienumerable <type_t> to create a xtd::collections::generic::list <type_t> from.

Returns

A xtd::collections::generic::list <type_t> that contains elements from the input sequence.

Remarks

The xtd::collections::generic::list include file #include <xtd/collections/generic/lists> is needeed to use this method.

Examples

The following code example demonstrates how to use xtd::linq::enumerable::to_list to force immediate query evaluation and return a xtd::collections::generic::list <type_t> that contains the query results.

#include <xtd/xtd>
 
auto main() -> int {
  auto fruits = array<string> {"apple", "passionfruit", "banana", "mango", "orange", "blueberry", "grape", "strawberry"};
  
  auto lengths = fruits.select<usize>(_*method(&string::length)).to_list();
  
  for (auto length : lengths)
    console::write_line(length);
}
 
// This code produces the following output :
//
// 5
// 12
// 6
// 5
// 6
// 9
// 5
// 10

Note

Need to include list file #include <xtd/collections/generic/list>.

where()

template<xtd::iterable source_t>

auto xtd::linq::enumerable::where ( source_t && source, auto && predicate ) -> xtd::collections::generic::enumerable_generator< xtd::iterable_value_type< source_t > >

staticnodiscard

Filters a sequence of values based on a predicate.

Template Parameters

source_t

The type of the elements of source.

Parameters

source	A sequence of values to filter.
predicate	A function to test each element for a condition.

Returns

An xtd::collections::generic::ienumerable <type_t> that contains elements from the input sequence that satisfy the condition.

Examples

The following code example demonstrates how to use xtd::linq::enumerable::where <source_t>(const ienumerable <source_t>&, const std::function<bool (const source_t&)>&) to filter a sequence.

#include <xtd/xtd>
 
auto main() -> int {
  auto fruits = array {"apple"_s, "passionfruit"_s, "banana"_s, "mango"_s, "orange"_s, "blueberry"_s, "grape"_s, "strawberry"_s};
  
  auto query = fruits.where(_*method(&string::length) < 6);
  
  for (const auto& fruit : query)
    console::write_line(fruit);
}
 
// This code produces the following output :
//
// apple
// mango
// grape

Examples

The following code example demonstrates how to use xtd::linq::enumerable::where <source_t>(const ienumerable <source_t>&, const std::function<bool (const source_t&, xtd::usize)>&) to filter a sequence based on a predicate that involves the index of each element.

#include <xtd/xtd>
 
auto main() -> int {
  auto numbers = array {0, 30, 20, 15, 90, 85, 40, 75};
  
  auto query = numbers.where(_1 <= _2 * 10);
  
  for (const auto& number : query)
    console::write_line(number);
}
 
// This code produces the following output :
//
// 0
// 20
// 15
// 40

---

The documentation for this class was generated from the following files:

• xtd.core/include/xtd/linq/enumerable_.hpp
• xtd.core/include/xtd/random.hpp