diff --git a/example/can_invoke/member_function_pointer.cpp b/example/can_invoke/member_function_pointer.cpp
new file mode 100644
index 0000000..a607092
--- /dev/null
+++ b/example/can_invoke/member_function_pointer.cpp
@@ -0,0 +1,32 @@
+/*!
+Copyright (c) 2016 Barrett Adair
+
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+*/
+
+#include <type_traits>
+#include <callable_traits/callable_traits.hpp>
+
+// NOTE: Due to non-compliance in MSVC, can_invoke_constexpr
+// always returns std::false_type on that compiler, which
+// causes a static assert below to fail.
+
+namespace ct = callable_traits;
+
+struct foo {
+    int bar(int) const {
+        return 1;
+    }
+};
+
+// can_invoke returns std::true_type here because the
+// arguments are valid to INVOKE
+static_assert(ct::can_invoke(&foo::bar, foo{}, 0), "");
+
+
+// can_invoke returns std::false_type here because the
+// arguments are NOT valid to INVOKE
+static_assert(!ct::can_invoke_constexpr(&foo::bar, foo{}), "");
+
+int main() { return 0; }
diff --git a/include/callable_traits/config.hpp b/include/callable_traits/config.hpp
index 8131fba..f884388 100644
--- a/include/callable_traits/config.hpp
+++ b/include/callable_traits/config.hpp
@@ -28,8 +28,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #endif //_MSC_VER
 
-#ifndef CALLABLE_TRAITS_MAX_ARITY_SEARCH
-#define CALLABLE_TRAITS_MAX_ARITY_SEARCH 10
-#endif //CALLABLE_TRAITS_MAX_ARITY_SEARCH
+#ifndef CALLABLE_TRAITS_ARITY_SEARCH_LIMIT
+#define CALLABLE_TRAITS_ARITY_SEARCH_LIMIT 10
+#endif //CALLABLE_TRAITS_ARITY_SEARCH_LIMIT
 
 #endif
diff --git a/include/callable_traits/detail/arity.hpp b/include/callable_traits/detail/arity.hpp
index 5b64d9c..a78fe03 100644
--- a/include/callable_traits/detail/arity.hpp
+++ b/include/callable_traits/detail/arity.hpp
@@ -87,10 +87,6 @@ namespace callable_traits {
             static constexpr bool value = result_type::value;
         };
 
