diff --git a/CMakeLists.txt b/CMakeLists.txt
index 5135bdf..8ea009b 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -37,24 +37,22 @@ callable_traits_append_flag(callable_traits_HAS_QUNUSED_ARGUMENTS          -Qunu
 callable_traits_append_flag(callable_traits_HAS_WNO_UNUSED_LOCAL_TYPEDEFS  -Wno-unused-local-typedefs)
 callable_traits_append_flag(callable_traits_HAS_WWRITE_STRINGS             -Wwrite-strings)
 
-if(${CMAKE_CXX_COMPILER_ID} STREQUAL "MSVC")
+if(MSVC AND NOT ${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang")
     #disable warning about symbol truncation. Doesn't matter, affected types are not linked
     callable_traits_append_flag(callable_traits_HAS_WD4503                     -wd4503)
     callable_traits_append_flag(callable_traits_HAS_W3                         -W3)
 else()
-
-    #if not using clang-cl
-    if(NOT MSVC)
-        callable_traits_append_flag(callable_traits_HAS_FTEMPLATE_BACKTRACE_LIMIT  -ftemplate-backtrace-limit=0)
-        callable_traits_append_flag(callable_traits_HAS_PEDANTIC                   -pedantic)
-        callable_traits_append_flag(callable_traits_HAS_STDCXX1Y                   -std=c++1y)
-    endif()
-
     callable_traits_append_flag(callable_traits_HAS_W                          -W)
     callable_traits_append_flag(callable_traits_HAS_WALL                       -Wall)
     callable_traits_append_flag(callable_traits_HAS_WEXTRA                     -Wextra)
 endif()
 
+if(NOT MSVC)
+    callable_traits_append_flag(callable_traits_HAS_FTEMPLATE_BACKTRACE_LIMIT  -ftemplate-backtrace-limit=0)
+    callable_traits_append_flag(callable_traits_HAS_PEDANTIC                   -pedantic)
+    callable_traits_append_flag(callable_traits_HAS_STDCXX1Y                   -std=c++1y)
+endif()
+
 #find_package(Boost)
 #if (Boost_FOUND)
 #    include_directories(${Boost_INCLUDE_DIRS})
diff --git a/example/bind_1.cpp b/example/bind_1.cpp
index 78a08a5..1e012db 100644
--- a/example/bind_1.cpp
+++ b/example/bind_1.cpp
@@ -23,6 +23,8 @@ because ScaryMonster is the narrowest of all _1 parameters. */
 #include <functional>
 #include <tuple>
 #include <callable_traits/bind.hpp>
+#include <callable_traits/args.hpp>
+#include <callable_traits/function_type.hpp>
 
 struct Vampire {};
 struct Robot {};
diff --git a/example/bind_2.cpp b/example/bind_2.cpp
index 93628ff..635d110 100644
--- a/example/bind_2.cpp
+++ b/example/bind_2.cpp
@@ -18,6 +18,8 @@ int main(){ return 0; };
 #include <functional>
 #include <tuple>
 #include <callable_traits/bind.hpp>
+#include <callable_traits/args.hpp>
+#include <callable_traits/function_type.hpp>
 
 struct Vampire {};
 struct Robot {};
diff --git a/include/callable_traits/config.hpp b/include/callable_traits/config.hpp
index 17f1f0c..8b2b9c5 100644
--- a/include/callable_traits/config.hpp
+++ b/include/callable_traits/config.hpp
@@ -10,22 +10,41 @@ Distributed under the Boost Software License, Version 1.0.
 #ifndef CALLABLE_TRAITS_CONFIG_HPP
 #define CALLABLE_TRAITS_CONFIG_HPP
 
+#define CALLABLE_TRAITS_IX_SEQ(...) ::std::index_sequence< __VA_ARGS__ >
+#define CALLABLE_TRAITS_MAKE_IX_SEQ(...) ::std::make_index_sequence< __VA_ARGS__ >
+#define CALLABLE_TRAITS_DISJUNCTION(...) ::std::disjunction< __VA_ARGS__ >
+#define CALLABLE_TRAITS_CONJUNCTION(...) ::std::conjunction< __VA_ARGS__ >
+
+#ifndef __cpp_lib_logical_traits
+#include <callable_traits/detail/polyfills/conjunction.hpp>
+#include <callable_traits/detail/polyfills/disjunction.hpp>
+#endif //__cpp_lib_logical_traits
+
+#ifndef __cpp_lib_integer_sequence
+#include <callable_traits/detail/polyfills/make_index_sequence.hpp>
+#endif // __cpp_lib_integer_sequence
+
 #define CALLABLE_TRAITS_EMPTY_
 #define CALLABLE_TRAITS_EMPTY CALLABLE_TRAITS_EMPTY_
-
 #define CALLABLE_TRAITS_DEFAULT_VARARGS_CC
 
+
+
 #ifdef _MSC_VER
 
-    #ifndef __clang__
+#ifndef __clang__
 
-    #undef CALLABLE_TRAITS_DEFAULT_VARARGS_CC
-    #define CALLABLE_TRAITS_DEFAULT_VARARGS_CC __cdecl
-    #define CALLABLE_TRAITS_PMF_VARGARGS_CDECL_DEFAULT
-    #define CALLABLE_TRAITS_CONSTEXPR_CHECKS_DISABLED
-    #define CALLABLE_TRAITS_MSVC
+#undef CALLABLE_TRAITS_DEFAULT_VARARGS_CC
+#define CALLABLE_TRAITS_DEFAULT_VARARGS_CC __cdecl
+#define CALLABLE_TRAITS_PMF_VARGARGS_CDECL_DEFAULT
+#define CALLABLE_TRAITS_CONSTEXPR_CHECKS_DISABLED
+#define CALLABLE_TRAITS_MSVC
 
-    #endif //ifndef __clang__
+#if _MSC_FULL_VER == 190023918
+#include <callable_traits/detail/polyfills/make_index_sequence.hpp>
+#endif //#if _MSC_FULL_VER == 190023918
+
+#endif //ifndef __clang__
 
 #endif //_MSC_VER
 
diff --git a/include/callable_traits/detail/arity.hpp b/include/callable_traits/detail/arity.hpp
index 2f95d3e..9122574 100644
--- a/include/callable_traits/detail/arity.hpp
+++ b/include/callable_traits/detail/arity.hpp
@@ -13,6 +13,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <callable_traits/detail/test_invoke.hpp>
 #include <callable_traits/detail/utility.hpp>
 #include <callable_traits/detail/any_arg.hpp>
+#include <callable_traits/config.hpp>
 #include <cstdint>
 #include <type_traits>
 
@@ -27,7 +28,7 @@ namespace callable_traits {
         };
 
         template<typename U>
-        struct max_args<U, std::index_sequence<0>> {
+        struct max_args<U, CALLABLE_TRAITS_IX_SEQ(0)> {
             static constexpr bool value = true;
             static constexpr int arg_count =
                 is_invokable<U, const any_arg<0> &>::value ? 1 : (
@@ -36,12 +37,12 @@ namespace callable_traits {
         };
 
         template<typename U, std::size_t... I>
-        struct max_args<U, std::index_sequence<I...>> {
+        struct max_args<U, CALLABLE_TRAITS_IX_SEQ(I...)> {
 
-            using result_type = disjunction<
+            using result_type = CALLABLE_TRAITS_DISJUNCTION(
                 is_invokable<U, const any_arg<I>&...>,
-                max_args<U, std::make_index_sequence<sizeof...(I)-1> >
-            >;
+                max_args<U, CALLABLE_TRAITS_MAKE_IX_SEQ(sizeof...(I)-1) >
+            );
 
             static constexpr bool value = result_type::value;
             static constexpr int arg_count = result_type::arg_count;
@@ -59,18 +60,18 @@ namespace callable_traits {
         };
 
         template<typename U, std::size_t Max, std::size_t... I>
-        struct min_args<U, Max, std::index_sequence<I...>> {
+        struct min_args<U, Max, CALLABLE_TRAITS_IX_SEQ(I...)> {
 
             using next = typename std::conditional<
                 sizeof...(I)+1 <= Max,
-                std::make_index_sequence<sizeof...(I)+1>,
+                CALLABLE_TRAITS_MAKE_IX_SEQ(sizeof...(I)+1),
                 sentinel
             >::type;
 
-            using result_type = disjunction<
+            using result_type = CALLABLE_TRAITS_DISJUNCTION(
                 is_invokable<U, const any_arg<I>&...>,
                 min_args<U, Max, next>
-            >;
+            );
 
             static constexpr bool value = result_type::value;
             static constexpr int arg_count = result_type::arg_count;
@@ -79,10 +80,10 @@ namespace callable_traits {
         template<typename U, std::size_t Max>
         struct min_args<U, Max, void> {
 
-            using result_type = disjunction<
+            using result_type = CALLABLE_TRAITS_DISJUNCTION(
                 is_invokable<U, void>,
-                min_args<U, Max, std::make_index_sequence<1>>
-            >;
+                min_args<U, Max, CALLABLE_TRAITS_MAKE_IX_SEQ(1)>
+            );
 
             static constexpr int arg_count = result_type::arg_count;
             static constexpr bool value = result_type::value;
@@ -123,7 +124,7 @@ namespace callable_traits {
             >::value;
 
             static constexpr int tentative_max_arity = max_args<
-                T, std::make_index_sequence<SearchLimit>
+                T, CALLABLE_TRAITS_MAKE_IX_SEQ(SearchLimit)
             >::arg_count;
 
             static constexpr int value =
diff --git a/include/callable_traits/detail/can_invoke_constexpr_impl.hpp b/include/callable_traits/detail/can_invoke_constexpr_impl.hpp
index e2ef5ca..cf60130 100644
--- a/include/callable_traits/detail/can_invoke_constexpr_impl.hpp
+++ b/include/callable_traits/detail/can_invoke_constexpr_impl.hpp
@@ -80,9 +80,9 @@ namespace callable_traits {
         };
 
         template<typename... Ts>
-        using are_all_constexpr_constructible = conjunction<
+        using are_all_constexpr_constructible = CALLABLE_TRAITS_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>
diff --git a/include/callable_traits/detail/is_constexpr_impl.hpp b/include/callable_traits/detail/is_constexpr_impl.hpp
index 898b653..cb503e7 100644
--- a/include/callable_traits/detail/is_constexpr_impl.hpp
+++ b/include/callable_traits/detail/is_constexpr_impl.hpp
@@ -41,7 +41,7 @@ namespace callable_traits {
         };
 
         template<typename F, std::size_t... I>
-        struct is_constexpr_t<F, std::index_sequence<I...>> {
+        struct is_constexpr_t<F, CALLABLE_TRAITS_IX_SEQ(I...)> {
 
             // An arbitrary expression as the left-hand argument to a non-overloaded
             // comma operator expression that is passed as a template value argument
@@ -75,7 +75,7 @@ namespace callable_traits {
         };
 
         template<typename Pmf, std::size_t... I>
-        struct is_constexpr_t<pmf<Pmf>, std::index_sequence<I...>> {
+        struct is_constexpr_t<pmf<Pmf>, CALLABLE_TRAITS_IX_SEQ(I...)> {
 
             // When `Pmf` is `int(foo::*)() const &&`, invoke_type is `foo const &&`
             using invoke_type = typename pmf<Pmf>::invoke_type;
@@ -93,7 +93,7 @@ namespace callable_traits {
 
         // Since constexpr data members must be static, you cannot create PMDs to them
         template<typename OriginalType, typename Pmd, std::size_t... I>
-        struct is_constexpr_t<pmd<OriginalType, Pmd>, std::index_sequence<I...>> {
+        struct is_constexpr_t<pmd<OriginalType, Pmd>, CALLABLE_TRAITS_IX_SEQ(I...)> {
             auto operator()(...) const -> substitution_failure;
         };
 
@@ -108,7 +108,7 @@ namespace callable_traits {
         is_constexpr_impl(T&& t, std::true_type){
             using traits = traits<T&&>;
             using min_args = min_arity_t<traits, constants::arity_search_limit>;
-            using seq = std::make_index_sequence<min_args::value < 0 ? 0 : min_args::value>;
+            using seq = CALLABLE_TRAITS_MAKE_IX_SEQ(min_args::value < 0 ? 0 : min_args::value);
             using test = is_constexpr_t<traits, seq>;
             using result = decltype(test{}(::std::forward<T>(t)));
             using failure = substitution_failure;
diff --git a/include/callable_traits/detail/placeholder.hpp b/include/callable_traits/detail/placeholder.hpp
index 5a32fb8..cad6b95 100644
--- a/include/callable_traits/detail/placeholder.hpp
+++ b/include/callable_traits/detail/placeholder.hpp
@@ -52,7 +52,7 @@ namespace callable_traits {
         template<typename Expression, typename, typename> struct argument_routing {};
 
         template<typename Expression, std::size_t... I, typename Tuple>
-        struct argument_routing<Expression, std::index_sequence<I...>, Tuple> {
+        struct argument_routing<Expression, CALLABLE_TRAITS_IX_SEQ(I...), Tuple> {
             using type =
                 std::tuple<
                     ph_route<
@@ -102,7 +102,7 @@ namespace callable_traits {
             using routed_placeholders = typename placeholder_routes_detail<
                 typename argument_routing<
                     Expression,
-                    std::make_index_sequence<sizeof...(Args)>,
+                    CALLABLE_TRAITS_MAKE_IX_SEQ(sizeof...(Args)),
                     std::tuple<Args...>
                 >::type
             >::type;
diff --git a/include/callable_traits/detail/polyfills/conjunction.hpp b/include/callable_traits/detail/polyfills/conjunction.hpp
new file mode 100644
index 0000000..9b6b9b5
--- /dev/null
+++ b/include/callable_traits/detail/polyfills/conjunction.hpp
@@ -0,0 +1,41 @@
+/*!
+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_POLYFILLS_CONJUNCTION_HPP
+#define CALLABLE_TRAITS_DETAIL_POLYFILLS_CONJUNCTION_HPP
+
+#undef CALLABLE_TRAITS_CONJUNCTION
+#define CALLABLE_TRAITS_CONJUNCTION(...) \
+::callable_traits::detail::polyfills::conjunction<__VA_ARGS__>
+
+#include <type_traits>
+
+namespace callable_traits {
+
+    namespace detail {
+
+		namespace polyfills {
+			
+		//polyfill for C++17 std::conjunction
+        template<typename...>
+        struct conjunction
+            : std::true_type {};
+
+        template<typename T>
+        struct conjunction<T>
+            : T {};
+
+        template<typename T, typename... Ts>
+        struct conjunction<T, Ts...>
+            : std::conditional<T::value != false, T, conjunction<Ts...>>::type {};
+			
+		}
+    }
+}
+
+#endif
diff --git a/include/callable_traits/detail/polyfills/disjunction.hpp b/include/callable_traits/detail/polyfills/disjunction.hpp
new file mode 100644
index 0000000..160bd07
--- /dev/null
+++ b/include/callable_traits/detail/polyfills/disjunction.hpp
@@ -0,0 +1,41 @@
+/*!
+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_POLYFILLS_DISJUNCTION_HPP
+#define CALLABLE_TRAITS_DETAIL_POLYFILLS_DISJUNCTION_HPP
+
+#undef CALLABLE_TRAITS_DISJUNCTION
+#define CALLABLE_TRAITS_DISJUNCTION(...) \
+::callable_traits::detail::polyfills::disjunction<__VA_ARGS__>
+
+#include <type_traits>
+
+namespace callable_traits {
+
+    namespace detail {
+
+		namespace polyfills {
+			
+			//polyfill for C++17 std::disjunction
+			template<typename...>
+			struct disjunction
+				: std::false_type {};
+
+			template<typename T>
+			struct disjunction<T>
+				: T {};
+
+			template<typename T, typename... Ts>
+			struct disjunction<T, Ts...>
+				: std::conditional<T::value != false, T, disjunction<Ts...>>::type {};
+			
+		}
+    }
+}
+
+#endif
diff --git a/include/callable_traits/detail/polyfills/make_index_sequence.hpp b/include/callable_traits/detail/polyfills/make_index_sequence.hpp
new file mode 100644
index 0000000..089d40f
--- /dev/null
+++ b/include/callable_traits/detail/polyfills/make_index_sequence.hpp
@@ -0,0 +1,61 @@
+/*!
+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_POLYFILLS_MAKE_INDEX_SEQUENCE_HPP
+#define CALLABLE_TRAITS_DETAIL_POLYFILLS_MAKE_INDEX_SEQUENCE_HPP
+
+#undef CALLABLE_TRAITS_IX_SEQ
+#define CALLABLE_TRAITS_IX_SEQ(...) ::callable_traits::detail::polyfills::index_sequence<__VA_ARGS__>
+
+#undef CALLABLE_TRAITS_MAKE_IX_SEQ
+#define CALLABLE_TRAITS_MAKE_IX_SEQ(...) ::callable_traits::detail::polyfills::make_index_sequence<__VA_ARGS__>
+
+// http://stackoverflow.com/questions/17424477/implementation-c14-make-integer-sequence
+
+namespace callable_traits { 
+
+    namespace detail { 
+
+        namespace polyfills {
+            
+            template<std::size_t...>
+            struct index_sequence {
+                using type = index_sequence;
+            };
+
+            template<typename, typename>
+            struct concat;
+
+            template<std::size_t... I1, std::size_t... I2>
+            struct concat<index_sequence<I1...>, index_sequence<I2...>>
+                : index_sequence<I1..., (sizeof...(I1)+I2)...> {};
+
+            template<std::size_t N>
+                struct make_index_sequence_t;
+
+            template<std::size_t N>
+            struct make_index_sequence_t
+                : concat< 
+					typename make_index_sequence_t<N/2>::type,
+					typename make_index_sequence_t<N - N/2>::type >::type {};
+
+            template<>
+            struct make_index_sequence_t<0>
+                : index_sequence<> {};
+
+            template<>
+            struct make_index_sequence_t<1>
+                : index_sequence<0> {};
+
+            template<std::size_t... I>
+            using make_index_sequence =
+                typename make_index_sequence_t<I...>::type;
+        }
+    }
+}
+
+#endif
diff --git a/include/callable_traits/detail/test_invoke.hpp b/include/callable_traits/detail/test_invoke.hpp
index 2e4a305..92c2aa1 100644
--- a/include/callable_traits/detail/test_invoke.hpp
+++ b/include/callable_traits/detail/test_invoke.hpp
@@ -10,6 +10,8 @@ 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/fwd/pmf_fwd.hpp>
+#include <callable_traits/detail/fwd/pmd_fwd.hpp>
 #include <callable_traits/detail/utility.hpp>
 #include <callable_traits/detail/make_constexpr.hpp>
 #include <callable_traits/config.hpp>
diff --git a/include/callable_traits/detail/traits.hpp b/include/callable_traits/detail/traits.hpp
index c5e4a47..da22596 100644
--- a/include/callable_traits/detail/traits.hpp
+++ b/include/callable_traits/detail/traits.hpp
@@ -31,14 +31,14 @@ namespace callable_traits {
         >::type;
 
         template<typename T, typename Decayed = shallow_decay<T>>
-        using traits = typename disjunction<
+        using traits = typename CALLABLE_TRAITS_DISJUNCTION(
             bind_expression_traits<Decayed>,
             function_object<T>,
             function<T, decay_if_ptr_or_integral_constant<T>>,
             pmf<T>,
             pmd<T, shallow_decay<T>>,
             function_object<Decayed>
-        >::traits;
+        )::traits;
     }
 }
 
diff --git a/include/callable_traits/detail/tuple_group_by.hpp b/include/callable_traits/detail/tuple_group_by.hpp
index aae0500..db8f117 100644
--- a/include/callable_traits/detail/tuple_group_by.hpp
+++ b/include/callable_traits/detail/tuple_group_by.hpp
@@ -84,7 +84,7 @@ namespace callable_traits {
         struct group_by_impl;
 
         template<typename Tup, typename DistinctGroupByValues, template<class> class Pred, std::size_t... I>
-        struct group_by_impl<Tup, DistinctGroupByValues, Pred, std::index_sequence<I...>> {
+        struct group_by_impl<Tup, DistinctGroupByValues, Pred, CALLABLE_TRAITS_IX_SEQ(I...)> {
 
             using type = std::tuple<
                 typename group_by_filter<
@@ -110,7 +110,7 @@ namespace callable_traits {
                 tuple_sort<Tup, sort_predicate>,
                 group_by_values,
                 Pred,
-                std::make_index_sequence<std::tuple_size<group_by_values>::value>
+                CALLABLE_TRAITS_MAKE_IX_SEQ(std::tuple_size<group_by_values>::value)
             >::type;
         };
 
diff --git a/include/callable_traits/detail/tuple_sort.hpp b/include/callable_traits/detail/tuple_sort.hpp
index 9034be5..ed2a058 100644
--- a/include/callable_traits/detail/tuple_sort.hpp
+++ b/include/callable_traits/detail/tuple_sort.hpp
@@ -11,7 +11,7 @@ Distributed under the Boost Software License, Version 1.0.
 #define CALLABLE_TRAITS_DETAIL_TUPLE_SORT_HPP
 
 
-
+#include <callable_traits/config.hpp>
 #include <tuple>
 #include <type_traits>
 
@@ -20,7 +20,7 @@ namespace callable_traits {
 
     namespace detail {
 
-        using empty_seq = std::index_sequence<>;
+        using empty_seq = CALLABLE_TRAITS_IX_SEQ(CALLABLE_TRAITS_EMPTY);
 
         template <typename Pred, std::size_t Insert, bool IsInsertionPoint,
             typename Left, std::size_t ...Right>
@@ -30,11 +30,11 @@ namespace callable_traits {
         // recursively.
         template <typename Pred, std::size_t Insert, std::size_t ...Left,
             std::size_t Right1, std::size_t Right2, std::size_t ...Right>
-        struct insert<Pred, Insert, false, std::index_sequence<Left...>,
+        struct insert<Pred, Insert, false, CALLABLE_TRAITS_IX_SEQ(Left...),
             Right1, Right2, Right...> {
             using type = typename insert<
                 Pred, Insert, Pred::template apply<Insert, Right2>::value,
-                std::index_sequence<Left..., Right1>,
+                CALLABLE_TRAITS_IX_SEQ(Left..., Right1),
                 Right2, Right...
             >::type;
         };
@@ -42,14 +42,14 @@ namespace callable_traits {
         // We did not find the insertion point, but there is only one element
         // left. We insert at the end of the list, and we're done.
         template <typename Pred, std::size_t Insert, std::size_t ...Left, std::size_t Last>
-        struct insert<Pred, Insert, false, std::index_sequence<Left...>, Last> {
-            using type = std::index_sequence<Left..., Last, Insert>;
+        struct insert<Pred, Insert, false, CALLABLE_TRAITS_IX_SEQ(Left...), Last> {
+            using type = CALLABLE_TRAITS_IX_SEQ(Left..., Last, Insert);
         };
 
         // We found the insertion point, we're done.
         template <typename Pred, std::size_t Insert, std::size_t ...Left, std::size_t ...Right>
-        struct insert<Pred, Insert, true, std::index_sequence<Left...>, Right...> {
-            using type = std::index_sequence<Left..., Insert, Right...>;
+        struct insert<Pred, Insert, true, CALLABLE_TRAITS_IX_SEQ(Left...), Right...> {
+            using type = CALLABLE_TRAITS_IX_SEQ(Left..., Insert, Right...);
         };
 
         template <typename Pred, typename Result, std::size_t ...T>
@@ -57,7 +57,7 @@ namespace callable_traits {
 
         template <typename Pred, std::size_t Result1, std::size_t ...Results,
             std::size_t T, std::size_t ...Ts>
-        struct insertion_sort<Pred, std::index_sequence<Result1, Results...>, T, Ts...> {
+        struct insertion_sort<Pred, CALLABLE_TRAITS_IX_SEQ(Result1, Results...), T, Ts...> {
             static constexpr bool pred_result = Pred::template apply<T, Result1>::value;
             using insert_result = typename insert<
                 Pred, T, pred_result, empty_seq, Result1, Results...
@@ -68,7 +68,7 @@ namespace callable_traits {
         template <typename Pred, std::size_t T, std::size_t ...Ts>
         struct insertion_sort<Pred, empty_seq, T, Ts...> {
             using type = typename insertion_sort<
-                Pred, std::index_sequence<T>, Ts...
+                Pred, CALLABLE_TRAITS_IX_SEQ(T), Ts...
             >::type;
         };
 
@@ -81,19 +81,19 @@ namespace callable_traits {
         struct sort_indices;
 
         template <typename Pred, std::size_t ...i>
-        struct sort_indices<Pred, std::index_sequence<i...>> {
+        struct sort_indices<Pred, CALLABLE_TRAITS_IX_SEQ(i...)> {
             using type = typename insertion_sort<Pred, empty_seq, i...>::type;
         };
 
         template<typename Tup, typename Pred>
         struct sort_impl {
             static constexpr std::size_t len = std::tuple_size<Tup>::value;
-            using indices = typename sort_indices<Pred, std::make_index_sequence<len>>::type;
+            using indices = typename sort_indices<Pred, CALLABLE_TRAITS_MAKE_IX_SEQ(len)>::type;
             using type = typename sort_impl<Tup, indices>::type;
         };
 
         template <typename Tup, std::size_t ...I>
-        struct sort_impl<Tup, std::index_sequence<I...>> {
+        struct sort_impl<Tup, CALLABLE_TRAITS_IX_SEQ(I...)> {
             using type = std::tuple<at<I, Tup>...>;
         };
 
diff --git a/include/callable_traits/detail/utility.hpp b/include/callable_traits/detail/utility.hpp
index 938c6b0..8cba2a8 100644
--- a/include/callable_traits/detail/utility.hpp
+++ b/include/callable_traits/detail/utility.hpp
@@ -56,43 +56,14 @@ struct invalid_type { invalid_type() = delete; };
         template<std::size_t I, typename Tup>
         using weak_at = typename util_detail::weak_at_t<I, Tup>::type;
 
-
         // 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 {};
-
-        template<typename T>
-        struct conjunction<T>
-            : T {};
-
-        template<typename T, typename... Ts>
-        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 {};
-
-        template<typename T>
-        struct disjunction<T>
-            : T {};
-
-        template<typename T, typename... Ts>
-        struct disjunction<T, Ts...>
-            : std::conditional<T::value != false, T, disjunction<Ts...>>::type { };
-
-
         //polyfill for C++17 negation
+		//TODO rename and move to polyfills folder
         template<typename BoolType>
         using negate = std::integral_constant<bool, !BoolType::value>;
 
@@ -273,10 +244,10 @@ struct invalid_type { invalid_type() = delete; };
         }
 
         template<typename T, typename FailType>
-        using fail_if_invalid = typename disjunction<
+        using fail_if_invalid = typename CALLABLE_TRAITS_DISJUNCTION(
             util_detail::type_value<T, !std::is_same<T, invalid_type>::value>,
             FailType
-        >::type;
+        )::type;
 
         template<typename T, typename Fallback>
         using fallback_if_invalid = typename std::conditional<
diff --git a/qtcreator/include/include.pro b/qtcreator/include/include.pro
index 92cd535..05c71b6 100644
--- a/qtcreator/include/include.pro
+++ b/qtcreator/include/include.pro
@@ -3,3 +3,4 @@ CONFIG -= qt
 HEADERS += ../../include/callable_traits/*.hpp
 HEADERS += ../../include/callable_traits/detail/*.hpp
 HEADERS += ../../include/callable_traits/detail/fwd/*.hpp
+HEADERS += ../../include/callable_traits/detail/polyfills/*.hpp
diff --git a/qtcreator/main/main.cpp b/qtcreator/main/main.cpp
index 7e15752..81636e8 100644
--- a/qtcreator/main/main.cpp
+++ b/qtcreator/main/main.cpp
@@ -1,19 +1,69 @@
-/*<-
-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)
-->*/
+/*!
+Copyright (c) 2016 Barrett Adair
 
-//[ push_args_back
-#include <callable_traits/push_args_back.hpp>
+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>
+
+#ifdef CALLABLE_TRAITS_MSVC
+//feature is unsupported in MSVC
+int main(){ return 0; };
+#else
+
+#ifndef CT_ASSERT
+#define CT_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+#endif //CT_ASSERT
+
+struct foo1 {
+    int operator()() const {
+        return 0;
+    }
+};
+
+struct foo2 {
+    constexpr int operator()(int) const {
+        return 1;
+    }
+    constexpr int operator()() const {
+        return 1;
+    }
+};
+
+struct foo3 {
+    constexpr int bar(int) const {
+        return 1;
+    }
+};
+
+constexpr int bar(const int&) {
+    return 1;
+}
+
+using foo4 = std::integral_constant<decltype(&bar), &bar>;
+
+using foo1_pmf = std::integral_constant<decltype(&foo1::operator()), &foo1::operator()>;
+using foo3_pmf = std::integral_constant<decltype(&foo3::bar), &foo3::bar>;
 
 namespace ct = callable_traits;
 
-int main() {
+CT_ASSERT(!ct::can_invoke_constexpr(foo1{}));
+CT_ASSERT(!ct::can_invoke_constexpr(foo1{}, 0));
 
-    using f = void(int, char);
-    using test = ct::push_args_back<f, long, void*>;
-    using expect = void(int, char, long, void*);
-    static_assert(std::is_same<test, expect>::value, "");
-}
-//]
+CT_ASSERT( ct::can_invoke_constexpr(foo2{}));
+CT_ASSERT( ct::can_invoke_constexpr(foo2{}, 0));
+
+CT_ASSERT(!ct::can_invoke_constexpr(foo4{}));
+CT_ASSERT( ct::can_invoke_constexpr(foo4{}, 0));
+
+CT_ASSERT(!ct::can_invoke_constexpr(foo1_pmf{}, foo1{}));
+CT_ASSERT(!ct::can_invoke_constexpr(foo1_pmf{}, foo1{}, 0));
+
+CT_ASSERT(!ct::can_invoke_constexpr(foo3_pmf{}, foo3{}));
+CT_ASSERT( ct::can_invoke_constexpr(foo3_pmf{}, foo3{}, 0));
+
+int main() {}
+
+#endif
diff --git a/test/bind_1.cpp b/test/bind_1.cpp
index f4f6fcc..145938b 100644
--- a/test/bind_1.cpp
+++ b/test/bind_1.cpp
@@ -70,7 +70,7 @@ auto ordered_letters(A a, B b, C c, D d, E e, F f, G g) {
 
 template <typename F, typename Tuple, std::size_t... I>
 constexpr decltype(auto)
-apply_helper(F&& f, Tuple&& t, std::index_sequence<I...>) {
+apply_helper(F&& f, Tuple&& t, CALLABLE_TRAITS_IX_SEQ(I...)) {
     return std::forward<F>(f)(std::get<I>(std::forward<Tuple>(t))...);
 }
 
@@ -80,9 +80,9 @@ apply(F&& f, Tuple&& t) {
     return apply_helper(
         std::forward<F>(f),
         std::forward<Tuple>(t),
-        std::make_index_sequence<
-        std::tuple_size<std::remove_reference_t<Tuple>>::value
-        >{}
+        CALLABLE_TRAITS_MAKE_IX_SEQ(
+            std::tuple_size<std::remove_reference_t<Tuple>>::value
+        ){}
     );
 }
 
diff --git a/test/bind_2.cpp b/test/bind_2.cpp
index 8d59f9c..35be10f 100644
--- a/test/bind_2.cpp
+++ b/test/bind_2.cpp
@@ -72,7 +72,7 @@ auto BEEF_returns_B(B, E, E, F) {
 
 template <typename F, typename Tuple, std::size_t... I>
 constexpr decltype(auto)
-apply_helper(F&& f, Tuple&& t, std::index_sequence<I...>) {
+apply_helper(F&& f, Tuple&& t, CALLABLE_TRAITS_IX_SEQ(I...)) {
     return std::forward<F>(f)(std::get<I>(std::forward<Tuple>(t))...);
 }
 
@@ -83,9 +83,9 @@ apply(F&& f, Tuple&& t) {
     return apply_helper(
         std::forward<F>(f),
         std::forward<Tuple>(t),
-        std::make_index_sequence<
-        std::tuple_size<typename std::remove_reference<Tuple>::type>::value
-        >{}
+        CALLABLE_TRAITS_MAKE_IX_SEQ(
+            std::tuple_size<std::remove_reference_t<Tuple>>::value
+        ){}
     );
 }
 
diff --git a/test/detail/flatten_bind_expressions.cpp b/test/detail/flatten_bind_expressions.cpp
index cdd05a5..7249521 100644
--- a/test/detail/flatten_bind_expressions.cpp
+++ b/test/detail/flatten_bind_expressions.cpp
@@ -15,6 +15,11 @@ Distributed under the Boost Software License, Version 1.0.
 #include <cstdint>
 #include <callable_traits/callable_traits.hpp>
 
+#ifdef CALLABLE_TRAITS_MSVC
+//feature is unsupported in MSVC
+int main(){ return 0; };
+#else
+
 #ifndef CT_ASSERT
 #define CT_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
 #endif //CT_ASSERT
@@ -71,3 +76,5 @@ int main() {
 
     return 0;
 }
+
+#endif