namespace std { namespace experimental { namespace ranges { inline namespace v1 {
template <class T> concept bool /* dereferenceable */ // exposition only
= requires(T& t) { {*t} -> auto&&; };
namespace {
constexpr /* unspecified */ iter_move = /* unspecified */;
constexpr /* unspecified */ iter_swap = /* unspecified */;
}
template <class> struct difference_type;
template <class T> using difference_type_t
= typename difference_type<T>::type;
template <class> struct value_type;
template <class T> using value_type_t
= typename value_type<T>::type;
template <class> struct iterator_category;
template <class T> using iterator_category_t
= typename iterator_category<T>::type;
template </* dereferenceable */ T> using reference_t
= decltype(*declval<T&>());
template </* dereferenceable */ T>
requires /* see definition */ using rvalue_reference_t
= decltype(ranges::iter_move(declval<T&>()));
template <class In>
concept bool Readable = /* see definition */;
template <class Out, class T>
concept bool Writable = /* see definition */;
template <class I>
concept bool WeaklyIncrementable = /* see definition */;
template <class I>
concept bool Incrementable = /* see definition */;
template <class I>
concept bool Iterator = /* see definition */;
template <class S, class I>
concept bool Sentinel = /* see definition */;
template <class S, class I>
constexpr bool disable_sized_sentinel = false;
template <class S, class I>
concept bool SizedSentinel = /* see definition */;
template <class I>
concept bool InputIterator = /* see definition */;
template <class I>
concept bool OutputIterator = /* see definition */;
template <class I>
concept bool ForwardIterator = /* see definition */;
template <class I>
concept bool BidirectionalIterator = /* see definition */;
template <class I>
concept bool RandomAccessIterator = /* see definition */;
template <class F, class I>
concept bool IndirectUnaryInvocable = /* see definition */;
template <class F, class I>
concept bool IndirectRegularUnaryInvocable = /* see definition */;
template <class F, class I>
concept bool IndirectUnaryPredicate = /* see definition */;
template <class F, class I1, class I2 = I1>
concept bool IndirectRelation = /* see definition */;
template <class F, class I1, class I2 = I1>
concept bool IndirectStrictWeakOrder = /* see definition */;
template <class> struct indirect_result_of;
template <class F, class... Is>
requires Invocable<F, reference_t<Is>...>
struct indirect_result_of<F(Is...)>;
template <class F>
using indirect_result_of_t
= typename indirect_result_of<F>::type;
template <Readable I, IndirectRegularUnaryInvocable<I> Proj>
struct projected;
template <WeaklyIncrementable I, class Proj>
struct difference_type<projected<I, Proj>>;
template <class In, class Out>
concept bool IndirectlyMovable = /* see definition */;
template <class In, class Out>
concept bool IndirectlyMovableStorable = /* see definition */;
template <class In, class Out>
concept bool IndirectlyCopyable = /* see definition */;
template <class In, class Out>
concept bool IndirectlyCopyableStorable = /* see definition */;
template <class I1, class I2 = I1>
concept bool IndirectlySwappable = /* see definition */;
template <class I1, class I2, class R = equal_to<>, class P1 = identity,
class P2 = identity>
concept bool IndirectlyComparable = /* see definition */;
template <class I>
concept bool Permutable = /* see definition */;
template <class I1, class I2, class Out,
class R = less<>, class P1 = identity, class P2 = identity>
concept bool Mergeable = /* see definition */;
template <class I, class R = less<>, class P = identity>
concept bool Sortable = /* see definition */;
template <class Iterator> using iterator_traits = /* see definition */;
template <Readable T> using iter_common_reference_t
= common_reference_t<reference_t<T>, value_type_t<T>&>;
struct output_iterator_tag { };
struct input_iterator_tag { };
struct forward_iterator_tag : input_iterator_tag { };
struct bidirectional_iterator_tag : forward_iterator_tag { };
struct random_access_iterator_tag : bidirectional_iterator_tag { };
namespace {
constexpr /* unspecified */ advance = /* unspecified */;
constexpr /* unspecified */ distance = /* unspecified */;
constexpr /* unspecified */ next = /* unspecified */;
constexpr /* unspecified */ prev = /* unspecified */;
}
template <BidirectionalIterator I> class reverse_iterator;
template <class I1, class I2>
requires EqualityComparableWith<I1, I2>
constexpr bool operator==(
const reverse_iterator<I1>& x,
const reverse_iterator<I2>& y);
template <class I1, class I2>
requires EqualityComparableWith<I1, I2>
constexpr bool operator!=(
const reverse_iterator<I1>& x,
const reverse_iterator<I2>& y);
template <class I1, class I2>
requires StrictTotallyOrderedWith<I1, I2>
constexpr bool operator<(
const reverse_iterator<I1>& x,
const reverse_iterator<I2>& y);
template <class I1, class I2>
requires StrictTotallyOrderedWith<I1, I2>
constexpr bool operator>(
const reverse_iterator<I1>& x,
const reverse_iterator<I2>& y);
template <class I1, class I2>
requires StrictTotallyOrderedWith<I1, I2>
constexpr bool operator>=(
const reverse_iterator<I1>& x,
const reverse_iterator<I2>& y);
template <class I1, class I2>
requires StrictTotallyOrderedWith<I1, I2>
constexpr bool operator<=(
const reverse_iterator<I1>& x,
const reverse_iterator<I2>& y);
template <class I1, class I2>
requires SizedSentinel<I1, I2>
constexpr difference_type_t<I2> operator-(
const reverse_iterator<I1>& x,
const reverse_iterator<I2>& y);
template <RandomAccessIterator I>
constexpr reverse_iterator<I> operator+(
difference_type_t<I> n,
const reverse_iterator<I>& x);
template <BidirectionalIterator I>
constexpr reverse_iterator<I> make_reverse_iterator(I i);
template <class Container> class back_insert_iterator;
template <class Container>
back_insert_iterator<Container> back_inserter(Container& x);
template <class Container> class front_insert_iterator;
template <class Container>
front_insert_iterator<Container> front_inserter(Container& x);
template <class Container> class insert_iterator;
template <class Container>
insert_iterator<Container> inserter(Container& x, iterator_t<Container> i);
template <InputIterator I> class move_iterator;
template <class I1, class I2>
requires EqualityComparableWith<I1, I2>
constexpr bool operator==(
const move_iterator<I1>& x, const move_iterator<I2>& y);
template <class I1, class I2>
requires EqualityComparableWith<I1, I2>
constexpr bool operator!=(
const move_iterator<I1>& x, const move_iterator<I2>& y);
template <class I1, class I2>
requires StrictTotallyOrderedWith<I1, I2>
constexpr bool operator<(
const move_iterator<I1>& x, const move_iterator<I2>& y);
template <class I1, class I2>
requires StrictTotallyOrderedWith<I1, I2>
constexpr bool operator<=(
const move_iterator<I1>& x, const move_iterator<I2>& y);
template <class I1, class I2>
requires StrictTotallyOrderedWith<I1, I2>
constexpr bool operator>(
const move_iterator<I1>& x, const move_iterator<I2>& y);
template <class I1, class I2>
requires StrictTotallyOrderedWith<I1, I2>
constexpr bool operator>=(
const move_iterator<I1>& x, const move_iterator<I2>& y);
template <class I1, class I2>
requires SizedSentinel<I1, I2>
constexpr difference_type_t<I2> operator-(
const move_iterator<I1>& x,
const move_iterator<I2>& y);
template <RandomAccessIterator I>
constexpr move_iterator<I> operator+(
difference_type_t<I> n,
const move_iterator<I>& x);
template <InputIterator I>
constexpr move_iterator<I> make_move_iterator(I i);
template <Semiregular S> class move_sentinel;
template <class I, Sentinel<I> S>
constexpr bool operator==(
const move_iterator<I>& i, const move_sentinel<S>& s);
template <class I, Sentinel<I> S>
constexpr bool operator==(
const move_sentinel<S>& s, const move_iterator<I>& i);
template <class I, Sentinel<I> S>
constexpr bool operator!=(
const move_iterator<I>& i, const move_sentinel<S>& s);
template <class I, Sentinel<I> S>
constexpr bool operator!=(
const move_sentinel<S>& s, const move_iterator<I>& i);
template <class I, SizedSentinel<I> S>
constexpr difference_type_t<I> operator-(
const move_sentinel<S>& s, const move_iterator<I>& i);
template <class I, SizedSentinel<I> S>
constexpr difference_type_t<I> operator-(
const move_iterator<I>& i, const move_sentinel<S>& s);
template <Semiregular S>
constexpr move_sentinel<S> make_move_sentinel(S s);
template <Iterator I, Sentinel<I> S>
requires !Same<I, S>
class common_iterator;
template <Readable I, class S>
struct value_type<common_iterator<I, S>>;
template <InputIterator I, class S>
struct iterator_category<common_iterator<I, S>>;
template <ForwardIterator I, class S>
struct iterator_category<common_iterator<I, S>>;
template <class I1, class I2, Sentinel<I2> S1, Sentinel<I1> S2>
bool operator==(
const common_iterator<I1, S1>& x, const common_iterator<I2, S2>& y);
template <class I1, class I2, Sentinel<I2> S1, Sentinel<I1> S2>
requires EqualityComparableWith<I1, I2>
bool operator==(
const common_iterator<I1, S1>& x, const common_iterator<I2, S2>& y);
template <class I1, class I2, Sentinel<I2> S1, Sentinel<I1> S2>
bool operator!=(
const common_iterator<I1, S1>& x, const common_iterator<I2, S2>& y);
template <class I2, SizedSentinel<I2> I1, SizedSentinel<I2> S1, SizedSentinel<I1> S2>
difference_type_t<I2> operator-(
const common_iterator<I1, S1>& x, const common_iterator<I2, S2>& y);
class default_sentinel;
template <Iterator I> class counted_iterator;
template <class I1, class I2>
requires Common<I1, I2>
constexpr bool operator==(
const counted_iterator<I1>& x, const counted_iterator<I2>& y);
constexpr bool operator==(
const counted_iterator<auto>& x, default_sentinel);
constexpr bool operator==(
default_sentinel, const counted_iterator<auto>& x);
template <class I1, class I2>
requires Common<I1, I2>
constexpr bool operator!=(
const counted_iterator<I1>& x, const counted_iterator<I2>& y);
constexpr bool operator!=(
const counted_iterator<auto>& x, default_sentinel y);
constexpr bool operator!=(
default_sentinel x, const counted_iterator<auto>& y);
template <class I1, class I2>
requires Common<I1, I2>
constexpr bool operator<(
const counted_iterator<I1>& x, const counted_iterator<I2>& y);
template <class I1, class I2>
requires Common<I1, I2>
constexpr bool operator<=(
const counted_iterator<I1>& x, const counted_iterator<I2>& y);
template <class I1, class I2>
requires Common<I1, I2>
constexpr bool operator>(
const counted_iterator<I1>& x, const counted_iterator<I2>& y);
template <class I1, class I2>
requires Common<I1, I2>
constexpr bool operator>=(
const counted_iterator<I1>& x, const counted_iterator<I2>& y);
template <class I1, class I2>
requires Common<I1, I2>
constexpr difference_type_t<I2> operator-(
const counted_iterator<I1>& x, const counted_iterator<I2>& y);
template <class I>
constexpr difference_type_t<I> operator-(
const counted_iterator<I>& x, default_sentinel y);
template <class I>
constexpr difference_type_t<I> operator-(
default_sentinel x, const counted_iterator<I>& y);
template <RandomAccessIterator I>
constexpr counted_iterator<I>
operator+(difference_type_t<I> n, const counted_iterator<I>& x);
template <Iterator I>
constexpr counted_iterator<I> make_counted_iterator(I i, difference_type_t<I> n);
class unreachable;
template <Iterator I>
constexpr bool operator==(const I&, unreachable) noexcept;
template <Iterator I>
constexpr bool operator==(unreachable, const I&) noexcept;
template <Iterator I>
constexpr bool operator!=(const I&, unreachable) noexcept;
template <Iterator I>
constexpr bool operator!=(unreachable, const I&) noexcept;
template <class T> class dangling;
template <class T, class CharT = char, class Traits = char_traits<CharT>,
class Distance = ptrdiff_t>
class istream_iterator;
template <class T, class CharT, class Traits, class Distance>
bool operator==(const istream_iterator<T, CharT, Traits, Distance>& x,
const istream_iterator<T, CharT, Traits, Distance>& y);
template <class T, class CharT, class Traits, class Distance>
bool operator==(default_sentinel x,
const istream_iterator<T, CharT, Traits, Distance>& y);
template <class T, class CharT, class Traits, class Distance>
bool operator==(const istream_iterator<T, CharT, Traits, Distance>& x,
default_sentinel y);
template <class T, class CharT, class Traits, class Distance>
bool operator!=(const istream_iterator<T, CharT, Traits, Distance>& x,
const istream_iterator<T, CharT, Traits, Distance>& y);
template <class T, class CharT, class Traits, class Distance>
bool operator!=(default_sentinel x,
const istream_iterator<T, CharT, Traits, Distance>& y);
template <class T, class CharT, class Traits, class Distance>
bool operator!=(const istream_iterator<T, CharT, Traits, Distance>& x,
default_sentinel y);
template <class T, class CharT = char, class Traits = char_traits<CharT>>
class ostream_iterator;
template <class CharT, class Traits = char_traits<CharT> >
class istreambuf_iterator;
template <class CharT, class Traits>
bool operator==(const istreambuf_iterator<CharT, Traits>& a,
const istreambuf_iterator<CharT, Traits>& b);
template <class CharT, class Traits>
bool operator==(default_sentinel a,
const istreambuf_iterator<CharT, Traits>& b);
template <class CharT, class Traits>
bool operator==(const istreambuf_iterator<CharT, Traits>& a,
default_sentinel b);
template <class CharT, class Traits>
bool operator!=(const istreambuf_iterator<CharT, Traits>& a,
const istreambuf_iterator<CharT, Traits>& b);
template <class CharT, class Traits>
bool operator!=(default_sentinel a,
const istreambuf_iterator<CharT, Traits>& b);
template <class CharT, class Traits>
bool operator!=(const istreambuf_iterator<CharT, Traits>& a,
default_sentinel b);
template <class CharT, class Traits = char_traits<CharT> >
class ostreambuf_iterator;
}}}}
namespace std {
template <experimental::ranges::Iterator Out>
struct iterator_traits<Out>;
template <experimental::ranges::InputIterator In>
struct iterator_traits<In>;
template <experimental::ranges::InputIterator In>
requires experimental::ranges::Sentinel<In, In>
struct iterator_traits;
}
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4