[libc++] Add ranges::in_fun_result

[philnik]

Summary

Add ranges::in_fun_result

[• Quuxplusone]

libcxx/include/CMakeLists.txt

32

Here and modulemap, please alphabetize.
Good news: I'll render this nit unnecessary Real Soon Now via however D116958 ends up.

libcxx/test/std/algorithms/algorithms.results/in_fun_result.pass.cpp

20–26

Could this plausibly use the MoveOnly type from test/support/moveonly.h instead, just to reduce the line count a bit?
(Ditto consistently in the in_in_result PR, if it also applies there; and in @var-const's PR that includes in_out_result. I hadn't noticed this nit before.)

libcxx/test/std/algorithms/algorithms.results/no_unqiue_address.compile.pass.cpp

1

Please fix the spelling of this file's filename, at some point (here or elsewhere or just as an NFC commit).

[philnik]

• Use MoveOnyl.h
• alphabetize CMakeLists.txt and module.modulemap

[philnik]

libcxx/include/CMakeLists.txt

32

I've already looked at D116958. Thanks for that!

libcxx/test/std/algorithms/algorithms.results/no_unqiue_address.compile.pass.cpp

1

This file was introduced in D116278. I'll fix it there.

[philnik]

• Use MoveOnly.h
• alphabetize CMakeLists.txt and module.modulemap

[philnik]

• Rebased
• Add constexpr test

[philnik]

• Add generated file

[CaseyCarter]

libcxx/include/__algorithm/in_fun_result.h

37

Shouldn't these be _VSTD-qualified?

libcxx/include/algorithm

697

This should be before in_in_result.h on line 702.

[philnik]

• Address comments

[philnik]

ping

[• Quuxplusone]

libcxx/include/algorithm

26

in_out_result isn't listed here; and in_in_out_result either isn't listed, or merge-conflicts.

libcxx/test/std/algorithms/algorithms.results/in_fun_result.pass.cpp

32

Same as on the in_in_out review, I think A would benefit from a comment about // no implicit conversion, and B could just be B(int);
In fact, all my comments from over there also apply here. Please add the exhaustive sets of MoveOnly tests, and so on and so forth. When you're done, diff <(sed s/in_fun/foo/g in_fun_result.pass.cpp) <(sed s/in_in/foo/g in_in_result.pass.cpp) should be basically an empty diff, and ~~~ <(sed s/in_in_out/foo/g in_in_out_result.pass.cpp) not much different.

[var-const]

libcxx/include/__algorithm/in_fun_result.h

17

Does this file need the #pragma GCC system_header annotation?

23

Note: in in_out_result, I used more descriptive/verbose names like _InputIterator. Ideally these should be consistent. I think that having long names is more common in __algorithm/ (quick grepping shows ~360 hits for _InputIterator and 0 hits for _Ip in my current working copy).

30

_LIBCPP_HIDE_FROM_ABI?

libcxx/include/algorithm

26

in_out_result is at the bottom of synopsis (around line 655). I don't have a very strong opinion on where in the synopsis these should be listed, but they should all be together; I'd slightly prefer having them in the end because I feel that these are helper types that don't really need to be in the spotlight.

libcxx/test/std/algorithms/algorithms.results/in_fun_result.pass.cpp

81

Please add return 0;.

libcxx/test/std/algorithms/algorithms.results/no_unique_address.compile.pass.cpp

24 ↗

