[libcxx] adds concept `std::uniform_random_bit_generator`

[cjdb]

Summary

Implements parts of:

• P0898R3 Standard Library Concepts
• P1754 Rename concepts to standard_case for C++20, while we still can

[cjdb]

undoes weird clang-formatting

[miscco]

Thanks for working on this. It is missing uglification but besides that I only have one small nit

libcxx/include/random

1707

This should be _Ugly, maybe use _Gen?

libcxx/test/std/numerics/rand/rand.req/rand.req.urng/uniform_random_bit_generator.compile.pass.cpp

119

I think that 1 and 0 would be more obvious that ~0 and 0

[miscco]

libcxx/include/random

1704

in https://reviews.llvm.org/D93166 we have a definition of _LIBCPP_HAS_NO_CONCEPTS

Should we reuse that globally and why are there different values ofr the macro?

[cjdb]

applies @miscco's feedback

[cjdb]

@ldionne can we override the Mac OS format failure? What it's proposing is abominable.

[cjdb]

undoes !_LIBCPP_HAS_NO_CONCEPTS change in an attempt to get the Mac OS build working

[Mordante]

In D96577#2561522, @cjdb wrote:

undoes !_LIBCPP_HAS_NO_CONCEPTS change in an attempt to get the Mac OS build working

Yes there seems to be a bug in that code. I've put it in a block for GCC specific code. (This is not obvious due to the lack of indention of the section.)
I'm testing a fix.

libcxx/include/random

22

Please add comment this has been added in C++20.

libcxx/test/std/numerics/rand/rand.req/rand.req.urng/uniform_random_bit_generator.compile.pass.cpp

21

Can you guard this with #ifndef _LIBCPP_HAS_NO_INT128?

123

Can you add a test where min() and max() return the same value?

[cjdb]

applies @Mordante's feedback

[cjdb]

Yes there seems to be a bug in that code. I've put it in a block for GCC specific code. (This is not obvious due to the lack of indention of the section.)

Oh, it might be because Clang's concepts are incomplete and so the feature-test macro's value is too high for us? Anyway, if you update everything in one fell swoop, I think that'd be best :-)

[Mordante]

In D96577#2562047, @cjdb wrote:

Yes there seems to be a bug in that code. I've put it in a block for GCC specific code. (This is not obvious due to the lack of indention of the section.)

Oh, it might be because Clang's concepts are incomplete and so the feature-test macro's value is too high for us? Anyway, if you update everything in one fell swoop, I think that'd be best :-)

No it was the placement in the file. But I'll fix <random> and <concept> after the fix has landed.

[Mordante]

libcxx/test/std/numerics/rand/rand.req/rand.req.urng/uniform_random_bit_generator.compile.pass.cpp

122

Is this a copy-paste error, I assume this should be zero.

[cjdb]

fixes copypasta

[ldionne]

LGTM apart for the nitpick. Let's settle on what we do about it and ship this.

libcxx/include/random

1704

why are there different values ofr the macro?

I don't know. @cjdb do you know what 201907L vs 201811L represents for __cpp_concepts?

Should we reuse that globally

Depending to the answer to the question above, I think it would make sense to use #if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS).

[cjdb]

libcxx/include/random

1704

I believe @Mordante has a patch to fix this globally. As for 201811L vs 201907L, this is consistent with what's in libc++ <concepts> right now.

[cjdb]

libcxx/include/random

1704

@saar.raz do you know the difference between these two values for __cpp_concepts?

[CaseyCarter]

libcxx/include/random

1704

https://isocpp.org/std/standing-documents/sd-6-sg10-feature-test-recommendations#__cpp_concepts explains the history fairly well.

[ldionne]

libcxx/include/random

1704

Oh, thanks for the link. @cjdb let's use 201907L consistently everywhere if you're OK with that.

[Mordante]

libcxx/include/random

1704

I used 201907L since that's the version used in Clang since @saar.raz's branch has been merged.

