std::ranges::views::take, std::ranges::take_view

template< ranges::view V >
class take_view
    : public ranges::view_interface<take_view<V>>

namespace views {
    inline constexpr /* unspecified */ take = /* unspecified */;
}

template< ranges::viewable_range R >
    requires /* see below */
constexpr ranges::view auto
    take( R&& r, ranges::range_difference_t<R> count );

template< class DifferenceType >
constexpr /* range adaptor closure */ take( DifferenceType&& count );

1) Un adaptador de rango que representa una vista de los elementos de una secuencia subyacente, comenzando desde el inicio y terminando en un límite dado.

2) views::take es un RangeAdaptorObject. La expresión views::take(e, f) produce una vista que representa los primeros f elementos de e. El resultado no es necesariamente un take_view.

views::take(e, f) es equivalente en expresión a (donde T es std::remove_cvref_t<decltype((e))> y D es ranges::range_difference_t<decltype((e))>):

• ((void)f, decay-copy(e)), si T es un ranges::empty_view, excepto que las evaluaciones de e y f se secuencian de manera indeterminada;
• U(ranges::begin(e), ranges::begin(e) + std::min<D>(ranges::distance(e), f)), si T es una especialización de std::span, std::basic_string_view, o ranges::subrange que modela tanto random_access_range como sized_range, donde U es

• std::span<typename T::element_type>, si T es una especialización de std::span;
• T, si T es una especialización de std::basic_string_view;
• ranges::subrange<ranges::iterator_t<T>>, si T es una especialización de ranges::subrange;

• ranges::iota_view(*ranges::begin(e),
*(ranges::begin(e) + std::min<D>(ranges::distance(e), f))), si T es una especialización de ranges::iota_view que modela tanto random_access_range como sized_range;

de lo contrario, si T es una especialización de ranges::repeat_view: views::repeat(*e.value_, std::min<D>(ranges::distance(e), f)), si T modela sized_range; en tal caso e se evalúa solo una vez; views::repeat(*e.value_, static_cast<D>(e)) de lo contrario;

(desde C++23)

• de lo contrario, take_view(e, f).

En todos los casos, decltype((f)) debe modelar std::convertible_to<D>.

#include <algorithm>
#include <iostream>
#include <ranges>
int main()
{
    namespace views = std::views;
    auto print = [](char x){ std::cout << x; };
    for (const char nums[]{'1', '2', '3'};
         int n : views::iota(0, 5))
    {
        std::cout << "take(" << n << "): ";
        // safely takes only upto min(n, nums.size()) elements:
        std::ranges::for_each(nums | views::take(n), print);
        std::cout << '\n';
    }
}

take(0): 
take(1): 1
take(2): 12
take(3): 123
take(4): 123