(On Diff #400652)

Can you please move the corresponding tests in in_out_result.compile.pass.cpp to this file for consistency? (not necessarily in this patch)

31 ↗

(On Diff #400652)

Would it be worthwhile to also test for the case of Empty and Empty2 where both classes are empty but they are distinct types?

[var-const]

libcxx/test/std/algorithms/algorithms.results/in_fun_result.pass.cpp

23–29

Optional: maybe move definitions of ConstructibleFrom and Empty down so that they're right above test() definition and thus closer to the point of usage?

61

Optional: consider adding a brief comment to each test case, e.g. Conversion via copy construction and Conversion via casting (also tests that move-only types can be converted).

70

Perhaps also test with a copy-only type? (that could be overkill)

72

Ultranit: please include <utility>.

[philnik]

• Use MoveOnyl.h
• Add constexpr test
• Add generated file
• Address comments
• Address comments

[philnik]

• Apply changes from in_in_out_result

[philnik]

• Rebased
• use std

[var-const]

LGTM modulo the remaining unresolved comments.

[philnik]

• Fix CI

[• Quuxplusone]

libcxx/include/algorithm

26

@philnik thanks for moving in_out_result up! :)

libcxx/test/std/algorithms/algorithms.results/in_fun_result.pass.cpp

73

s/10L/10/, right?

libcxx/test/std/algorithms/algorithms.results/no_unique_address.compile.pass.cpp

24 ↗

(On Diff #400652)

This was marked "Done", but not done. Since you moved the synopsis comment for in_out_result, I think it would be nice to also move the mentioned tests in this same commit. But if it happens in a followup, also cool.

[philnik]

libcxx/test/std/algorithms/algorithms.results/no_unique_address.compile.pass.cpp

24 ↗

(On Diff #400652)

I'll do it in the results cleanup PR. The synopsis are just to easy to miss for my taste, so I moved them here.

libcxx/include/CMakeLists.txt

set(files
   __algorithm/for_each_n.h
   __algorithm/for_each.h
   __algorithm/generate_n.h
   __algorithm/generate.h
   __algorithm/half_positive.h
   __algorithm/includes.h
   __algorithm/inplace_merge.h
   __algorithm/in_in_result.h
+  __algorithm/in_fun_result.h
   __algorithm/is_heap_until.h
   __algorithm/is_heap.h
   __algorithm/is_partitioned.h
   __algorithm/is_permutation.h
   __algorithm/is_sorted_until.h
   __algorithm/is_sorted.h
   __algorithm/iter_swap.h
   __algorithm/lexicographical_compare.h

libcxx/include/__algorithm/in_fun_result.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___ALGORITHM_IN_FUN_RESULT_H
+#define _LIBCPP___ALGORITHM_IN_FUN_RESULT_H
+
+#include <__concepts/convertible_to.h>
+#include <__config>
+#include <__utility/move.h>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#ifndef _LIBCPP_HAS_NO_RANGES
+
+namespace ranges {
+template <class _Ip, class _Fp>
+struct in_fun_result {
+  [[no_unique_address]] _Ip in;
+  [[no_unique_address]] _Fp fun;
+
+  template <class _I2, class _F2>
+    requires convertible_to<const _Ip&, _I2> && convertible_to<const _Fp&, _F2>
+  constexpr operator in_fun_result<_I2, _F2>() const & {
+    return {in, fun};
+  }
+
+  template <class _I2, class _F2>
+    requires convertible_to<_Ip, _I2> && convertible_to<_Fp, _F2>
+  constexpr operator in_fun_result<_I2, _F2>() && {
+    return {std::move(in), std::move(fun)};
+  }
+};
+} // namespace ranges
+
+#endif // _LIBCPP_HAS_NO_RANGES
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___ALGORITHM_IN_FUN_RESULT_H

libcxx/include/algorithm

 
 #include <initializer_list>
 
 namespace std
 {
 
 namespace ranges {
   template <class I1, class I2>
-    struct in_in_result; // since C++20
+    struct in_in_result;  // since C++20
+
+  template <class I, class F>
+    struct in_fun_result; // since C++20
 }
 
 template <class InputIterator, class Predicate>
     constexpr bool     // constexpr in C++20
     all_of(InputIterator first, InputIterator last, Predicate pred);
 
 template <class InputIterator, class Predicate>
     constexpr bool     // constexpr in C++20

 #include <__algorithm/find_if.h>
 #include <__algorithm/find_if_not.h>
 #include <__algorithm/for_each.h>
 #include <__algorithm/for_each_n.h>
 #include <__algorithm/generate_n.h>
 #include <__algorithm/generate.h>
 #include <__algorithm/half_positive.h>
 #include <__algorithm/includes.h>
+#include <__algorithm/in_fun_result.h>
 #include <__algorithm/inplace_merge.h>
 #include <__algorithm/in_in_result.h>
 #include <__algorithm/is_heap.h>
 #include <__algorithm/is_heap_until.h>
 #include <__algorithm/is_partitioned.h>
 #include <__algorithm/is_permutation.h>
 #include <__algorithm/is_sorted.h>
 #include <__algorithm/is_sorted_until.h>

libcxx/include/module.modulemap

module __algorithm {
       module find_if_not              { private header "__algorithm/find_if_not.h" }
       module for_each                 { private header "__algorithm/for_each.h" }
       module for_each_n               { private header "__algorithm/for_each_n.h" }
       module generate                 { private header "__algorithm/generate.h" }
       module generate_n               { private header "__algorithm/generate_n.h" }
       module half_positive            { private header "__algorithm/half_positive.h" }
       module includes                 { private header "__algorithm/includes.h" }
       module in_in_result             { private header "__algorithm/in_in_result.h" }
+      module in_fun_result            { private header "__algorithm/in_fun_result.h" }
       module inplace_merge            { private header "__algorithm/inplace_merge.h" }
       module is_heap                  { private header "__algorithm/is_heap.h" }
       module is_heap_until            { private header "__algorithm/is_heap_until.h" }
       module is_partitioned           { private header "__algorithm/is_partitioned.h" }
       module is_permutation           { private header "__algorithm/is_permutation.h" }
       module is_sorted                { private header "__algorithm/is_sorted.h" }
       module is_sorted_until          { private header "__algorithm/is_sorted_until.h" }
       module iter_swap                { private header "__algorithm/iter_swap.h" }

libcxx/test/std/algorithms/algorithms.results/in_fun_result.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-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// template <class I1, class I2>
+// struct in_fun_result;
+
+#include <algorithm>
+#include <cassert>
+#include <type_traits>
+
+struct MoveOnly {
+  MoveOnly() = default;
+  MoveOnly(const MoveOnly&) = delete;
+  MoveOnly(MoveOnly&& o) { o.movedFrom = true; }
+
+  bool movedFrom = false;
+};
+
+template <class T>
+struct ConstructibleFrom {
+  ConstructibleFrom(T c) : content{c} {}
+  T content;
+};
+
+struct Empty {};
+
+struct A {
+  explicit A(int);
+};
+static_assert(!std::is_constructible_v<std::ranges::in_fun_result<A, A>,
+                                       std::ranges::in_fun_result<int, int>>);
+
+struct B {
+  B(const int&);
+  B(int&&);
+};
+static_assert(std::is_constructible_v<std::ranges::in_fun_result<B, B>, std::ranges::in_fun_result<int, int>>);
+static_assert(std::is_constructible_v<std::ranges::in_fun_result<B, B>, std::ranges::in_fun_result<int, int>&>);
+static_assert(std::is_constructible_v<std::ranges::in_fun_result<B, B>, const std::ranges::in_fun_result<int, int>>);
+static_assert(std::is_constructible_v<std::ranges::in_fun_result<B, B>, const std::ranges::in_fun_result<int, int>&>);
+
+struct C {
+  C(int&);
+};
+static_assert(!std::is_constructible_v<std::ranges::in_fun_result<C, C>, std::ranges::in_fun_result<int, int>&>);
+
+static_assert(std::is_convertible_v<         std::ranges::in_fun_result<int, int>&, std::ranges::in_fun_result<long, long>>);
+static_assert(!std::is_nothrow_convertible_v<std::ranges::in_fun_result<int, int>&, std::ranges::in_fun_result<long, long>>);
+static_assert(std::is_convertible_v<         const std::ranges::in_fun_result<int, int>&, std::ranges::in_fun_result<long, long>>);
+static_assert(!std::is_nothrow_convertible_v<const std::ranges::in_fun_result<int, int>&, std::ranges::in_fun_result<long, long>>);
+static_assert(std::is_convertible_v<         std::ranges::in_fun_result<int, int>&&, std::ranges::in_fun_result<long, long>>);
+static_assert(!std::is_nothrow_convertible_v<std::ranges::in_fun_result<int, int>&&, std::ranges::in_fun_result<long, long>>);
+static_assert(std::is_convertible_v<         const std::ranges::in_fun_result<int, int>&&, std::ranges::in_fun_result<long, long>>);
+static_assert(!std::is_nothrow_convertible_v<const std::ranges::in_fun_result<int, int>&&, std::ranges::in_fun_result<long, long>>);
+
+int main(int, char**) {
+  {
+    std::ranges::in_fun_result<int, double> res{10L, 0.};
+    assert(res.in == 10);
+    assert(res.fun == 0.);
+    std::ranges::in_fun_result<ConstructibleFrom<int>, ConstructibleFrom<double>> res2 = res;
+    assert(res2.in.content == 10);
+    assert(res2.fun.content == 0.);
+  }
+  {
+    std::ranges::in_fun_result<MoveOnly, Empty> res;
+    assert(!res.in.movedFrom);
+    [[maybe_unused]] auto res2 = static_cast<std::ranges::in_fun_result<MoveOnly, Empty>>(std::move(res));
+    assert(res.in.movedFrom);
+  }
+}

libcxx/test/std/algorithms/algorithms.results/no_unqiue_address.compile.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-no-concepts
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
 // clang-cl and cl currently don't support [[no_unique_address]]
 // XFAIL: msvc
 
 // [[no_unique_address]] for [algorithms.results]
 
 #include <algorithm>
 
 struct Empty {};
 
 static_assert(sizeof(std::ranges::in_in_result<Empty, int>) == sizeof(int));
 static_assert(sizeof(std::ranges::in_in_result<int, Empty>) == sizeof(int));
 static_assert(sizeof(std::ranges::in_in_result<Empty, Empty>) == 2 * sizeof(Empty));
+
+static_assert(sizeof(std::ranges::in_fun_result<Empty, int>) == sizeof(int));
+static_assert(sizeof(std::ranges::in_fun_result<int, Empty>) == sizeof(int));
+static_assert(sizeof(std::ranges::in_fun_result<Empty, Empty>) == 2 * sizeof(Empty));