libcxx/include/concepts

 concept invocable = requires(_Fn&& __fn, _Args&&... __args) {
   _VSTD::invoke(_VSTD::forward<_Fn>(__fn), _VSTD::forward<_Args>(__args)...); // not required to be equality preserving
 };
 
 // [concept.regular.invocable]
 template<class _Fn, class... _Args>
 concept regular_invocable = invocable<_Fn, _Args...>;
 
-#endif //_LIBCPP_STD_VER > 17 && defined(__cpp_concepts) && __cpp_concepts >= 201811L
+#endif // _LIBCPP_STD_VER > 17 && defined(__cpp_concepts) && __cpp_concepts >= 201811L
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP_CONCEPTS

libcxx/include/random

 
 /*
     random synopsis
 
 #include <initializer_list>
 
 namespace std
 {
+// [rand.req.urng], uniform random bit generator requirements
+template<class G>
+concept uniform_random_bit_generator = see below; // C++20
 
 // Engines
 
 template <class UIntType, UIntType a, UIntType c, UIntType m>
 class linear_congruential_engine
 {
 public:
     // types

 
 } // std
 */
 
 #include <__config>
 #include <cstddef>
 #include <cstdint>
 #include <cmath>
+#include <concepts>
 #include <type_traits>
 #include <initializer_list>
 #include <limits>
 #include <algorithm>
 #include <numeric>
 #include <vector>
 #include <string>
 #include <iosfwd>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+#if _LIBCPP_STD_VER > 17 && defined(__cpp_concepts) && __cpp_concepts >= 201811L
