optimize any to accept a normal function without function pointer; optimize template is_basic_type<T>.

Author: xhawk18

example/test0.cpp

@@ -91,8 +91,8 @@ Promise run(Promise &next){
     }).fail([](uint64_t n) {
         output_func_name();
         printf("n = %d\n", (int)n);
-    }).then(&test1)
-    .then(&test2)
+    }).then(test1)
+    .then(test2)
     .then(&test3);
     //.always([]() {
     //    output_func_name();

include/any.hpp

@@ -54,11 +54,16 @@ class any {
     }
 
     template<typename ValueType>
-    any(const ValueType & value)
+    any(const ValueType &value)
         : content(new holder<ValueType>(value)) {
     }
 
-    any(const any & other)
+    template<typename RET, typename ...ARG>
+    any(RET value(ARG...))
+        : content(new holder<RET (*)(ARG...)>(value)) {
+    }
+
+    any(const any &other)
         : content(other.content ? other.content->clone() : 0) {
     }
 

include/call_traits.hpp

@@ -47,7 +47,7 @@ namespace promise {
 template<typename T,
          bool is_basic_type = (std::is_void<T>::value
                             || std::is_fundamental<T>::value
-                            || std::is_pointer<T>::value
+                            || (std::is_pointer<T>::value && !std::is_function<typename std::remove_pointer<T>::type>::value)
                             || std::is_union<T>::value
                             || std::is_enum<T>::value
                             || std::is_array<T>::value) && !std::is_function<T>::value>
@@ -141,7 +141,7 @@ struct call_traits_impl<RET(T::*)(ARG...), false> {
 };
 
 template<typename RET, class T, typename ...ARG>
-struct call_traits_impl<RET(T:: *)(ARG...) const, false> {
+struct call_traits_impl<RET(T::*)(ARG...) const, false> {
     static const bool is_callable = true;
     typedef std::function<RET(ARG...)> fun_type;
     typedef RET result_type;
@@ -183,30 +183,6 @@ struct call_traits_impl<RET(ARG...), false> {
     }
 };
 
-template<typename RET, typename ...ARG>
-struct call_traits_impl<RET(*)(ARG...), true> {
-    static const bool is_callable = true;
-    typedef std::function<RET(ARG...)> fun_type;
-    typedef RET result_type;
-    typedef std::tuple<ARG...> argument_type;
-
-    static fun_type to_std_function(RET(*func)(ARG...)) {
-        return func;
-    }
-};
-
-template<typename RET, typename ...ARG>
-struct call_traits_impl<RET(ARG...), true> {
-    static const bool is_callable = true;
-    typedef std::function<RET(ARG...)> fun_type;
-    typedef RET result_type;
-    typedef std::tuple<ARG...> argument_type;
-
-    static fun_type to_std_function(RET(*func)(ARG...)) {
-        return func;
-    }
-};
-
 template<typename T>
 struct call_traits_impl<T, false> {
     static const bool is_callable = has_operator_parentheses<T>::type::value;