Add function with invoke and result_of_t

asl/BUILD.bazel

@@ -5,6 +5,7 @@ cc_library(
         "assert.hpp",
         "config.hpp",
         "format.hpp",
+        "functional.hpp",
         "integers.hpp",
         "io.hpp",
         "layout.hpp",
@@ -34,6 +35,7 @@ cc_library(
     ],
 ) for name in [
     "format",
+    "functional",
     "integers",
     "maybe_uninit",
     "meta",

asl/functional.hpp

@@ -0,0 +1,65 @@
+#pragma once
+
+#include "asl/meta.hpp"
+#include "asl/utility.hpp"
+
+namespace asl {
+
+template<typename... Args, typename C>
+constexpr auto invoke(is_func auto C::* f, auto&& self, Args&&... args)
+    requires requires {
+        (self.*f)(ASL_FWD(args)...);
+    }
+{
+    return (ASL_FWD(self).*f)(ASL_FWD(args)...);
+}
+
+template<typename... Args, typename C>
+constexpr auto invoke(is_func auto C::* f, auto* self, Args&&... args)
+    requires requires {
+        (self->*f)(ASL_FWD(args)...);
+    }
+{
+    return (self->*f)(ASL_FWD(args)...);
+}
+
+template<typename... Args, typename C>
+constexpr auto invoke(is_object auto C::* m, auto&& self, Args&&...)
+    requires (
+        sizeof...(Args) == 0 &&
+        requires { self.*m; }
+    )
+{
+    return ASL_FWD(self).*m;
+}
+
+template<typename... Args, typename C>
+constexpr auto invoke(is_object auto C::* m, auto* self, Args&&...)
+    requires (
+        sizeof...(Args) == 0 &&
+        requires { self->*m; }
+    )
+{
+    return self->*m;
+}
+
+template<typename... Args>
+constexpr auto invoke(auto&& f, Args&&... args)
+    requires requires {
+        f(ASL_FWD(args)...);
+    }
+{
+    return ASL_FWD(f)(ASL_FWD(args)...);
+}
+
+template<typename F> struct _result_of_helper;
+
+template<typename R, typename... Args>
+struct _result_of_helper<R(Args...)>
+{
+    using type = decltype(invoke(declval<R>(), declval<Args>()...));
+};
+
+template<typename F> using result_of_t = _result_of_helper<F>::type;
+
+} // namespace asl

asl/meta.hpp

@@ -35,6 +35,8 @@ template<typename T> auto _as_rref_helper(...) -> id<T>;
 template<typename T> using as_lref_t = decltype(_as_lref_helper<T>(0))::type;
 template<typename T> using as_rref_t = decltype(_as_rref_helper<T>(0))::type;
 
+template<typename T> consteval as_rref_t<T> declval() {}
+
 template<typename T> struct _un_ref_t      { using type = T; };
 template<typename T> struct _un_ref_t<T&>  { using type = T; };
 template<typename T> struct _un_ref_t<T&&> { using type = T; };
@@ -67,9 +69,13 @@ template<typename T> concept trivially_destructible = __is_trivially_destructibl
 
 template<typename T> concept trivially_copyable = __is_trivially_copyable(T);
 
+// @Todo Rename concepts (_from)
 template<typename From, typename To>
 concept convertible = __is_convertible(From, To);
 
+template<typename Derived, class Base>
+concept derived_from = __is_class(Derived) && __is_class(Base) && convertible<const volatile Derived*, const volatile Base*>;
+
 using nullptr_t = decltype(nullptr);
 
 template<typename T> struct _un_const_helper          { using type = T; };

asl/tests/functional_tests.cpp

@@ -0,0 +1,73 @@
+#include "asl/functional.hpp"
+#include "asl/testing/testing.hpp"
+
+struct HasFunction
+{
+    void do_something(int, float) {}
+};
+
+struct HasMember
+{
+    int member{};
+    int member_array[4]{};
+    void (*member_fn)(){};
+};
+
+struct Functor
+{
+    int64_t operator()() { return 35; }
+    int operator()(int x) { return x; }
+};
+
+static int some_func0() { return 1; }
+static int some_func1(int x) { return x + 1; }
+static float some_func1(float x) { return x + 1; }
+static int some_func2(int x, int b) { return x + b; }
+
+static_assert(asl::is_same<asl::result_of_t<Functor()>, int64_t>);
+static_assert(asl::is_same<asl::result_of_t<Functor(int)>, int>);
+static_assert(asl::is_same<asl::result_of_t<decltype(static_cast<float(*)(float)>(some_func1))(float)>, float>);
+static_assert(asl::is_same<asl::result_of_t<decltype(&HasFunction::do_something)(HasFunction, int, float)>, void>);
+static_assert(asl::is_same<asl::result_of_t<decltype(&HasMember::member)(HasMember)>, int>);
+
+ASL_TEST(invoke_member_function)
+{
+    HasFunction c;
+    asl::invoke(&HasFunction::do_something, c, 5, 5.0F);
+    asl::invoke(&HasFunction::do_something, &c, 5, 5.0F);
+}
+
+ASL_TEST(invoke_member_data)
+{
+    HasMember c;
+    
+    asl::invoke(&HasMember::member, c);
+    asl::invoke(&HasMember::member_array, c);
+    asl::invoke(&HasMember::member_fn, c);
+    asl::invoke(&HasMember::member, &c);
+    asl::invoke(&HasMember::member_array, &c);
+    asl::invoke(&HasMember::member_fn, &c);
+}
+
+ASL_TEST(invoke_fn)
+{
+    ASL_TEST_EXPECT(asl::invoke(some_func0) == 1);
+    ASL_TEST_EXPECT(asl::invoke(static_cast<int(*)(int)>(some_func1), 8) == 9);
+    ASL_TEST_EXPECT(asl::invoke(some_func2, 4, 8) == 12);
+    ASL_TEST_EXPECT(asl::invoke(&some_func0) == 1);
+    ASL_TEST_EXPECT(asl::invoke(static_cast<int(*)(int)>(&some_func1), 8) == 9);
+    ASL_TEST_EXPECT(asl::invoke(&some_func2, 4, 8) == 12);
+}
+
+ASL_TEST(invoke_operator_call)
+{
+    Functor f;
+    ASL_TEST_EXPECT(asl::invoke(f) == 35);
+    ASL_TEST_EXPECT(asl::invoke(f, 8) == 8);
+}
+
+ASL_TEST(invoke_lambda)
+{
+    ASL_TEST_EXPECT(asl::invoke([](){ return 35; }) == 35);
+    ASL_TEST_EXPECT(asl::invoke([](int x){ return x + 2; }, 6) == 8);
+}

asl/tests/meta_tests.cpp

@@ -1,5 +1,6 @@
 #include "asl/meta.hpp"
 #include "asl/tests/test_types.hpp"
+#include "asl/testing/testing.hpp"
 
 struct Struct {};
 union Union {};
@@ -180,3 +181,12 @@ static_assert(!asl::convertible<Base*, Derived*>);
 static_assert(asl::convertible<D, C>);
 static_assert(!asl::convertible<Derived*, C*>);
 static_assert(asl::convertible<Base, E>);
+
+static_assert(asl::derived_from<Derived, Base>);
+static_assert(!asl::derived_from<Base, Derived>);
+static_assert(!asl::derived_from<D, C>);
+static_assert(!asl::derived_from<C, D>);
+static_assert(!asl::derived_from<uint8_t, uint16_t>);
+static_assert(!asl::derived_from<uint16_t, uint8_t>);
+static_assert(!asl::derived_from<int, int>);
+