+
+// [rand.req.urng]
+template<class _Gen>
+concept uniform_random_bit_generator =
+  invocable<_Gen&> && unsigned_integral<invoke_result_t<_Gen&>> &&
+  requires {
+    { _Gen::min() } -> same_as<invoke_result_t<_Gen&>>;
+    { _Gen::max() } -> same_as<invoke_result_t<_Gen&>>;
+    requires bool_constant<(_Gen::min() < _Gen::max())>::value;
+  };
+
+#endif // _LIBCPP_STD_VER > 17 && defined(__cpp_concepts) && __cpp_concepts >= 201811L
+
 // __is_seed_sequence
 
 template <class _Sseq, class _Engine>
 struct __is_seed_sequence
 {
     static _LIBCPP_CONSTEXPR const bool value =
               !is_convertible<_Sseq, typename _Engine::result_type>::value &&
               !is_same<typename remove_cv<_Sseq>::type, _Engine>::value;

libcxx/test/std/concepts/lang/arithmetic.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++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 
 // template<class T>
 // concept integral = // see below
 
 // template<class T>
 // concept signed_integral = // see below
 

libcxx/test/std/numerics/rand/rand.req/rand.req.urng/nothing_to_do.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
-//
-//===----------------------------------------------------------------------===//
-
-int main(int, char**)
-{
-
-  return 0;
-}

libcxx/test/std/numerics/rand/rand.req/rand.req.urng/uniform_random_bit_generator.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
+
+// template<class T>
+// concept uniform_random_bit_generator = // see below
+
+#include <random>
+
+static_assert(std::uniform_random_bit_generator<
+              std::linear_congruential_engine<unsigned int, 0U, 1U, 2U> >);
+
+#ifndef _LIBCPP_HAS_NO_INT128
+static_assert(std::uniform_random_bit_generator<
+              std::subtract_with_carry_engine<__uint128_t, 1U, 2U, 3U> >);
+#endif
+
+// Not invocable
+static_assert(!std::uniform_random_bit_generator<void>);
+static_assert(!std::uniform_random_bit_generator<int>);
+static_assert(!std::uniform_random_bit_generator<int[10]>);
+static_assert(!std::uniform_random_bit_generator<int*>);
+static_assert(!std::uniform_random_bit_generator<const int*>);
+static_assert(!std::uniform_random_bit_generator<volatile int*>);
+static_assert(!std::uniform_random_bit_generator<const volatile int*>);
+static_assert(!std::uniform_random_bit_generator<int&>);
+static_assert(!std::uniform_random_bit_generator<const int&>);
+static_assert(!std::uniform_random_bit_generator<volatile int&>);
+static_assert(!std::uniform_random_bit_generator<const volatile int&>);
+static_assert(!std::uniform_random_bit_generator<int&&>);
+static_assert(!std::uniform_random_bit_generator<const int&&>);
+static_assert(!std::uniform_random_bit_generator<volatile int&&>);
+static_assert(!std::uniform_random_bit_generator<const volatile int&&>);
+
+struct Empty {};
+static_assert(!std::uniform_random_bit_generator<Empty>);
+
+namespace WrongReturnType {
+using FunctionPointer = void (*)();
+static_assert(!std::uniform_random_bit_generator<FunctionPointer>);
+
+using FunctionReference = int (&)();
+static_assert(!std::uniform_random_bit_generator<FunctionReference>);
+
+struct FunctionObject {
+  unsigned long* operator()();
+};
+static_assert(!std::uniform_random_bit_generator<FunctionObject>);
+static_assert(!std::uniform_random_bit_generator<unsigned int Empty::*>);
+static_assert(!std::uniform_random_bit_generator<unsigned short (Empty::*)()>);
+} // namespace WrongReturnType
+
+namespace NoMinOrMax {
+using FunctionPointer = unsigned int (*)();
+static_assert(!std::uniform_random_bit_generator<FunctionPointer>);
+
+using FunctionReference = unsigned long long (&)();
+static_assert(!std::uniform_random_bit_generator<FunctionReference>);
+
+struct FunctionObject {
+  unsigned char operator()();
+};
+static_assert(!std::uniform_random_bit_generator<FunctionObject>);
+} // namespace NoMinOrMax
+
+namespace OnlyMinIsRight {
+struct NoMax {
+  unsigned char operator()();
+
+  static unsigned char min();
+};
+static_assert(!std::uniform_random_bit_generator<NoMax>);
+
+struct MaxHasWrongReturnType {
+  unsigned char operator()();
+
+  static unsigned char min();
+  static unsigned int max();
+};
+
+static_assert(!std::uniform_random_bit_generator<MaxHasWrongReturnType>);
+} // namespace OnlyMinIsRight
+
+namespace OnlyMaxIsRight {
+struct NoMin {
+  unsigned char operator()();
+
+  static unsigned char max();
+};
+static_assert(!std::uniform_random_bit_generator<NoMin>);
+
+struct MinHasWrongReturnType {
+  unsigned char operator()();
+
+  static unsigned int min();
+  static unsigned char max();
+};
+
+static_assert(!std::uniform_random_bit_generator<MinHasWrongReturnType>);
+} // namespace OnlyMaxIsRight
+
+namespace MinNotLessMax {
+struct NotConstexpr {
+  unsigned char operator()();
+
+  static unsigned char min();
+  static unsigned char max();
+};
+static_assert(!std::uniform_random_bit_generator<NotConstexpr>);
+
+struct MinEqualsMax {
+  unsigned char operator()();
+
+  static constexpr unsigned char min() { return 0; }
+  static constexpr unsigned char max() { return 0; }
+};
+static_assert(!std::uniform_random_bit_generator<MinEqualsMax>);
+
+struct MaxLessThanMin {
+  unsigned char operator()();
+
+  static constexpr unsigned char min() { return 1; }
+  static constexpr unsigned char max() { return 0; }
+};
+static_assert(!std::uniform_random_bit_generator<MaxLessThanMin>);
+} // namespace MinNotLessMax
+
+struct Works {
+  unsigned char operator()();
+
+  static constexpr unsigned char min() { return 0; }
+  static constexpr unsigned char max() { return 1; }
+};
+static_assert(std::uniform_random_bit_generator<Works>);
+
+int main(int, char**) { return 0; }