Feature invocable and function (#34)

* fixing the Ascii doc from C to C++

* ✨ added is_function and is_invocable features

* ✨ updated the operators for callable list and its example

* 💚 fixed the CI build issue

Author: bvbasavaraju

docs/utility.adoc

@@ -94,3 +94,41 @@ using select_f_c_t {
 * `select_qmf_c_t` => to avoid `::type`
 * `select_qmf` => when `false` type is captured with quoted meta function, and condition is a type
 * `select_qmf_t` => to avoid `::type`
+
+=== is_function
+
+This will check if the provided type is a function or not.
+
+[source, cpp]
+template <typename T>
+struct is_function {
+  ...
+};
+
+If the provided type is not a reference and adding const to type will not result in the const, then it is considered as function.
+
+variants of `is_function` are:
+
+* `is_function_t` => to avoid using `::type`
+* `is_function_v` => to avoid using `::value`
+
+=== is_invocable
+
+This will check if the provided type is a `function` OR a class which implements `operator()`
+
+[source, cpp]
+template <typename T>
+struct is_invocable {
+  ...
+};
+
+It makes use of the https://en.wikibooks.org/wiki/More_C++_Idioms/Member_Detector[CPP member detection idiom] technique.
+
+If the provided T is a function, then it will result in `std::true_type`
+If the provided T is a class, if it implements `operator()` then it will result in `std::true_type`
+otherwise it will result in `std::false_type`
+
+variants of `is_invocable` are:
+
+* `is_invocable_t` => to avoid using `::type`
+* `is_invocable_v` => to avoid using `::value`

include/container/list.hpp

@@ -1,5 +1,8 @@
 #pragma once
 
+#include <utils.hpp>
+// #include <type_traits>
+
 namespace ctl {
 
 // list
@@ -11,6 +14,16 @@ struct ilist {};
 
 template <typename... types>
 struct clist : public ilist<types...> {
+  private:
+    constexpr static auto get_value = []<typename T>() {
+        if constexpr (ctl::is_invocable_v<T>) {
+            return T{}();
+        } else {
+            return T::value;
+        }
+    };
+
+  public:
     constexpr auto operator()() {
         return (types{}(), ...);
     }
@@ -19,8 +32,39 @@ struct clist : public ilist<types...> {
         return (predicate(types{}), ...);
     }
 
+    // bitwise
+    constexpr auto operator|(auto initialVal) {
+        return (initialVal | ... | (get_value.template operator()<types>()));
+    }
+
+    constexpr auto operator&(auto initialVal) {
+        return (initialVal & ... & (get_value.template operator()<types>()));
+    }
+
+    constexpr auto operator^(auto initialVal) {
+        return (initialVal ^ ... ^ (get_value.template operator()<types>()));
+    }
+
+    // logical
     constexpr auto operator||(auto inital_val) -> bool {
-        return (types{} || ... || inital_val);
+        return (inital_val || ... || (get_value.template operator()<types>()));
+    }
+
+    constexpr auto operator&&(auto inital_val) -> bool {
+        return (inital_val && ... && (get_value.template operator()<types>()));
+    }
+
+    // Calculative
+    constexpr auto operator+(auto initialVal) {
+        return (initialVal + ... + (get_value.template operator()<types>()));
+    }
+
+    constexpr auto operator-(auto initialVal) {
+        return (initialVal - ... - (get_value.template operator()<types>()));
+    }
+
+    constexpr auto operator*(auto initialVal) {
+        return (initialVal * ... * (get_value.template operator()<types>()));
     }
 
     // TODO: other operators!!

include/utils.hpp

@@ -126,4 +126,59 @@ using select_qmf = select_f<C, T, QMF::template fn, Ts...>;
 template <typename C, typename T, typename QMF, typename... Ts>
 using select_qmf_t = typename select_qmf<C, T, QMF, Ts...>::type;
 
+// is_function
+template <typename T>
+struct is_function {
+  private:
+    struct is_function_impl {
+        constexpr static bool value = !std::is_reference_v<T> && !std::is_const_v<std::add_const_t<T>>;
+    };
+
+  public:
+    using type = std::integral_constant<bool, is_function_impl::value>;
+};
+
+template <typename T>
+using is_function_t = typename is_function<T>::type;
+
+template <typename T>
+constexpr static auto is_function_v = is_function_t<T>::value;
+
+// is invocable
+/*
+    using member detection idiom:
+    https://en.wikibooks.org/wiki/More_C++_Idioms/Member_Detector
+*/
+template <typename T>
+struct is_invocable {
+  private:
+    // member detection idiom. member to detect here is 'operator()'
+    struct call_operator {
+        auto operator()() -> void {};
+    };
+
+    template <typename F, bool> 
+    struct derived : call_operator {};
+
+    template <typename F>
+    struct derived <F, true> : F, call_operator {};
+
+    //invocable impl
+    //if T also has operator() defined, then there will be ambiguity in the std::void_t<> will be ill-formed, so only true_type is accepted.
+    template <typename, typename = void>
+    struct is_invocable_impl : public std::true_type {};
+
+    template <typename U>
+    struct is_invocable_impl<U, std::void_t< decltype(& derived<U, std::is_class_v<U>>::operator()) > > : public std::false_type {};
+
+  public:
+    using type = std::integral_constant<bool, is_function_v<T> || is_invocable_impl<T>::value>;
+};
+
+template <typename T>
+using is_invocable_t = typename is_invocable<T>::type;
+
+template <typename T>
+constexpr static auto is_invocable_v = is_invocable_t<T>::value;
+
 }  // namespace ctl

src/main.cpp

@@ -7,25 +7,25 @@ struct super_type {
     auto attendence() const {
         std::cout << "Present" << std::endl;
     }
+    
+    virtual void name() const = 0;
 };
-
 struct type1 : public super_type {
-    auto operator()() {
-        std::cout << "inside type1\n";
+    void name() const {
+        std::cout << "type1: ";
     }
 
-    auto operator||(auto val) {
-        return val || false;
+    auto operator()() const -> bool {
+        return false;
     }
 };
-
 struct type2 : public super_type {
-    auto operator()() {
-        std::cout << "inside type2\n";
+    void name() const {
+        std::cout << "type2: ";
     }
 
-    auto operator||(auto val) {
-        return val || false;
+    auto operator()() const -> bool {
+        return true;
     }
 };
 
@@ -50,16 +50,23 @@ int main() {
 
         // with predicate!
         constexpr auto fn = [](auto const& obj) {
+            obj.name();
             obj.attendence();
         };
+
         ctypes_all{}(fn);
 
-        // with operator logical OR
-        if (ctypes_all{} || false) {
-            std::cout << "Operation Logical OR returned true" << std::endl;
-        } else {
-            std::cout << "Operation Logical OR returned false" << std::endl;
-        }
+        // Operator overloading
+        using numList = ctl::clist<std::integral_constant<uint32_t, 1>,std::integral_constant<uint32_t, 2>, std::integral_constant<uint32_t, 3>>;
+        std::cout << "operator|: " << (numList{} | 0) << std::endl;
+        std::cout << "operator&: " << (numList{} & 0xFF) << std::endl;
+        std::cout << "operator^: " << (numList{} ^ 0) << std::endl;
+        std::cout << "operator^: " << (numList{} ^ 0xFF) << std::endl;
+        std::cout << "operator||: " << (ctypes_all{} || false) << std::endl;
+        std::cout << "operator&&: " << (ctypes_all{} && true) << std::endl; 
+        std::cout << "operator+: " << (numList{} + 10) << std::endl;
+        std::cout << "operator-: " << (numList{} - 10) << std::endl;
+        std::cout << "operator*: " << (numList{} * 10) << std::endl;
     }
 
     return 0;