[libcxx] adds concepts `std::invocable` and `std::regular_invocable`

[cjdb]

Summary

Implements parts of:

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

[Mordante]

Except for the build issue, LGTM!

libcxx/test/std/concepts/callable/invocable.pass.cpp

110 ↗

(On Diff #322022)

Can you initialize it with something different, this seems to cause a build failure when the platform has no random device.

[ldionne]

libcxx/include/concepts

211

The Standard seems to say that we should call invoke unqualified: http://eel.is/c++draft/concept.invocable#concept:invocable.

This seems a bit weird to me - I assume I'm missing some context or mis-reading the paragraph prior to the concept definition?

[CaseyCarter]

libcxx/include/concepts

211

I suspect you're forgetting http://eel.is/c++draft/contents#3 "meow really means ::std::meow". Please don't ask me why the Standard always says std::move / std::forward or my head will explode.

Source comment: there's a weird mixture of _VSTD:: and std:: here - is that intended? (I have a vague notion that std:: is used only for exceptions that are stable across ABIs or something?)

[cjdb]

fixes build issue and replaces std:: with _VSTD::

[cjdb]

adds new lines to EOFs

[ldionne]

libcxx/include/concepts

211

Oh, thanks.

The difference between _VSTD:: and std:: is unclear to me as well, to be entirely honest. Eric tried removing _VSTD:: altogether at some point and the attempt was meant with push back by some people who use the _VSTD macro to completely different ends.

I think you might be mistaking this with the fact that we define exception types outside of the __1 inline namespace so that they mangle the same as exceptions from libstdc++ (when interop between the two was necessary).

[cjdb]

libcxx/include/concepts

214–216

The difference between invocable and regular_invocable is purely semantic. Do we want do add any sort of documentation here to indicate as much?

libcxx/test/std/concepts/callable/invocable.pass.cpp

110 ↗

(On Diff #322022)

Yes, but I'm going to open a bug, because I think

[• Quuxplusone]

libcxx/include/concepts

211

FWIW, I think the difference is purely that _VSTD:: is std::__1::. This is significant in SFINAE-related-mangling contexts, e.g. https://godbolt.org/z/xGbTG7 (which GCC gets wrong anyway).

When I did my big _VSTD::-normalization patch series (mainly focused on eliminating unwanted ADL but also normalizing what was already there), the only places using std:: were std::type_info and std::nothrow_t, both (I assumed) for ABI reasons.

My personal interpretation of libc++ style is that we use std:: only in weird historical ABI corner cases; _VSTD:: for things that would trigger ADL (all function calls taking any parameters, but notably not declval); and for everything else we use no qualification. E.g. in this file _VSTD::is_constructible_v should be just is_constructible_v; and in <chrono> I see four accidental instances of std::numeric_limits which should be just numeric_limits.

Teeny nit: equality-preserving should be hyphenated.

libcxx/test/std/concepts/callable/invocable.compile.pass.cpp

26

spurious ;
FWIW, I'd prefer indenting as

template<class F, class... Args> requires std::invocable<F, Args...>
constexpr void ModelsInvocable(F, Args&&...) noexcept { }

or

template<class F, class... Args>
    requires std::invocable<F, Args...>
constexpr void
ModelsInvocable(F, Args&&...) noexcept { }

114

Incidentally, blech. ;) What's the default here — std::uniform_int_distribution<int>?

libcxx/test/std/concepts/callable/regularinvocable.compile.pass.cpp

115

I would suggest commenting this back in, since a conforming implementation must accept it.
Ideally diff regularinvocable.compile.pass.cpp invocable.compile.pass.cpp should produce only a single line of differences — the name of the constraint.
I might also add a test that verifies that invocable and regular_invocable subsume each other (i.e., a conforming program cannot rely on regular_invocable to be a more specialized constraint than plain invocable).

[• Quuxplusone]

libcxx/include/concepts

138

Could we omit this line, and use _VSTD::__invoke (from <type_traits>) below instead of _VSTD::invoke (from <functional>)?
Alternatively, could someone add to their to-do list "move std::invoke into <type_traits> or something" so that <concepts> doesn't have to pull in all the <functional> stuff?

libcxx/include/concepts

namespace std {
   // [concept.strictweakorder], concept strict_weak_order
   template<class R, class T, class U>
     concept strict_weak_order = see below;
 }
 
 */
 
 #include <__config>
+#include <functional>
 #include <type_traits>
+#include <utility>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>

 
 template<class _Tp>
 concept default_initializable = constructible_from<_Tp> &&
     requires { _Tp{}; } && __default_initializable<_Tp>;
 
 // [concept.moveconstructible]
 template<class _Tp>
 concept move_constructible =
   constructible_from<_Tp, _Tp> && convertible_to<_Tp, _Tp>;
 
 // [concept.copyconstructible]
 template<class _Tp>
 concept copy_constructible =
   move_constructible<_Tp> &&
   constructible_from<_Tp, _Tp&> && convertible_to<_Tp&, _Tp> &&
   constructible_from<_Tp, const _Tp&> && convertible_to<const _Tp&, _Tp> &&
   constructible_from<_Tp, const _Tp> && convertible_to<const _Tp, _Tp>;
 
+// [concept.invocable]
+template<class _Fn, class... _Args>
+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
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP_CONCEPTS

libcxx/test/std/concepts/callable/functions.h

+//===----------------------------------------------------------------------===//
+//
+// 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 CALLABLE_FUNCTIONS_H
+#define CALLABLE_FUNCTIONS_H
+
+namespace RegularInvocable {
+struct A {
+  int I = 13;
+  constexpr int F() const noexcept { return 42; }
+  constexpr int G(int X) { return 2 * X + 1; }
+  constexpr int H(int J) && { return I * J; }
+};
+
+constexpr int F() noexcept { return 13; }
+constexpr int G(int I) { return 2 * I + 1; }
+} // namespace RegularInvocable
+
+namespace Predicate {
+struct L2rSorted {
+  template <class T>
+  constexpr bool operator()(T const& A, T const& B, T const& C) const noexcept {
+    return A <= B && B <= C;
+  }
+};
+
+struct NotAPredicate {
+  void operator()() const noexcept {}
+};
+} // namespace Predicate
+
+namespace Relation {
+int Greater(int X, int Y) noexcept { return X > Y; }
+} // namespace Relation
+
+#endif // CALLABLE_FUNCTIONS_H

libcxx/test/std/concepts/callable/invocable.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, class U>
+// concept invocable;
+
+#include <chrono>
+#include <concepts>
+#include <memory>
+#include <random>
+#include <type_traits>
+
+#include "functions.h"
+
+template <class F, class... Args>
+requires std::invocable<F, Args...> constexpr void
+ModelsInvocable(F, Args&&...) noexcept{};
+
+template <class F, class... Args>
+requires(!std::invocable<F, Args...>) constexpr
+    void NotInvocable(F, Args&&...) noexcept {}
+
+static_assert(!std::invocable<void>);
+static_assert(!std::invocable<void*>);
+static_assert(!std::invocable<int>);
+static_assert(!std::invocable<int&>);
+static_assert(!std::invocable<int&&>);
+
+int main(int, char**) {
+  {
+    using namespace RegularInvocable;
+
+    ModelsInvocable(F);
+    NotInvocable(F, 0);
+
+    ModelsInvocable(G, 2);
+    NotInvocable(G);
+    NotInvocable(G, 3, 0);
+
+    NotInvocable(&A::I);
+    NotInvocable(&A::F);
+
+    {
+      auto X = A{};
+      ModelsInvocable(&A::I, X);
+      ModelsInvocable(&A::F, X);
+      ModelsInvocable(&A::G, X, 0);
+      NotInvocable(&A::G, X);
+      NotInvocable(&A::G, 0);
+      NotInvocable(&A::H);
+
+      auto const& Y = X;
+      ModelsInvocable(&A::I, Y);
+      ModelsInvocable(&A::F, Y);
+      NotInvocable(&A::G, Y, 0);
+      NotInvocable(&A::H, Y, 0);
+    }
+
+    ModelsInvocable(&A::I, A{});
+    ModelsInvocable(&A::F, A{});
+    ModelsInvocable(&A::G, A{}, 0);
+    ModelsInvocable(&A::H, A{}, 0);
+
+    {
+      auto Up = std::make_unique<A>();
+      ModelsInvocable(&A::I, Up);
+      ModelsInvocable(&A::F, Up);
+      ModelsInvocable(&A::G, Up, 0);
+      NotInvocable(&A::H, Up, 0);
+    }
+    {
+      auto Sp = std::make_shared<A>();
+      ModelsInvocable(&A::I, Sp);
+      ModelsInvocable(&A::F, Sp);
+      ModelsInvocable(&A::G, Sp, 0);
+      NotInvocable(&A::H, Sp, 0);
+    }
+  }
+  {
+    using namespace Predicate;
+    {
+      ModelsInvocable(L2rSorted{}, 0, 1, 2);
+      NotInvocable(L2rSorted{});
+      NotInvocable(L2rSorted{}, 0);
+      NotInvocable(L2rSorted{}, 0, 1);
+    }
+    {
+      auto Up = std::make_unique<L2rSorted>();
+      ModelsInvocable(&L2rSorted::operator()<int>, Up, 0, 1, 2);
+      NotInvocable(&L2rSorted::operator()<int>, Up);
+      NotInvocable(&L2rSorted::operator()<int>, Up, 0);
+      NotInvocable(&L2rSorted::operator()<int>, Up, 0, 1);
+    }
+    {
+      auto Sp = std::make_shared<L2rSorted>();
+      ModelsInvocable(&L2rSorted::operator()<int>, Sp, 0, 1, 2);
+      NotInvocable(&L2rSorted::operator()<int>, Sp);
+      NotInvocable(&L2rSorted::operator()<int>, Sp, 0);
+      NotInvocable(&L2rSorted::operator()<int>, Sp, 0, 1);
+    }
+  }
+  {
+    auto G = std::mt19937_64(
+        std::chrono::high_resolution_clock().now().time_since_epoch().count());
+    auto D = std::uniform_int_distribution<>();
+    ModelsInvocable(D, G);
+  }
+  return 0;
+}

libcxx/test/std/concepts/callable/regularinvocable.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, class U>
+// concept regular_invocable;
+
+#include <concepts>
+#include <memory>
+#include <random>
+#include <type_traits>
+
+#include "functions.h"
+
+template <class F, class... Args>
+requires std::invocable<F, Args...> constexpr void
+ModelsRegularInvocable(F, Args&&...) noexcept{};
+
+template <class F, class... Args>
+requires(!std::invocable<F, Args...>) constexpr
+    void NotRegularInvocable(F, Args&&...) noexcept {}
+
+static_assert(!std::invocable<void>);
+static_assert(!std::invocable<void*>);
+static_assert(!std::invocable<int>);
+static_assert(!std::invocable<int&>);
+static_assert(!std::invocable<int&&>);
+
+int main(int, char**) {
+  {
+    using namespace RegularInvocable;
+
+    ModelsRegularInvocable(F);
+    NotRegularInvocable(F, 0);
+
+    ModelsRegularInvocable(G, 2);
+    NotRegularInvocable(G);
+    NotRegularInvocable(G, 3, 0);
+
+    NotRegularInvocable(&A::I);
+    NotRegularInvocable(&A::F);
+
+    {
+      auto X = A{};
+      ModelsRegularInvocable(&A::I, X);
+      ModelsRegularInvocable(&A::F, X);
+      ModelsRegularInvocable(&A::G, X, 0);
+      NotRegularInvocable(&A::G, X);
+      NotRegularInvocable(&A::G, 0);
+      NotRegularInvocable(&A::H);
+
+      auto const& Y = X;
+      ModelsRegularInvocable(&A::I, Y);
+      ModelsRegularInvocable(&A::F, Y);
+      NotRegularInvocable(&A::G, Y, 0);
+      NotRegularInvocable(&A::H, Y, 0);
+    }
+
+    ModelsRegularInvocable(&A::I, A{});
+    ModelsRegularInvocable(&A::F, A{});
+    ModelsRegularInvocable(&A::G, A{}, 0);
+    ModelsRegularInvocable(&A::H, A{}, 0);
+
+    {
+      auto Up = std::make_unique<A>();
+      ModelsRegularInvocable(&A::I, Up);
+      ModelsRegularInvocable(&A::F, Up);
+      ModelsRegularInvocable(&A::G, Up, 0);
+      NotRegularInvocable(&A::H, Up, 0);
+    }
+    {
+      auto Sp = std::make_shared<A>();
+      ModelsRegularInvocable(&A::I, Sp);
+      ModelsRegularInvocable(&A::F, Sp);
+      ModelsRegularInvocable(&A::G, Sp, 0);
+      NotRegularInvocable(&A::H, Sp, 0);
+    }
+  }
+  {
+    using namespace Predicate;
+    {
+      ModelsRegularInvocable(L2rSorted{}, 0, 1, 2);
+      NotRegularInvocable(L2rSorted{});
+      NotRegularInvocable(L2rSorted{}, 0);
+      NotRegularInvocable(L2rSorted{}, 0, 1);
+    }
+    {
+      auto Up = std::make_unique<L2rSorted>();
+      ModelsRegularInvocable(&L2rSorted::operator()<int>, Up, 0, 1, 2);
+      NotRegularInvocable(&L2rSorted::operator()<int>, Up);
+      NotRegularInvocable(&L2rSorted::operator()<int>, Up, 0);
+      NotRegularInvocable(&L2rSorted::operator()<int>, Up, 0, 1);
+    }
+    {
+      auto Sp = std::make_shared<L2rSorted>();
+      ModelsRegularInvocable(&L2rSorted::operator()<int>, Sp, 0, 1, 2);
+      NotRegularInvocable(&L2rSorted::operator()<int>, Sp);
+      NotRegularInvocable(&L2rSorted::operator()<int>, Sp, 0);
+      NotRegularInvocable(&L2rSorted::operator()<int>, Sp, 0, 1);
+    }
+  }
+  // {
+  // RNG doesn't model regular_invocable, left here for documentation
+  //  auto G = std::mt19937_64(std::random_device()());
+  //  auto D = std::uniform_int_distribution<>();
+  //  models_invocable(D, G);
+  // }
+  return 0;
+}

libcxx/test/std/concepts/lang/derived.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++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 
 // template<class Derived, class Base>
 // concept derived_from;
 
 #include <concepts>
 #include <type_traits>