-        struct dummy_wrapper {
-            using arg_types = std::tuple<unknown>;
-        };
-
         template<typename T>
         struct arg_tuple_size {
             static constexpr int value = -1;
diff --git a/include/callable_traits/detail/can_dereference.hpp b/include/callable_traits/detail/can_dereference.hpp
deleted file mode 100644
index c47ed0d..0000000
--- a/include/callable_traits/detail/can_dereference.hpp
+++ /dev/null
@@ -1,45 +0,0 @@
-/*!
-@file
-
-@copyright Barrett Adair 2015
-Distributed under the Boost Software License, Version 1.0.
-(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
-
-*/
-
-#ifndef CALLABLE_TRAITS_DETAIL_CAN_DEREFERENCE_HPP
-#define CALLABLE_TRAITS_DETAIL_CAN_DEREFERENCE_HPP
-
-#include <cstdint>
-#include <type_traits>
-
-namespace callable_traits {
-
-    namespace detail {
-
-        template<typename T>
-        struct can_dereference_t
-        {
-            template<typename>
-            struct check {};
-
-            template<typename U>
-            static std::int8_t test(
-                check<typename std::remove_reference<decltype(*std::declval<U>())>::type>*
-            );
-
-            template<typename>
-            static std::int16_t test(...);
-
-            static constexpr const bool value =
-                sizeof(test<T>(nullptr)) == sizeof(std::int8_t);
-        };
-
-        template<typename T>
-        using can_dereference = std::integral_constant<bool,
-            can_dereference_t<T>::value
-        >;
-    }
-}
-
-#endif
\ No newline at end of file
diff --git a/include/callable_traits/detail/can_invoke_constexpr_impl.hpp b/include/callable_traits/detail/can_invoke_constexpr_impl.hpp
index fe95304..5cb91cc 100644
--- a/include/callable_traits/detail/can_invoke_constexpr_impl.hpp
+++ b/include/callable_traits/detail/can_invoke_constexpr_impl.hpp
@@ -6,35 +6,104 @@
 #include <callable_traits/detail/utility.hpp>
 
 #include <type_traits>
+#include <cstdint>
+#include <utility>
 
 namespace callable_traits {
 
     namespace detail {
 
-        template<typename T, typename... Args,
-            typename std::enable_if<!detail::conjunction<
-                is_constexpr_constructible<T>,
-                is_constexpr_constructible<Args>...
-            >::value, int>::type = 0>
+#ifdef CALLABLE_TRAITS_CONSTEXPR_CHECKS_DISABLED
+
+        inline constexpr auto
+        can_invoke_constexpr_impl(...) {
+            return std::false_type{};
+        }
+
+#else
+
+        template<typename...>
+        struct test_invoke_constexpr {
+            auto operator()(...) const -> substitution_failure;
+        };
+
+        template<typename Pmf, typename T, typename... Args>
+        struct test_invoke_constexpr<pmf<Pmf>, T, Args...> {
+
+            using class_t = typename pmf<Pmf>::class_type;
+
+            // An arbitrary expression as the left-hand argument to a non-overloaded
+            // comma operator expression that is passed as a template value argument
+            // will trigger a substitution failure when the expression is not constexpr
+            template<typename P, typename U, typename... Rgs,
+                //generalize_if_dissimilar is used to abstract away the rules of INVOKE.
+                typename Obj = generalize_if_dissimilar<class_t, U&&>>
+            auto operator()(P&& p, U&& u, Rgs&&... rgs) const -> if_integral_constant<P,
+                std::integral_constant<int,
+
+            // Where K = std::remove_reference_t<Obj>, CALLABLE_TRAITS_MAKE_CONSTEXPR(U&&)
+            // resolves to a matching reference to a constexpr K object. Hence, K must be
+            // a literal type with a constexpr default constructor. any_arg_evaluated<I>
+            // is a "chameleon" type that tries to pass as anything. Generally, if K is
+            // templated and uses dependent names, this will fail. However, There are a few
+            // exceptions: Unary/binary operators, value member `value`, and member alias
+            // `type` are all defined in terms of any_arg_evaluated<I>, so usage of these
+            // will succeed in K.
+
+
+                    ((CALLABLE_TRAITS_MAKE_CONSTEXPR(Obj).*std::remove_reference<P>::type::value)(
+                        CALLABLE_TRAITS_MAKE_CONSTEXPR(Rgs&&)...
+                    ), 0)>>;
+
+            auto operator()(...) const -> substitution_failure;
+        };
+
+        template<typename Pmd, typename... Args>
+        struct test_invoke_constexpr<pmd<Pmd>, Args...> {
+            auto operator()(...) const -> substitution_failure;
+        };
+
+        template<typename F, typename... Args>
+        struct test_invoke_constexpr<F, Args...> {
+
+            //see comments on specialization above
+            template<typename T, typename... Rgs>
+            auto operator()(T&& t, Rgs&&...) const -> if_not_integral_constant<T,
+                std::integral_constant<int,
+                    (CALLABLE_TRAITS_MAKE_CONSTEXPR(T&&)(CALLABLE_TRAITS_MAKE_CONSTEXPR(Rgs&&)...), 0)>>;
+
+            template<typename T, typename... Rgs, typename U = typename std::remove_reference<T>::type>
+            auto operator()(T&& t, Rgs&&...) const -> if_integral_constant<T,
+                std::integral_constant<int, (U::value(CALLABLE_TRAITS_MAKE_CONSTEXPR(Rgs&&)...), 0)>>;
+
+            auto operator()(...) const -> substitution_failure;
+        };
+
+        template<typename... Ts>
+        using are_all_constexpr_constructible = conjunction<
+            is_constexpr_constructible<Ts>...
+        >;
+
+        template<typename T, typename... Args, typename std::enable_if<
+            negate<are_all_constexpr_constructible<T, Args...>>::value, int>::type = 0>
         inline constexpr auto
         can_invoke_constexpr_impl(T&&, Args&&...) {
             return std::false_type{};
         }
 
-        template<typename T, typename... Args,
-                 typename std::enable_if<detail::conjunction<
-                     is_constexpr_constructible<T>,
-                     is_constexpr_constructible<Args>...
-                 >::value, int>::type = 0>
+        template<typename T, typename... Args, typename std::enable_if<
+            are_all_constexpr_constructible<T, Args...>::value, int>::type = 0>
         inline constexpr auto
         can_invoke_constexpr_impl(T&& t, Args&&... args) {
-            using traits = detail::traits<T&&>;
-            using test = detail::test_invoke_constexpr<traits, Args&&...>;
+            using traits = traits<T&&>;
+            using test = test_invoke_constexpr<traits, Args&&...>;
             using result = decltype(test{}(::std::forward<T>(t), ::std::forward<Args>(args)...));
-            using failure = detail::substitution_failure;
+            using failure = substitution_failure;
             using is_invalid_invoke = std::is_same<result, failure>;
             return std::integral_constant<bool, !is_invalid_invoke::value>{};
         }
+
+#endif //ifndef CALLABLE_TRAITS_CONSTEXPR_CHECKS_DISABLED
     }
 }
 #endif // CALLABLE_TRAITS_DETAIL_CAN_INVOKE_CONSTEXPR_T_HPP
diff --git a/include/callable_traits/detail/generalize.hpp b/include/callable_traits/detail/generalize.hpp
deleted file mode 100644
index a78b1cd..0000000
--- a/include/callable_traits/detail/generalize.hpp
+++ /dev/null
@@ -1,49 +0,0 @@
-/*!
-@file
-
-@copyright Barrett Adair 2015
-Distributed under the Boost Software License, Version 1.0.
-(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
-
-*/
-
-#ifndef CALLABLE_TRAITS_DETAIL_GENERALIZE_HPP
-#define CALLABLE_TRAITS_DETAIL_GENERALIZE_HPP
-
-#include <callable_traits/detail/utility.hpp>
-#include <type_traits>
-#include <utility>
-
-namespace callable_traits {
-
-    namespace detail {
-
-        template<typename T, typename = std::true_type>
-        struct generalize_t {
-            using type = T;
-        };
-
-        template<typename T>
-        struct generalize_t<T, std::integral_constant<bool,
-                can_dereference<T>::value && !is_reference_wrapper<T>::value
-        >>{
-            using type = decltype(*std::declval<T>());
-        };
-
-        template<typename T>
-        struct generalize_t<T, is_reference_wrapper<T>> {
-            using type = decltype(std::declval<T>().get());
-        };
-
-        // generalize expects a pointer, a reference, or a reference_wrapper.
-        // When T is a pointer, generalize<T> is the resulting type
-        // of the pointer dereferenced. When T is an std::reference_wrapper,
-        // generalize<T> is the underlying reference type. Otherwise, generalize
-        // is T.
-
-        template<typename T>
-        using generalize = typename generalize_t<T>::type;
-    }
-}
-
-#endif
diff --git a/include/callable_traits/detail/generalized_class.hpp b/include/callable_traits/detail/generalized_class.hpp
index fca6787..1feeefe 100644
--- a/include/callable_traits/detail/generalized_class.hpp
+++ b/include/callable_traits/detail/generalized_class.hpp
@@ -10,7 +10,7 @@ Distributed under the Boost Software License, Version 1.0.
 #ifndef CALLABLE_TRAITS_DETAIL_GENERALIZED_CLASS_HPP
 #define CALLABLE_TRAITS_DETAIL_GENERALIZED_CLASS_HPP
 
-#include <callable_traits/detail/can_dereference.hpp>
+#include <callable_traits/detail/utility.hpp>
 #include <type_traits>
 #include <memory>
 
@@ -67,4 +67,4 @@ namespace callable_traits {
     }
 }
 
