From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [216.205.24.124]) by sourceware.org (Postfix) with ESMTP id E8FE739B3412 for ; Fri, 18 Jun 2021 21:56:51 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org E8FE739B3412 Received: from mail-wr1-f71.google.com (mail-wr1-f71.google.com [209.85.221.71]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-157-avWfNY0UNYuBcXSizd-ARg-1; Fri, 18 Jun 2021 17:56:45 -0400 X-MC-Unique: avWfNY0UNYuBcXSizd-ARg-1 Received: by mail-wr1-f71.google.com with SMTP id h10-20020a5d688a0000b0290119c2ce2499so4948589wru.19 for ; Fri, 18 Jun 2021 14:56:45 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc; bh=VpsxDXo+BkzsU8DgRuSHY9wsxND4CU/HMJFPfC0G8C0=; b=n14vBNUXw0+I9DcUVXVlr8A/RlgAcEEow6rosD2wWBBnngKU1g7EBen6J1/WXeYE8v nWUmcNTk6W0hvyPvCZMTiWcaUZmLcfmXtyLlIPLALv8zDFntNgr84edGy2PVwSrera9j DdP64lqfFmsPZfl83E3TcOQIHpwQzsltnaJINwTS1Zgyk/ZRNr6DsIXFi/zmxrofuw3Y /xjI+x/DXk5hcvSDuvVff2+rIgXCM/ZQq2d6yUmbvgdVIjIP18ziY5mjFY3S3GSSUHyI w8dEjYx5onTnvEfZfp7S+tdV/VpNUND3hEXMukbOy+8MKfnoeBK9gNLFaZxoREO9eSqc B8hw== X-Gm-Message-State: AOAM530jEME4vBwUyingpNIR4UONHMUndexE2kTi2JqN7vKMm2jdqcP4 KV0u4D9x16t0kNtI7BYvxls4RZqlSAJCJv8PHocYkEs4HF6cNJqtVnZGr81etsMiBBgkLZvkFLi za4svHx0VjJtqB3TH5yI39N0ZWklNXJY= X-Received: by 2002:a5d:6409:: with SMTP id z9mr14364500wru.279.1624053403893; Fri, 18 Jun 2021 14:56:43 -0700 (PDT) X-Google-Smtp-Source: ABdhPJxiADRgB1zYTrdDgnBCx0LkOpfIEhk/q5nIEn3vVeaZ4oma1cEqOj33vtxfGliFFIOF6aPWLd+EYfTpr7S4QVI= X-Received: by 2002:a5d:6409:: with SMTP id z9mr14364485wru.279.1624053403550; Fri, 18 Jun 2021 14:56:43 -0700 (PDT) MIME-Version: 1.0 References: <20210617152206.1408001-1-ppalka@redhat.com> <20210617152206.1408001-3-ppalka@redhat.com> In-Reply-To: <20210617152206.1408001-3-ppalka@redhat.com> From: Jonathan Wakely Date: Fri, 18 Jun 2021 22:56:32 +0100 Message-ID: Subject: Re: [PATCH 3/5] libstdc++: Rename views::split to views::lazy_split as per P2210 To: Patrick Palka Cc: gcc Patches , "libstdc++" X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Type: text/plain; charset="UTF-8" X-Spam-Status: No, score=-12.3 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, KAM_NUMSUBJECT, RCVD_IN_DNSWL_LOW, RCVD_IN_MSPIKE_H4, RCVD_IN_MSPIKE_WL, SPF_HELO_NONE, SPF_PASS, TXREP, URI_HEX autolearn=ham autolearn_force=no version=3.4.2 X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) on server2.sourceware.org X-BeenThere: libstdc++@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Libstdc++ mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Fri, 18 Jun 2021 21:56:55 -0000 On Thu, 17 Jun 2021 at 16:55, Patrick Palka via Libstdc++ wrote: > > This mostly mechanical patch performs the renaming part of P2210R3 > "Superior string splitting". It also defines _InnerIter::base() > overloads. > > libstdc++-v3/ChangeLog: > > * include/std/ranges: Rename views::split to views::lazy_split, > split_view to lazy_split_view, etc. throughout. > (lazy_split_view::_InnerIter::base): Define as per P2210. > * testsuite/std/ranges/*: Likewise. The base() member could be noexcept, but that can be added later. OK. > --- > libstdc++-v3/include/std/ranges | 68 +++++++++++-------- > .../testsuite/std/ranges/adaptors/100479.cc | 2 +- > .../testsuite/std/ranges/adaptors/100577.cc | 20 +++--- > .../testsuite/std/ranges/adaptors/join.cc | 2 +- > .../adaptors/{split.cc => lazy_split.cc} | 54 +++++++-------- > .../{split_neg.cc => lazy_split_neg.cc} | 6 +- > .../testsuite/std/ranges/adaptors/p2281.cc | 18 ++--- > .../testsuite/std/ranges/adaptors/sizeof.cc | 2 +- > libstdc++-v3/testsuite/std/ranges/p2259.cc | 6 +- > libstdc++-v3/testsuite/std/ranges/p2325.cc | 10 +-- > libstdc++-v3/testsuite/std/ranges/p2367.cc | 4 +- > 11 files changed, 100 insertions(+), 92 deletions(-) > rename libstdc++-v3/testsuite/std/ranges/adaptors/{split.cc => lazy_split.cc} (76%) > rename libstdc++-v3/testsuite/std/ranges/adaptors/{split_neg.cc => lazy_split_neg.cc} (79%) > > diff --git a/libstdc++-v3/include/std/ranges b/libstdc++-v3/include/std/ranges > index f93a880ff8a..cc1ef112ff1 100644 > --- a/libstdc++-v3/include/std/ranges > +++ b/libstdc++-v3/include/std/ranges > @@ -2826,19 +2826,19 @@ namespace views::__adaptor > && (remove_reference_t<_Range>::size() <= 1); > > template > - struct __split_view_outer_iter_cat > + struct __lazy_split_view_outer_iter_cat > { }; > > template > - struct __split_view_outer_iter_cat<_Base> > + struct __lazy_split_view_outer_iter_cat<_Base> > { using iterator_category = input_iterator_tag; }; > > template > - struct __split_view_inner_iter_cat > + struct __lazy_split_view_inner_iter_cat > { }; > > template > - struct __split_view_inner_iter_cat<_Base> > + struct __lazy_split_view_inner_iter_cat<_Base> > { > private: > static constexpr auto > @@ -2860,7 +2860,7 @@ namespace views::__adaptor > && indirectly_comparable, iterator_t<_Pattern>, > ranges::equal_to> > && (forward_range<_Vp> || __detail::__tiny_range<_Pattern>) > - class split_view : public view_interface> > + class lazy_split_view : public view_interface> > { > private: > template > @@ -2871,17 +2871,17 @@ namespace views::__adaptor > > template > struct _OuterIter > - : __detail::__split_view_outer_iter_cat<_Base<_Const>> > + : __detail::__lazy_split_view_outer_iter_cat<_Base<_Const>> > { > private: > - using _Parent = __detail::__maybe_const_t<_Const, split_view>; > - using _Base = split_view::_Base<_Const>; > + using _Parent = __detail::__maybe_const_t<_Const, lazy_split_view>; > + using _Base = lazy_split_view::_Base<_Const>; > > constexpr bool > __at_end() const > { return __current() == ranges::end(_M_parent->_M_base); } > > - // [range.split.outer] p1 > + // [range.lazy.split.outer] p1 > // Many of the following specifications refer to the notional member > // current of outer-iterator. current is equivalent to current_ if > // V models forward_range, and parent_->current_ otherwise. > @@ -2914,7 +2914,7 @@ namespace views::__adaptor > using iterator_concept = conditional_t, > forward_iterator_tag, > input_iterator_tag>; > - // iterator_category defined in __split_view_outer_iter_cat > + // iterator_category defined in __lazy_split_view_outer_iter_cat > using difference_type = range_difference_t<_Base>; > > struct value_type : view_interface > @@ -2974,7 +2974,7 @@ namespace views::__adaptor > operator++() > { > // _GLIBCXX_RESOLVE_LIB_DEFECTS > - // 3505. split_view::outer-iterator::operator++ misspecified > + // 3505. lazy_split_view::outer-iterator::operator++ misspecified > const auto __end = ranges::end(_M_parent->_M_base); > if (__current() == __end) > return *this; > @@ -3030,10 +3030,10 @@ namespace views::__adaptor > > template > struct _InnerIter > - : __detail::__split_view_inner_iter_cat<_Base<_Const>> > + : __detail::__lazy_split_view_inner_iter_cat<_Base<_Const>> > { > private: > - using _Base = split_view::_Base<_Const>; > + using _Base = lazy_split_view::_Base<_Const>; > > constexpr bool > __at_end() const > @@ -3081,7 +3081,7 @@ namespace views::__adaptor > public: > using iterator_concept > = typename _OuterIter<_Const>::iterator_concept; > - // iterator_category defined in __split_view_inner_iter_cat > + // iterator_category defined in __lazy_split_view_inner_iter_cat > using value_type = range_value_t<_Base>; > using difference_type = range_difference_t<_Base>; > > @@ -3092,6 +3092,14 @@ namespace views::__adaptor > : _M_i(std::move(__i)) > { } > > + constexpr iterator_t<_Base> > + base() const& requires copyable> > + { return _M_i_current(); } > + > + constexpr iterator_t<_Base> > + base() && > + { return std::move(_M_i_current()); } > + > constexpr decltype(auto) > operator*() const > { return *_M_i_current(); } > @@ -3151,12 +3159,12 @@ namespace views::__adaptor > > > public: > - split_view() requires (default_initializable<_Vp> > - && default_initializable<_Pattern>) > + lazy_split_view() requires (default_initializable<_Vp> > + && default_initializable<_Pattern>) > = default; > > constexpr > - split_view(_Vp __base, _Pattern __pattern) > + lazy_split_view(_Vp __base, _Pattern __pattern) > : _M_pattern(std::move(__pattern)), _M_base(std::move(__base)) > { } > > @@ -3164,7 +3172,7 @@ namespace views::__adaptor > requires constructible_from<_Vp, views::all_t<_Range>> > && constructible_from<_Pattern, single_view>> > constexpr > - split_view(_Range&& __r, range_value_t<_Range> __e) > + lazy_split_view(_Range&& __r, range_value_t<_Range> __e) > : _M_pattern(views::single(std::move(__e))), > _M_base(views::all(std::forward<_Range>(__r))) > { } > @@ -3216,35 +3224,35 @@ namespace views::__adaptor > }; > > template > - split_view(_Range&&, _Pattern&&) > - -> split_view, views::all_t<_Pattern>>; > + lazy_split_view(_Range&&, _Pattern&&) > + -> lazy_split_view, views::all_t<_Pattern>>; > > template > - split_view(_Range&&, range_value_t<_Range>) > - -> split_view, single_view>>; > + lazy_split_view(_Range&&, range_value_t<_Range>) > + -> lazy_split_view, single_view>>; > > namespace views > { > namespace __detail > { > template > - concept __can_split_view > - = requires { split_view(std::declval<_Range>(), std::declval<_Pattern>()); }; > + concept __can_lazy_split_view > + = requires { lazy_split_view(std::declval<_Range>(), std::declval<_Pattern>()); }; > } // namespace __detail > > - struct _Split : __adaptor::_RangeAdaptor<_Split> > + struct _LazySplit : __adaptor::_RangeAdaptor<_LazySplit> > { > template > - requires __detail::__can_split_view<_Range, _Pattern> > + requires __detail::__can_lazy_split_view<_Range, _Pattern> > constexpr auto > operator()(_Range&& __r, _Pattern&& __f) const > { > - return split_view(std::forward<_Range>(__r), std::forward<_Pattern>(__f)); > + return lazy_split_view(std::forward<_Range>(__r), std::forward<_Pattern>(__f)); > } > > - using _RangeAdaptor<_Split>::operator(); > + using _RangeAdaptor<_LazySplit>::operator(); > static constexpr int _S_arity = 2; > - // The pattern argument of views::split is not always simple -- it can be > + // The pattern argument of views::lazy_split is not always simple -- it can be > // a non-view range, the value category of which affects whether the call > // is well-formed. But a scalar or a view pattern argument is surely > // simple. > @@ -3254,7 +3262,7 @@ namespace views::__adaptor > && copy_constructible<_Pattern>); > }; > > - inline constexpr _Split split; > + inline constexpr _LazySplit lazy_split; > } // namespace views > > namespace views > diff --git a/libstdc++-v3/testsuite/std/ranges/adaptors/100479.cc b/libstdc++-v3/testsuite/std/ranges/adaptors/100479.cc > index ba10b7baf3f..9899ff92c0b 100644 > --- a/libstdc++-v3/testsuite/std/ranges/adaptors/100479.cc > +++ b/libstdc++-v3/testsuite/std/ranges/adaptors/100479.cc > @@ -90,7 +90,7 @@ test03() > // Propagating cached iterators during copy/move would cause these asserts > // to fail here. > auto v = views::single(1) > - | views::split(1) > + | views::lazy_split(1) > | views::drop(0) > | views::drop_while([](auto) { return false; }) > | views::filter([](auto) { return true; }); > diff --git a/libstdc++-v3/testsuite/std/ranges/adaptors/100577.cc b/libstdc++-v3/testsuite/std/ranges/adaptors/100577.cc > index 06be4980ddb..5ef7f3f59a7 100644 > --- a/libstdc++-v3/testsuite/std/ranges/adaptors/100577.cc > +++ b/libstdc++-v3/testsuite/std/ranges/adaptors/100577.cc > @@ -38,11 +38,11 @@ test01() > static_assert(__adaptor_has_simple_extra_args); > static_assert(__adaptor_has_simple_extra_args); > static_assert(__adaptor_has_simple_extra_args); > - static_assert(__adaptor_has_simple_extra_args); > - static_assert(__adaptor_has_simple_extra_args); > - static_assert(!__adaptor_has_simple_extra_args); > + static_assert(__adaptor_has_simple_extra_args); > + static_assert(__adaptor_has_simple_extra_args); > + static_assert(!__adaptor_has_simple_extra_args); > > - // Verify all adaptor closures except for views::split(pattern) have a simple > + // Verify all adaptor closures except for views::lazy_split(pattern) have a simple > // operator(). > using views::__adaptor::__closure_has_simple_call_op; > __closure_has_simple_call_op auto a00 = views::all; > @@ -56,14 +56,14 @@ test01() > __closure_has_simple_call_op auto a08 = views::common; > __closure_has_simple_call_op auto a09 = views::reverse; > __closure_has_simple_call_op auto a10 = views::keys; > - __closure_has_simple_call_op auto a11 = views::split(' '); > + __closure_has_simple_call_op auto a11 = views::lazy_split(' '); > // Verify composition of simple closures is simple. > __closure_has_simple_call_op auto b > = (a00 | a01) | (a02 | a03) | (a04 | a05 | a06) | (a07 | a08 | a09 | a10) | a11; > > - // Verify views::split(non_view_range) is an exception. > + // Verify views::lazy_split(non_view_range) is an exception. > extern std::string s; > - auto a12 = views::split(s); > + auto a12 = views::lazy_split(s); > static_assert(!__closure_has_simple_call_op); > static_assert(!__closure_has_simple_call_op); > static_assert(!__closure_has_simple_call_op); > @@ -91,9 +91,9 @@ test02() > // implemented using a fallback deleted overload, so when a call is > // ill-formed overload resolution succeeds but selects the deleted overload > // (but only when the closure is invoked as an rvalue). > - views::split(badarg)(x); // { dg-error "deleted function" } > - (views::split(badarg) | views::all)(x); // { dg-error "deleted function" } > - auto a0 = views::split(badarg); > + views::lazy_split(badarg)(x); // { dg-error "deleted function" } > + (views::lazy_split(badarg) | views::all)(x); // { dg-error "deleted function" } > + auto a0 = views::lazy_split(badarg); > a0(x); // { dg-error "no match" }; > auto a1 = a0 | views::all; > a1(x); // { dg-error "no match" } > diff --git a/libstdc++-v3/testsuite/std/ranges/adaptors/join.cc b/libstdc++-v3/testsuite/std/ranges/adaptors/join.cc > index d774e8d9385..50af3fdf729 100644 > --- a/libstdc++-v3/testsuite/std/ranges/adaptors/join.cc > +++ b/libstdc++-v3/testsuite/std/ranges/adaptors/join.cc > @@ -93,7 +93,7 @@ test05() > { > using namespace std::literals; > std::vector x = {"the", " ", "quick", " ", "brown", " ", "fox"}; > - auto v = x | views::join | views::split(' '); > + auto v = x | views::join | views::lazy_split(' '); > auto i = v.begin(); > VERIFY( ranges::equal(*i++, "the"sv) ); > VERIFY( ranges::equal(*i++, "quick"sv) ); > diff --git a/libstdc++-v3/testsuite/std/ranges/adaptors/split.cc b/libstdc++-v3/testsuite/std/ranges/adaptors/lazy_split.cc > similarity index 76% > rename from libstdc++-v3/testsuite/std/ranges/adaptors/split.cc > rename to libstdc++-v3/testsuite/std/ranges/adaptors/lazy_split.cc > index 9d2cfa8632a..12844525d86 100644 > --- a/libstdc++-v3/testsuite/std/ranges/adaptors/split.cc > +++ b/libstdc++-v3/testsuite/std/ranges/adaptors/lazy_split.cc > @@ -39,7 +39,7 @@ test01() > { > auto x = "the quick brown fox"sv; > auto p = std::string{" "}; > - auto v = x | views::split(views::all(p)); // views::all is needed here after P2281. > + auto v = x | views::lazy_split(views::all(p)); // views::all is needed here after P2281. > auto i = v.begin(); > VERIFY( ranges::equal(*i++, "the"sv) ); > VERIFY( ranges::equal(*i++, "quick"sv) ); > @@ -52,7 +52,7 @@ void > test02() > { > auto x = "the quick brown fox"sv; > - auto v = x | views::split(' '); > + auto v = x | views::lazy_split(' '); > auto i = v.begin(); > VERIFY( ranges::equal(*i++, "the"sv) ); > VERIFY( ranges::equal(*i++, "quick"sv) ); > @@ -66,7 +66,7 @@ test03() > { > char x[] = "the quick brown fox"; > test_range rx(x, x+sizeof(x)-1); > - auto v = rx | views::split(' '); > + auto v = rx | views::lazy_split(' '); > auto i = v.begin(); > VERIFY( ranges::equal(*i++, "the"sv) ); > VERIFY( ranges::equal(*i++, "quick"sv) ); > @@ -83,7 +83,7 @@ test04() > static_assert(!ranges::view); > static_assert(std::same_as ranges::ref_view>); > - auto v = x | views::split(views::all(p)); // views::all is needed here after P2281. > + auto v = x | views::lazy_split(views::all(p)); // views::all is needed here after P2281. > auto i = v.begin(); > VERIFY( ranges::equal(*i++, "the"sv) ); > VERIFY( ranges::equal(*i++, "quick"sv) ); > @@ -102,7 +102,7 @@ test05() > std::string str > = "Now is the time for all good men to come to the aid of their county."; > auto rng > - = str | views::split(' ') | views::transform(as_string) | views::common; > + = str | views::lazy_split(' ') | views::transform(as_string) | views::common; > std::vector words(rng.begin(), rng.end()); > auto not_space_p = [](char c) { return c != ' '; }; > VERIFY( ranges::equal(words | views::join, > @@ -113,7 +113,7 @@ void > test06() > { > std::string str = "hello world"; > - auto v = str | views::transform(std::identity{}) | views::split(' '); > + auto v = str | views::transform(std::identity{}) | views::lazy_split(' '); > > // Verify that _Iterator is implicitly convertible to _Iterator. > static_assert(!std::same_as @@ -126,7 +126,7 @@ void > test07() > { > char str[] = "banana split"; > - auto split = str | views::split(' '); > + auto split = str | views::lazy_split(' '); > auto val = *split.begin(); > auto b = val.begin(); > auto b2 = b++; > @@ -139,7 +139,7 @@ test08() > { > char x[] = "the quick brown fox"; > test_range rx(x, x+sizeof(x)-1); > - auto v = rx | views::split(' '); > + auto v = rx | views::lazy_split(' '); > auto i = v.begin(); > VERIFY( ranges::equal(*i, "the"sv) ); > ++i; > @@ -152,32 +152,32 @@ test08() > VERIFY( i == v.end() ); > } > > -template > +template > void > test09() > { > // Verify SFINAE behavior. > std::string s, p; > - static_assert(!requires { split(); }); > - static_assert(!requires { split(s, p, 0); }); > - static_assert(!requires { split(p)(); }); > - static_assert(!requires { s | split; }); > - > - static_assert(!requires { s | split(p); }); > - static_assert(!requires { split(p)(s); }); > - static_assert(!requires { s | (split(p) | views::all); }); > - static_assert(!requires { (split(p) | views::all)(s); }); > - > - static_assert(requires { s | split(views::all(p)); }); > - static_assert(requires { split(views::all(p))(s); }); > - static_assert(requires { s | (split(views::all(p)) | views::all); }); > - static_assert(requires { (split(views::all(p)) | views::all)(s); }); > - > - auto adapt = split(p); > + static_assert(!requires { lazy_split(); }); > + static_assert(!requires { lazy_split(s, p, 0); }); > + static_assert(!requires { lazy_split(p)(); }); > + static_assert(!requires { s | lazy_split; }); > + > + static_assert(!requires { s | lazy_split(p); }); > + static_assert(!requires { lazy_split(p)(s); }); > + static_assert(!requires { s | (lazy_split(p) | views::all); }); > + static_assert(!requires { (lazy_split(p) | views::all)(s); }); > + > + static_assert(requires { s | lazy_split(views::all(p)); }); > + static_assert(requires { lazy_split(views::all(p))(s); }); > + static_assert(requires { s | (lazy_split(views::all(p)) | views::all); }); > + static_assert(requires { (lazy_split(views::all(p)) | views::all)(s); }); > + > + auto adapt = lazy_split(p); > static_assert(requires { s | adapt; }); > static_assert(requires { adapt(s); }); > > - auto adapt2 = split(p) | views::all; > + auto adapt2 = lazy_split(p) | views::all; > static_assert(requires { s | adapt2; }); > static_assert(requires { adapt2(s); }); > } > @@ -189,7 +189,7 @@ test10() > auto to_string = [] (auto r) { > return std::string(r.begin(), ranges::next(r.begin(), r.end())); > }; > - auto v = "xxyx"sv | views::split("xy"sv) | views::transform(to_string); > + auto v = "xxyx"sv | views::lazy_split("xy"sv) | views::transform(to_string); > VERIFY( ranges::equal(v, (std::string_view[]){"x", "x"}) ); > } > > diff --git a/libstdc++-v3/testsuite/std/ranges/adaptors/split_neg.cc b/libstdc++-v3/testsuite/std/ranges/adaptors/lazy_split_neg.cc > similarity index 79% > rename from libstdc++-v3/testsuite/std/ranges/adaptors/split_neg.cc > rename to libstdc++-v3/testsuite/std/ranges/adaptors/lazy_split_neg.cc > index 4229314a9dc..c59f828ee56 100644 > --- a/libstdc++-v3/testsuite/std/ranges/adaptors/split_neg.cc > +++ b/libstdc++-v3/testsuite/std/ranges/adaptors/lazy_split_neg.cc > @@ -30,7 +30,7 @@ test01() > { > using namespace std::literals; > auto x = "the quick brown fox"sv; > - auto v = views::split(x, std::initializer_list{' ', ' '}); // { dg-error "no match" } > + auto v = views::lazy_split(x, std::initializer_list{' ', ' '}); // { dg-error "no match" } > } > > void > @@ -38,8 +38,8 @@ test02() > { > using namespace std::literals; > auto x = "the quick brown fox"sv; > - auto v1 = views::split(std::initializer_list{' ', ' '})(x); // { dg-error "deleted" } > - auto v2 = x | views::split(std::initializer_list{' ', ' '}); // { dg-error "no match" } > + auto v1 = views::lazy_split(std::initializer_list{' ', ' '})(x); // { dg-error "deleted" } > + auto v2 = x | views::lazy_split(std::initializer_list{' ', ' '}); // { dg-error "no match" } > } > > // { dg-prune-output "in requirements" } > diff --git a/libstdc++-v3/testsuite/std/ranges/adaptors/p2281.cc b/libstdc++-v3/testsuite/std/ranges/adaptors/p2281.cc > index c916a5ea8b7..7950c43576d 100644 > --- a/libstdc++-v3/testsuite/std/ranges/adaptors/p2281.cc > +++ b/libstdc++-v3/testsuite/std/ranges/adaptors/p2281.cc > @@ -34,7 +34,7 @@ void > test01() > { > auto split_into_strings = [] (auto p) { > - return views::split(p) | views::transform([](auto r){ > + return views::lazy_split(p) | views::transform([](auto r){ > return std::string(r.begin(), ranges::next(r.begin(), r.end())); > }); > }; > @@ -60,19 +60,19 @@ struct move_only_range > template<> > inline constexpr bool std::ranges::enable_view = true; > > -template > +template > void > test02() > { > std::string_view s; > move_only_range p; > - static_assert(requires { s | split(std::move(p)); }); > - static_assert(requires { split(std::move(p))(s); }); > - static_assert(requires { split(std::move(p)) | views::all; }); > - static_assert(requires { views::all | split(std::move(p)); }); > - static_assert(!requires { split(p); }); > - static_assert(!requires { split(p) | views::all; }); > - static_assert(!requires { views::all | split(p); }); > + static_assert(requires { s | lazy_split(std::move(p)); }); > + static_assert(requires { lazy_split(std::move(p))(s); }); > + static_assert(requires { lazy_split(std::move(p)) | views::all; }); > + static_assert(requires { views::all | lazy_split(std::move(p)); }); > + static_assert(!requires { lazy_split(p); }); > + static_assert(!requires { lazy_split(p) | views::all; }); > + static_assert(!requires { views::all | lazy_split(p); }); > } > > int > diff --git a/libstdc++-v3/testsuite/std/ranges/adaptors/sizeof.cc b/libstdc++-v3/testsuite/std/ranges/adaptors/sizeof.cc > index 80326f8bf21..219e2a61f07 100644 > --- a/libstdc++-v3/testsuite/std/ranges/adaptors/sizeof.cc > +++ b/libstdc++-v3/testsuite/std/ranges/adaptors/sizeof.cc > @@ -46,7 +46,7 @@ static_assert(sizeof(ranges::take_while_view) == 3*ptr); > static_assert(sizeof(ranges::drop_while_view) == 3*ptr); > static_assert(sizeof(ranges::transform_view) == 3*ptr); > > -static_assert(sizeof(ranges::split_view) == 4*ptr); > +static_assert(sizeof(ranges::lazy_split_view) == 4*ptr); > > static_assert > (sizeof(ranges::reverse_view>) == 4*ptr); > diff --git a/libstdc++-v3/testsuite/std/ranges/p2259.cc b/libstdc++-v3/testsuite/std/ranges/p2259.cc > index 1b422e44f16..0ec7e21f657 100644 > --- a/libstdc++-v3/testsuite/std/ranges/p2259.cc > +++ b/libstdc++-v3/testsuite/std/ranges/p2259.cc > @@ -49,12 +49,12 @@ test01() > // Verify the changes to transform_view. > only_cxx20_input_range auto v2 = v0 | views::transform([](int& c) -> auto& { return c; }); > > - // Verify the changes to split_view. > - only_cxx20_input_range auto v3 = v0 | views::split(12); > + // Verify the changes to lazy_split_view. > + only_cxx20_input_range auto v3 = v0 | views::lazy_split(12); > static_assert(only_cxx20_input_range); > > // Verify the changes to join_view. > - only_cxx20_input_range auto v4 = v0 | views::split(12) | views::join; > + only_cxx20_input_range auto v4 = v0 | views::lazy_split(12) | views::join; > > // Verify the changes to elements_view. > only_cxx20_input_range auto v5 > diff --git a/libstdc++-v3/testsuite/std/ranges/p2325.cc b/libstdc++-v3/testsuite/std/ranges/p2325.cc > index df6cde29e4d..4d075409026 100644 > --- a/libstdc++-v3/testsuite/std/ranges/p2325.cc > +++ b/libstdc++-v3/testsuite/std/ranges/p2325.cc > @@ -113,14 +113,14 @@ test07() > void > test08() > { > - // Verify split_view is conditionally default constructible. > - using type1 = ranges::split_view, ranges::single_view>; > + // Verify lazy_split_view is conditionally default constructible. > + using type1 = ranges::lazy_split_view, ranges::single_view>; > static_assert(!default_initializable); > - using type2 = ranges::split_view, ranges::ref_view>; > + using type2 = ranges::lazy_split_view, ranges::ref_view>; > static_assert(!default_initializable); > - using type3 = ranges::split_view, ranges::ref_view>; > + using type3 = ranges::lazy_split_view, ranges::ref_view>; > static_assert(!default_initializable); > - using type4 = ranges::split_view, ranges::single_view>; > + using type4 = ranges::lazy_split_view, ranges::single_view>; > static_assert(default_initializable); > } > > diff --git a/libstdc++-v3/testsuite/std/ranges/p2367.cc b/libstdc++-v3/testsuite/std/ranges/p2367.cc > index 40875233d88..5228b021602 100644 > --- a/libstdc++-v3/testsuite/std/ranges/p2367.cc > +++ b/libstdc++-v3/testsuite/std/ranges/p2367.cc > @@ -43,6 +43,6 @@ test01() > // Verify changes to views::drop. > auto v5 = views::drop(x, 0ull); > > - // Verify changes to views::split. > - auto v6 = views::split(x, 5u); > + // Verify changes to views::lazy_split. > + auto v6 = views::lazy_split(x, 5u); > } > -- > 2.32.0.93.g670b81a890 >