[libc++][ranges] Implement `views::single`.

[var-const]

Summary

This only adds the customization point object (which isn't pipeable),
the view itself has already been implemented previously.

[jloser]

Can you please uncomment the CPO test line at https://github.com/llvm/llvm-project/blob/aff52d1f08d2bb566192618d59a01aa7dd442088/libcxx/test/std/library/description/conventions/customization.point.object/cpo.compile.pass.cpp#L83?

[var-const]

Address review comment

[var-const]

In D124978#3494482, @jloser wrote:

Can you please uncomment the CPO test line at https://github.com/llvm/llvm-project/blob/aff52d1f08d2bb566192618d59a01aa7dd442088/libcxx/test/std/library/description/conventions/customization.point.object/cpo.compile.pass.cpp#L83?

Done, thanks!

libcxx/include/__ranges/lazy_split_view.h

constexpr lazy_split_view(_View __base, _Pattern __pattern)
     : __base_(std::move(__base)), __pattern_(std::move(__pattern)) {}
 
   template <input_range _Range>
     requires constructible_from<_View, views::all_t<_Range>> &&
              constructible_from<_Pattern, single_view<range_value_t<_Range>>>
   _LIBCPP_HIDE_FROM_ABI
   constexpr lazy_split_view(_Range&& __r, range_value_t<_Range> __e)
     : __base_(views::all(std::forward<_Range>(__r)))
-    // TODO(varconst): use `views::single` once it's implemented.
-    , __pattern_(ranges::single_view(std::move(__e))) {}
+    , __pattern_(views::single(std::move(__e))) {}
 
   _LIBCPP_HIDE_FROM_ABI
   constexpr _View base() const& requires copy_constructible<_View> { return __base_; }
   _LIBCPP_HIDE_FROM_ABI
   constexpr _View base() && { return std::move(__base_); }
 
   _LIBCPP_HIDE_FROM_ABI
   constexpr auto begin() {

libcxx/include/__ranges/single_view.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef _LIBCPP___RANGES_SINGLE_VIEW_H
 #define _LIBCPP___RANGES_SINGLE_VIEW_H
 
 #include <__config>
 #include <__ranges/copyable_box.h>
+#include <__ranges/range_adaptor.h>
 #include <__ranges/view_interface.h>
 #include <__utility/forward.h>
 #include <__utility/in_place.h>
 #include <__utility/move.h>
 #include <concepts>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
public:
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr _Tp* data() noexcept { return __value_.operator->(); }
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr const _Tp* data() const noexcept { return __value_.operator->(); }
   };
 
-  template<class _Tp>
-  single_view(_Tp) -> single_view<_Tp>;
+
+namespace views {
+namespace __single_view {
+
+struct __fn : __range_adaptor_closure<__fn> {
+  template<class _Range>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
+  constexpr auto operator()(_Range&& __range) const
+    noexcept(noexcept(single_view<decay_t<_Range&&>>(std::forward<_Range>(__range))))
+    -> decltype(      single_view<decay_t<_Range&&>>(std::forward<_Range>(__range)))
+    { return          single_view<decay_t<_Range&&>>(std::forward<_Range>(__range)); }
+};
+} // namespace __single_view
+
+inline namespace __cpo {
+  inline constexpr auto single = __single_view::__fn{};
+} // namespace __cpo
+
+} // namespace views
 } // namespace ranges
 
 #endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___RANGES_SINGLE_VIEW_H

libcxx/test/std/library/description/conventions/customization.point.object/cpo.compile.pass.cpp

 static_assert(test(std::ranges::size, a));
 static_assert(test(std::ranges::ssize, a));
 
 // [range.factories]
 // views::empty<T> is not a CPO
 static_assert(test(std::views::iota, 1));
 static_assert(test(std::views::iota, 1, 10));
 //static_assert(test(std::views::istream<int>, 1);
-//static_assert(test(std::views::single, 4));
+static_assert(test(std::views::single, 4));
 
 // [range.adaptors]
 static_assert(test(std::views::all, a));
 static_assert(test(std::views::common, a));
 static_assert(test(std::views::counted, a, 10));
 //static_assert(test(std::views::drop, a, 10));
 //static_assert(test(std::views::drop_while, a, [](int x){ return x < 10; }));
 //static_assert(test(std::views::elements<0>, pairs));
 static_assert(test(std::views::filter, a, [](int x){ return x < 10; }));
 //static_assert(test(std::views::join, arrays));
 //static_assert(test(std::views::split, a, 4));
 static_assert(test(std::views::lazy_split, a, 4));
 static_assert(test(std::views::reverse, a));
 static_assert(test(std::views::take, a, 10));
 //static_assert(test(std::views::take_while, a, [](int x){ return x < 10; }));
 static_assert(test(std::views::transform, a, [](int x){ return x + 1; }));

libcxx/test/std/ranges/range.adaptors/range.lazy.split/ctor.range.pass.cpp

constexpr bool test() {
     static_assert(!std::is_constructible_v<V, Empty, std::string_view>);
     static_assert(!std::is_constructible_v<V, std::string_view, Empty>);
   }
 
   // Make sure the arguments are moved, not copied.
   {
     using Range = RangeWithCounting;
     using Element = ElementWithCounting;
-    // TODO(varconst): use `views::single` once it's implemented.
     using Pattern = std::ranges::single_view<Element>;
 
     // Arguments are lvalues.
     {
       using View = std::ranges::ref_view<Range>;
 
       int range_copied = 0, range_moved = 0, element_copied = 0, element_moved = 0;
       Range range(range_copied, range_moved);

libcxx/test/std/ranges/range.factories/range.single.view/cpo.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// std::views::single
+
+#include <ranges>
+
+#include <cassert>
+#include <concepts>
+#include <utility>
+#include "MoveOnly.h"
+
+// Can't invoke without arguments.
+static_assert(!std::is_invocable_v<decltype((std::views::single))>);
+// Can't invoke with a move-only type.
+static_assert(!std::is_invocable_v<decltype((std::views::single)), MoveOnly>);
+
+constexpr bool test() {
+  // Lvalue.
+  {
+    int x = 42;
+    std::same_as<std::ranges::single_view<int>> decltype(auto) v = std::views::single(x);
+    assert(v.size() == 1);
+    assert(v.front() == x);
+  }
+
+  // Prvalue.
+  {
+    std::same_as<std::ranges::single_view<int>> decltype(auto) v = std::views::single(42);
+    assert(v.size() == 1);
+    assert(v.front() == 42);
+  }
+
+  // Const lvalue.
+  {
+    const int x = 42;
+    std::same_as<std::ranges::single_view<int>> decltype(auto) v = std::views::single(x);
+    assert(v.size() == 1);
+    assert(v.front() == x);
+  }
+
+  // Xvalue.
+  {
+    int x = 42;
+    std::same_as<std::ranges::single_view<int>> decltype(auto) v = std::views::single(std::move(x));
+    assert(v.size() == 1);
+    assert(v.front() == x);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}