-#endif
\ No newline at end of file
+#endif
diff --git a/include/callable_traits/detail/is_constexpr_impl.hpp b/include/callable_traits/detail/is_constexpr_impl.hpp
index 689f609..b3b9611 100644
--- a/include/callable_traits/detail/is_constexpr_impl.hpp
+++ b/include/callable_traits/detail/is_constexpr_impl.hpp
@@ -1,5 +1,13 @@
-#ifndef CAN_INVOKE_IMPL_HPP
-#define CAN_INVOKE_IMPL_HPP
+/*!
+Copyright (c) 2016 Barrett Adair
+
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+*/
+
+
+#ifndef CALLABLE_TRAITS_IS_CONSTEXPR_IMPL_HPP
+#define CALLABLE_TRAITS_IS_CONSTEXPR_IMPL_HPP
 
 #include <callable_traits/detail/traits.hpp>
 #include <callable_traits/detail/arity.hpp>
@@ -18,7 +26,14 @@ namespace callable_traits {
 
     namespace detail {
 
-#ifndef CALLABLE_TRAITS_CONSTEXPR_CHECKS_DISABLED
+#ifdef CALLABLE_TRAITS_CONSTEXPR_CHECKS_DISABLED
+
+        inline constexpr auto
+        is_constexpr_impl(...) {
+            return std::false_type{};
+        }
+
+#else
 
         template<typename F, typename Seq>
         struct is_constexpr_t {
@@ -28,10 +43,29 @@ namespace callable_traits {
         template<typename F, std::size_t... I>
         struct is_constexpr_t<F, std::index_sequence<I...>> {
 
+            // An arbitrary expression as the left-hand argument to a non-overloaded
+            // comma operator expression that is passed as a template value argument
+            // will trigger a substitution failure when the expression is not constexpr
             template<typename T>
             auto operator()(T&& t) const -> if_not_integral_constant<T,
                 std::integral_constant<int,
-                    (CALLABLE_TRAITS_MAKE_CONSTEXPR(T&&)(::callable_traits::detail::any_arg_evaluated<I>{}...), 0)>>;
+
+            // Where U = std::remove_reference_t<T>, CALLABLE_TRAITS_MAKE_CONSTEXPR(T&&)
+            // resolves to a matching reference to a constexpr U object. Hence, U must be
+            // a literal type with a constexpr default constructor. any_arg_evaluated<I>
+            // is a "chameleon" type that tries to pass as anything. Generally, if U is
+            // templated and uses dependent names, this will fail. However, There are a few
+            // exceptions: Unary/binary operators, value member `value`, and member alias
+            // `type` are all defined in terms of any_arg_evaluated<I>, so usage of these
+            // will succeed in U.
+
+                    (
+                        CALLABLE_TRAITS_MAKE_CONSTEXPR(T&&)(
+                            ::callable_traits::detail::any_arg_evaluated<I>{}...
+                        ),
+                        0
+                    )
+                >>;
 
             template<typename T, typename U = typename std::remove_reference<T>::type>
             auto operator()(T&& t) const -> if_integral_constant<T,
@@ -43,18 +77,21 @@ namespace callable_traits {
         template<typename Pmf, std::size_t... I>
         struct is_constexpr_t<pmf<Pmf>, std::index_sequence<I...>> {
 
-            using class_t = typename pmf<Pmf>::invoke_type;
+            // When `Pmf` is `int(foo::*)() const &&`, invoke_type is `foo const &&`
+            using invoke_type = typename pmf<Pmf>::invoke_type;
 
+            //see comments on specialization above
             template<typename P>
             auto operator()(P&&) const -> if_integral_constant<P,
                 std::integral_constant<int,
-                    ((CALLABLE_TRAITS_MAKE_CONSTEXPR(class_t).* ::std::remove_reference<P>::type::value)(
+                    ((CALLABLE_TRAITS_MAKE_CONSTEXPR(invoke_type).* ::std::remove_reference<P>::type::value)(
                         ::callable_traits::detail::any_arg_evaluated<I>{}...
                     ), 0)>>;
 
             auto operator()(...) const -> substitution_failure;
         };
 
+        // Since constexpr data members must be static, you cannot create PMDs to them
         template<typename Pmd, std::size_t... I>
         struct is_constexpr_t<pmd<Pmd>, std::index_sequence<I...>> {
             auto operator()(...) const -> substitution_failure;
@@ -79,15 +116,10 @@ namespace callable_traits {
             return std::integral_constant<bool, !is_not_constexpr::value>{};
         }
 
-#else
-        inline constexpr auto
-        is_constexpr_impl(...) {
-            return std::false_type{};
-        }
+#endif //ifdef CALLABLE_TRAITS_CONSTEXPR_CHECKS_DISABLED
 
-#endif //ifndef CALLABLE_TRAITS_CONSTEXPR_CHECKS_DISABLED
     }
 }
 
-#endif // CAN_INVOKE_IMPL_HPP
+#endif // CALLABLE_TRAITS_IS_CONSTEXPR_IMPL_HPP
 
diff --git a/include/callable_traits/detail/private_tuple.hpp b/include/callable_traits/detail/private_tuple.hpp
new file mode 100644
index 0000000..c0ec30a
--- /dev/null
+++ b/include/callable_traits/detail/private_tuple.hpp
@@ -0,0 +1,23 @@
+/*!
+@copyright Barrett Adair 2016
+
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+*/
+
+#ifndef CALLABLE_TRAITS_DETAIL_PRIVATE_TUPLE_HPP
+#define CALLABLE_TRAITS_DETAIL_PRIVATE_TUPLE_HPP
+
+namespace callable_traits { 
+
+    namespace detail { 
+
+        template<typename... Ts>
+        struct private_tuple {
+            using to_std_tuple = std::tuple<Ts...>;
+        };
+
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/include/callable_traits/detail/test_invoke.hpp b/include/callable_traits/detail/test_invoke.hpp
index d6d7b80..319735b 100644
--- a/include/callable_traits/detail/test_invoke.hpp
+++ b/include/callable_traits/detail/test_invoke.hpp
@@ -10,8 +10,6 @@ Distributed under the Boost Software License, Version 1.0.
 #ifndef CALLABLE_TRAITS_DETAIL_TEST_INVOKE_HPP
 #define CALLABLE_TRAITS_DETAIL_TEST_INVOKE_HPP
 
-#include <callable_traits/detail/generalize.hpp>
-#include <callable_traits/detail/utility.hpp>
 #include <callable_traits/detail/utility.hpp>
 #include <callable_traits/detail/make_constexpr.hpp>
 #include <callable_traits/config.hpp>
@@ -26,13 +24,6 @@ namespace callable_traits {
         template<typename T>
         struct success {};
 
-        template<typename Base, typename T,
-                 typename IsBaseOf = std::is_base_of<Base, shallow_decay<T>>,
-                 typename IsSame = std::is_same<Base, shallow_decay<T>>>
-        using generalize_if_dissimilar = typename std::conditional<
-            IsBaseOf::value || IsSame::value, T, generalize<T>
-        >::type;
-
         template<typename...>
         struct test_invoke;
 
@@ -144,51 +135,6 @@ namespace callable_traits {
         template<typename Traits, typename... Args>
         using is_invokable = build_invoke_t<
             typename Traits::is_member_pointer, Traits, Args...>;
-
-        template<typename...>
-        struct test_invoke_constexpr {
-            auto operator()(...) const->substitution_failure;
-        };
-
-#ifndef CALLABLE_TRAITS_CONSTEXPR_CHECKS_DISABLED
-
-        template<typename Pmf, typename T, typename... Args>
-        struct test_invoke_constexpr<pmf<Pmf>, T, Args...> {
-
-            using class_t = typename pmf<Pmf>::class_type;
-
-            template<typename P, typename U, typename... Rgs,
-                typename Obj = generalize_if_dissimilar<class_t, U&&>>
-            auto operator()(P&& p, U&& u, Rgs&&... rgs) const -> if_integral_constant<P,
-                std::integral_constant<int,
-                    ((CALLABLE_TRAITS_MAKE_CONSTEXPR(Obj).*std::remove_reference<P>::type::value)(
-                        CALLABLE_TRAITS_MAKE_CONSTEXPR(Rgs&&)...
-                    ), 0)>>;
-
-            auto operator()(...) const -> substitution_failure;
-        };
-
-        template<typename Pmd, typename... Args>
-        struct test_invoke_constexpr<pmd<Pmd>, Args...> {
-            auto operator()(...) const -> substitution_failure;
-        };
-
-        template<typename F, typename... Args>
-        struct test_invoke_constexpr<F, Args...> {
-
-            template<typename T, typename... Rgs>
-            auto operator()(T&& t, Rgs&&...) const -> if_not_integral_constant<T,
-                std::integral_constant<int,
-                    (CALLABLE_TRAITS_MAKE_CONSTEXPR(T&&)(CALLABLE_TRAITS_MAKE_CONSTEXPR(Rgs&&)...), 0)>>;
-
-            template<typename T, typename... Rgs, typename U = typename std::remove_reference<T>::type>
-            auto operator()(T&& t, Rgs&&...) const -> if_integral_constant<T,
-                std::integral_constant<int, (U::value(CALLABLE_TRAITS_MAKE_CONSTEXPR(Rgs&&)...), 0)>>;
-
-            auto operator()(...) const -> substitution_failure;
-        };
-
-#endif //ifndef CALLABLE_TRAITS_CONSTEXPR_CHECKS_DISABLED
     }
 }
 
diff --git a/include/callable_traits/detail/utility.hpp b/include/callable_traits/detail/utility.hpp
index 472546a..f509d52 100644
--- a/include/callable_traits/detail/utility.hpp
+++ b/include/callable_traits/detail/utility.hpp
@@ -14,11 +14,12 @@ Distributed under the Boost Software License, Version 1.0.
 #include <type_traits>
 #include <tuple>
 #include <utility>
+#include <cstdint>
 
 namespace callable_traits {
 
 struct constants {
-    static constexpr std::size_t arity_search_limit = CALLABLE_TRAITS_MAX_ARITY_SEARCH;
+    static constexpr std::size_t arity_search_limit = CALLABLE_TRAITS_ARITY_SEARCH_LIMIT;
 };
 
 struct invalid_type { invalid_type() = delete; };
@@ -28,37 +29,45 @@ struct unknown { unknown() = delete; };
 
     namespace detail {
 
+        // used to convey "this type doesn't matter" in code
         struct dummy {};
 
+
+        // used as return type in failed SFINAE tests
         struct substitution_failure{};
 
+
+        // shorthand for std::tuple_element
         template<std::size_t I, typename Tup>
         using at = typename std::tuple_element<I, Tup>::type;
 
-        template<std::size_t I, typename Tup, typename = std::true_type>
-        struct weak_at_t {
-            using type = at<I, Tup>;
-        };
 
+        namespace util_detail {
+
+            template<std::size_t I, typename Tup, typename = std::true_type>
+            struct weak_at_t {
+                using type = at<I, Tup>;
+            };
+
+            template<std::size_t I, typename Tup>
+            struct weak_at_t<I, Tup, std::integral_constant<bool, I >= std::tuple_size<Tup>::value>>{
+                using type = invalid_type;
+            };
+        }
+
+        // bounds-checked version of at (see above)
         template<std::size_t I, typename Tup>
-        struct weak_at_t<I, Tup, std::integral_constant<bool, I >= std::tuple_size<Tup>::value>>{
-            using type = invalid_type;
-        };
+        using weak_at = typename util_detail::weak_at_t<I, Tup>::type;
 
-        template<std::size_t I, typename Tup>
-        using weak_at = typename weak_at_t<I, Tup>::type;
-
-        template<bool Value, typename T>
-        struct value_type_pair {
-            using type = T;
-            static constexpr const bool value = Value;
-        };
 
+        // a faster version of std::decay_t
         template<typename T>
         using shallow_decay = typename std::remove_cv<
             typename std::remove_reference<T>::type
         >::type;
 
+
+        //polyfill for C++17 std::conjunction
         template<typename...>
         struct conjunction
             : std::true_type {};
@@ -71,6 +80,8 @@ struct unknown { unknown() = delete; };
         struct conjunction<T, Ts...>
             : std::conditional<T::value != false, T, conjunction<Ts...>>::type { };
 
+
+        //polyfill for C++17 std::disjunction
         template<typename...>
         struct disjunction
             : std::false_type {};
@@ -83,21 +94,29 @@ struct unknown { unknown() = delete; };
         struct disjunction<T, Ts...>
             : std::conditional<T::value != false, T, disjunction<Ts...>>::type { };
 
+
+        //polyfill for C++17 negation
         template<typename BoolType>
         using negate = std::integral_constant<bool, !BoolType::value>;
 
-        template<typename T>
-        struct is_reference_wrapper_t {
-            using type = std::false_type;
-        };
+
+        namespace util_detail {
+
+            template<typename T>
+            struct is_reference_wrapper_t {
+                using type = std::false_type;
+            };
+
+            template<typename T>
+            struct is_reference_wrapper_t<std::reference_wrapper<T>> {
+                using type = std::true_type;
+            };
+        }
 
         template<typename T>
-        struct is_reference_wrapper_t<std::reference_wrapper<T>> {
-            using type = std::true_type;
-        };
+        using is_reference_wrapper =
+            typename util_detail::is_reference_wrapper_t<shallow_decay<T>>::type;
 
-        template<typename T>
-        using is_reference_wrapper = typename is_reference_wrapper_t<shallow_decay<T>>::type;
 
         template<typename T, typename = std::true_type>
         struct unwrap_reference_t {
@@ -109,22 +128,28 @@ struct unknown { unknown() = delete; };
             using type = decltype(std::declval<T>().get());
         };
 
+        // removes std::reference_wrapper
         template<typename T>
         using unwrap_reference = typename unwrap_reference_t<T>::type;
 
-        template<typename T>
-        struct is_integral_constant_t {
-            static constexpr bool value = false;
-        };
 
-        template<typename T, T Value>
-        struct is_integral_constant_t<std::integral_constant<T, Value>> {
-            static constexpr bool value = true;
-        };
+        namespace util_detail {
+
+            template<typename T>
+            struct is_integral_constant_t {
+                using type = std::false_type;
+            };
+
+            template<typename T, T Value>
+            struct is_integral_constant_t<std::integral_constant<T, Value>> {
+                using type = std::true_type;
+            };
+        }
 
         template<typename T>
-        using is_integral_constant = std::integral_constant<bool,
-            is_integral_constant_t<shallow_decay<T>>::value>;
+        using is_integral_constant = typename util_detail::is_integral_constant_t<
+            shallow_decay<T>>::type;
+
 
         template<typename Check, typename Result>
         using if_integral_constant =
@@ -134,39 +159,116 @@ struct unknown { unknown() = delete; };
         using if_not_integral_constant =
             typename std::enable_if<!is_integral_constant<Check>::value, Result>::type;
 
+
         template<typename T, typename Class>
         using add_member_pointer = T Class::*;
 
-        template<typename T>
-        struct remove_member_pointer_t {
-            using type = T;
-        };
 
-        template<typename T, typename U>
-        struct remove_member_pointer_t<T U::*>{
-            using type = T;
-        };
+        namespace util_detail {
+
+            template<typename T>
+            struct remove_member_pointer_t {
+                using type = T;
+            };
+
+            template<typename T, typename U>
+            struct remove_member_pointer_t<T U::*>{
+                using type = T;
+            };
+        }
 
         template<typename T>
         using remove_member_pointer =
-            typename remove_member_pointer_t<T>::type;
+            typename util_detail::remove_member_pointer_t<T>::type;
+
 
         template<typename T, typename U = shallow_decay<T>>
         using is_constexpr_constructible = std::integral_constant<bool,
             std::is_literal_type<U>::value && std::is_default_constructible<U>::value
         >;
 
-        template<typename...>
-        struct build_function_t;
 
-        template<typename Return, typename... Args>
-        struct build_function_t<Return, std::tuple<Args...>>{
-            using type = Return(Args...);
-        };
+        namespace util_detail {
+
+            template<typename...>
+            struct build_function_t;
+
+            template<typename Return, typename... Args>
+            struct build_function_t<Return, std::tuple<Args...>>{
+                using type = Return(Args...);
+            };
+        }
 
         template<typename Ret, typename Tup>
-        using build_function = typename build_function_t<Ret, Tup>::type;
+        using build_function =
+            typename util_detail::build_function_t<Ret, Tup>::type;
 
+
+        namespace util_detail {
+
+            template<typename T>
+            struct can_dereference_t
+            {
+                template<typename>
+                struct check {};
+
+                template<typename U>
+                static std::int8_t test(
+                    check<typename std::remove_reference<decltype(*std::declval<U>())>::type>*
+                );
+
+                template<typename>
+                static std::int16_t test(...);
+
+                static constexpr const bool value =
+                    sizeof(test<T>(nullptr)) == sizeof(std::int8_t);
+            };
+        }
+
+        //returns std::true_type for pointers and smart pointers
+        template<typename T>
+        using can_dereference = std::integral_constant<bool,
+            util_detail::can_dereference_t<T>::value
+        >;
+
+
+        namespace util_detail {
+
+            template<typename T, typename = std::true_type>
+            struct generalize_t {
+                using type = T;
+            };
+
+            template<typename T>
+            struct generalize_t<T, std::integral_constant<bool,
+                    can_dereference<T>::value && !is_reference_wrapper<T>::value
+            >>{
+                using type = decltype(*std::declval<T>());
+            };
+
+            template<typename T>
+            struct generalize_t<T, is_reference_wrapper<T>> {
+                using type = decltype(std::declval<T>().get());
+            };
+        }
+
+        // When T is a pointer, generalize<T> is the resulting type of the
+        // pointer dereferenced. When T is an std::reference_wrapper, generalize<T>
+        // is the underlying reference type. Otherwise, generalize<T> is T.
+        template<typename T>
+        using generalize = typename util_detail::generalize_t<T>::type;
+
+
+        // handles the member pointer rules of INVOKE
+        template<typename Base, typename T,
+                 typename IsBaseOf = std::is_base_of<Base, shallow_decay<T>>,
+                 typename IsSame = std::is_same<Base, shallow_decay<T>>>
+        using generalize_if_dissimilar = typename std::conditional<
+            IsBaseOf::value || IsSame::value, T, generalize<T>
+        >::type;
+
+
+        //used to prepend a type to a tuple
         template <typename...> struct prepend;
 
         template <> struct prepend<> {
diff --git a/qtcreator/main/main.cpp b/qtcreator/main/main.cpp
index d8cdef0..a607092 100644
--- a/qtcreator/main/main.cpp
+++ b/qtcreator/main/main.cpp
@@ -1,4 +1,3 @@
-
 /*!
 Copyright (c) 2016 Barrett Adair
 
@@ -9,28 +8,25 @@ Distributed under the Boost Software License, Version 1.0.
 #include <type_traits>
 #include <callable_traits/callable_traits.hpp>
 
-// NOTE: Due to non-compliance in MSVC, is_constexpr always
-// returns std::false_type on that compiler, which causes
-// the static asserts below to fail.
+// NOTE: Due to non-compliance in MSVC, can_invoke_constexpr
+// always returns std::false_type on that compiler, which
+// causes a static assert below to fail.
 
 namespace ct = callable_traits;
 
-constexpr int foo(const int&) {
-    return 1;
-}
+struct foo {
+    int bar(int) const {
+        return 1;
+    }
+};
 
-int bar(const int&) {
-    return 1;
-}
+// can_invoke returns std::true_type here because the
+// arguments are valid to INVOKE
+static_assert(ct::can_invoke(&foo::bar, foo{}, 0), "");
 
-// for is_constexpr calls, function pointers must
-// be passed as std::integral_constants
-using F = std::integral_constant<decltype(&foo), &foo>;
-using B = std::integral_constant<decltype(&bar), &bar>;
 
-static_assert(ct::is_constexpr(F{}), "");
-static_assert(ct::is_constexpr<F>(), "");
-static_assert(!ct::is_constexpr(B{}), "");
-static_assert(!ct::is_constexpr<B>(), "");
+// can_invoke returns std::false_type here because the
+// arguments are NOT valid to INVOKE
+static_assert(!ct::can_invoke_constexpr(&foo::bar, foo{}), "");
 
 int main() { return 0; }