View source for cpp/ranges/adjacent view

{{cpp/ranges/view title|adjacent|{{small|views::}}pairwise}}
{{cpp/ranges/adjacent_view/navbar}}
{{dcl begin}}
{{dcl header|ranges}}
{{dcl|num=1|since=c++23|1=
template< ranges::forward_range V, std::size_t N >
    requires ranges::view<V> && (N > 0)
class adjacent_view
    : public ranges::view_interface<adjacent_view<V, N>>
}}
{{dcl|num=2|since=c++23|1=
namespace views {
    template< std::size_t N >
    constexpr /* unspecified */ adjacent = /* unspecified */ ;
}
}}
{{dcl|num=3|since=c++23|1=
namespace views {
    inline constexpr auto pairwise = adjacent<2>;
}
}}
{{dcl h|Call signature}}
{{dcl|since=c++23|1=
template< ranges::viewable_range R >
    requires /* see below */
constexpr ranges::view auto adjacent<N>( R&& r );
}}
{{dcl end}}

@1@ {{tt|adjacent_view}} is a range adaptor that takes a {{lconcept|view}}, and produces a {{lconcept|view}} whose {{tti|i}}{{sup|''th''}} element (a "window") is a {{lc|std::tuple}} that holds {{tti|N}} references to the elements of the original view, from {{tti|i}}{{sup|''th''}} up to {{c|i + N - 1}}{{sup|''th''}} inclusively.

@@ Let {{tti|S}} be the size of the original view. Then the size of produced view is:
* {{c|S - N + 1}}, if {{tt|1=S >= N}},
* {{c|0}} otherwise, and the resulting view is empty.

@2@ The name {{c|views::adjacent<N>}} denotes a {{named req|RangeAdaptorObject}}. Given a subexpression {{c|e}} and a constant expression {{c|N}}, the expression {{c|views::adjacent<N>(e)}} is [[cpp/language/expressions#Expression-equivalence|expression-equivalent]] to
* {{c|((void)e, auto(views::empty<tuple<>>))}} if {{c|N}} is equal to {{c|0}} and {{c|decltype((e))}} models {{lconcept|forward_range}},
* {{c|adjacent_view<views::all_t<decltype((e))>, N>(e)}} otherwise.

@3@ The name {{c|views::pairwise}} denotes a {{named req|RangeAdaptorObject}} that behaves exactly as {{c|views::adjacent<2>}}.

{{tt|adjacent_view}} always models {{lconcept|forward_range}}, and models {{lconcept|bidirectional_range}}, {{lconcept|random_access_range}}, or {{lconcept|sized_range}} if adapted {{lconcept|view}} type models the corresponding concept.
<!--{{tt|adjacent_view}} models {{lconcept|common_range}} if-->
<!--{{cpp/ranges/cpo|views|adjacent}}-->

===Data members===
{{dsc begin}}
{{dsc hitem|Member name|Definition}}
{{dsc expos mem obj|base_|private=yes|the underlying {{lconcept|view}} of type {{tt|V}}.}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc|cpp/ranges/adaptor/dsc constructor|adjacent_view}}
{{dsc inc|cpp/ranges/adaptor/dsc begin|adjacent_view}}
{{dsc inc|cpp/ranges/adaptor/dsc end|adjacent_view}}
{{dsc inc|cpp/ranges/adaptor/dsc size|adjacent_view}}
{{cpp/ranges/view_interface/inherit|embedded=yes|size=invalid|data=invalid}}
{{dsc end}}

===Deduction guides===
(none)

===Nested classes===
{{dsc begin}}
{{dsc expos mem tclass|cpp/ranges/adjacent_view/iterator|the iterator type}}
{{dsc expos mem tclass|cpp/ranges/adjacent_view/sentinel|the sentinel type used when {{tt|adjacent_view}} is not a {{lconcept|common_range}}}}
{{dsc end}}

===Helper templates===
{{ddcl|since=c++23|1=
template< class V, size_t N >
constexpr bool ranges::enable_borrowed_range<adjacent_view<V, N>> =
    ranges::enable_borrowed_range<V>;
}}
This specialization of {{ltt|cpp/ranges/borrowed_range|ranges::enable_borrowed_range}} makes {{tt|adjacent_view}} satisfy {{lconcept|borrowed_range}} when the underlying view satisfies it.

===Notes===
{{c|views::adjacent}} only accepts foward ranges even when {{tt|N}} is {{tt|0}}.

{{cpp/ranges/adjacent vs slide}}

{{feature test macro|__cpp_lib_ranges_zip|std=C++23|value=202110L|{{c/core|ranges::zip_view}},<br>{{c/core|ranges::zip_transform_view}},<br>{{tt|ranges::adjacent_view}},<br>{{c/core|ranges::adjacent_transform_view}}}}

===Example===
{{example
|code=
#include <array>
#include <format>
#include <iostream>
#include <ranges>
#include <tuple>

int main()
{
    constexpr std::array v{1, 2, 3, 4, 5, 6};
    std::cout << "v = [1 2 3 4 5 6]\n";

    for (int i{}; std::tuple t : v {{!}} std::views::adjacent<3>)
    {
        auto [t0, t1, t2] = t;
        std::cout << std::format("e = {:<{}<!---->}[{} {} {}]\n", "", 2 * i++, t0, t1, t2);
    }
}
|output=
v = [1 2 3 4 5 6]
e = [1 2 3]
e =   [2 3 4]
e =     [3 4 5]
e =       [4 5 6]
}}

===Defect reports===
{{dr list begin}}
{{dr list item|wg=lwg|dr=4098|std=C++23|before={{c|views::adjacent<0>}} used to accept input-only ranges|after=made rejected}}
{{dr list end}}

===References===
{{ref std c++23}}
{{ref std|title=Adjacent view|id=range.adjacent|section=26.7.25}}
{{ref std end}}

===See also===
{{dsc begin}}
{{dsc inc|cpp/ranges/dsc adjacent_transform_view}}
{{dsc inc|cpp/ranges/dsc slide_view}}
{{dsc inc|cpp/ranges/dsc chunk_view}}
{{dsc inc|cpp/ranges/dsc stride_view}}
{{dsc end}}

{{langlinks|de|es|fr|it|ja|pt|ru|zh}}