diff --git a/src/bsoncxx/include/CMakeLists.txt b/src/bsoncxx/include/CMakeLists.txt
index ae5b3c7186..1f7ea4b7e3 100644
--- a/src/bsoncxx/include/CMakeLists.txt
+++ b/src/bsoncxx/include/CMakeLists.txt
@@ -59,6 +59,7 @@ set_dist_list(src_bsoncxx_include_DIST
     bsoncxx/v_noabi/bsoncxx/stdx/make_unique.hpp
     bsoncxx/v_noabi/bsoncxx/stdx/optional.hpp
     bsoncxx/v_noabi/bsoncxx/stdx/string_view.hpp
+    bsoncxx/v_noabi/bsoncxx/stdx/type_traits.hpp
     bsoncxx/v_noabi/bsoncxx/string/to_string.hpp
     bsoncxx/v_noabi/bsoncxx/string/view_or_value.hpp
     bsoncxx/v_noabi/bsoncxx/types.hpp
diff --git a/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/builder/basic/impl.hpp b/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/builder/basic/impl.hpp
index bde3a54803..5f65301f61 100644
--- a/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/builder/basic/impl.hpp
+++ b/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/builder/basic/impl.hpp
@@ -16,7 +16,7 @@
 
 #include <bsoncxx/builder/basic/sub_array.hpp>
 #include <bsoncxx/builder/basic/sub_document.hpp>
-#include <bsoncxx/util/functor.hpp>
+#include <bsoncxx/stdx/type_traits.hpp>
 
 #include <bsoncxx/config/prelude.hpp>
 
@@ -27,31 +27,26 @@ namespace basic {
 namespace impl {
 
 template <typename T>
-using takes_document = typename util::is_functor<T, void(sub_document)>;
-
-template <typename T>
-using takes_array = typename util::is_functor<T, void(sub_array)>;
-
-template <typename T>
-BSONCXX_INLINE typename std::enable_if<takes_document<T>::value, void>::type generic_append(
-    core* core, T&& func) {
+BSONCXX_INLINE detail::requires_t<void, detail::is_invocable<T, sub_document>>  //
+generic_append(core* core, T&& func) {
     core->open_document();
-    func(sub_document(core));
+    detail::invoke(std::forward<T>(func), sub_document(core));
     core->close_document();
 }
 
-template <typename T>
-BSONCXX_INLINE typename std::enable_if<takes_array<T>::value, void>::type generic_append(core* core,
-                                                                                         T&& func) {
+template <typename T, typename Placeholder = void>  // placeholder 'void' for VS2015 compat
+BSONCXX_INLINE detail::requires_t<void, detail::is_invocable<T, sub_array>>  //
+generic_append(core* core, T&& func) {
     core->open_array();
-    func(sub_array(core));
+    detail::invoke(std::forward<T>(func), sub_array(core));
     core->close_array();
 }
 
-template <typename T>
-BSONCXX_INLINE
-    typename std::enable_if<!takes_document<T>::value && !takes_array<T>::value, void>::type
-    generic_append(core* core, T&& t) {
+template <typename T, typename = void, typename = void>
+BSONCXX_INLINE detail::requires_not_t<void,  //
+                                      detail::is_invocable<T, sub_document>,
+                                      detail::is_invocable<T, sub_array>>
+generic_append(core* core, T&& t) {
     core->append(std::forward<T>(t));
 }
 
diff --git a/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/builder/basic/sub_document.hpp b/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/builder/basic/sub_document.hpp
index ee0e328db5..dda94fd340 100644
--- a/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/builder/basic/sub_document.hpp
+++ b/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/builder/basic/sub_document.hpp
@@ -18,6 +18,7 @@
 #include <bsoncxx/builder/concatenate.hpp>
 #include <bsoncxx/builder/core.hpp>
 #include <bsoncxx/stdx/string_view.hpp>
+#include <bsoncxx/stdx/type_traits.hpp>
 
 #include <bsoncxx/config/prelude.hpp>
 
@@ -59,8 +60,7 @@ class sub_document {
     // Appends a basic::kvp where the key is a non-owning string view.
     //
     template <typename K, typename V>
-    BSONCXX_INLINE typename std::enable_if<
-        std::is_same<typename std::decay<K>::type, stdx::string_view>::value>::type
+    BSONCXX_INLINE detail::requires_t<void, detail::is_alike<K, stdx::string_view>>  //
     append_(std::tuple<K, V>&& t) {
         _core->key_view(std::forward<K>(std::get<0>(t)));
         impl::value_append(_core, std::forward<V>(std::get<1>(t)));
@@ -70,8 +70,7 @@ class sub_document {
     // Appends a basic::kvp where the key is an owning STL string.
     //
     template <typename K, typename V>
-    BSONCXX_INLINE typename std::enable_if<
-        std::is_same<typename std::decay<K>::type, std::string>::value>::type
+    BSONCXX_INLINE detail::requires_t<void, detail::is_alike<K, std::string>>  //
     append_(std::tuple<K, V>&& t) {
         _core->key_owned(std::forward<K>(std::get<0>(t)));
         impl::value_append(_core, std::forward<V>(std::get<1>(t)));
diff --git a/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/builder/core.hpp b/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/builder/core.hpp
index 4b845e2a29..dcd504366b 100644
--- a/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/builder/core.hpp
+++ b/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/builder/core.hpp
@@ -18,6 +18,7 @@
 #include <stdexcept>
 #include <type_traits>
 
+#include "bsoncxx/stdx/type_traits.hpp"
 #include <bsoncxx/array/value.hpp>
 #include <bsoncxx/array/view.hpp>
 #include <bsoncxx/document/value.hpp>
@@ -508,7 +509,7 @@ class BSONCXX_API core {
     ///
     template <typename T>
     BSONCXX_INLINE core& append(T* v) {
-        static_assert(std::is_same<typename std::remove_const<T>::type, char>::value,
+        static_assert(detail::is_alike<T, char>::value,
                       "append is disabled for non-char pointer types");
         append(types::b_string{v});
 
diff --git a/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/builder/stream/array_context.hpp b/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/builder/stream/array_context.hpp
index 70ec1b47d8..24e6c640b1 100644
--- a/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/builder/stream/array_context.hpp
+++ b/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/builder/stream/array_context.hpp
@@ -19,7 +19,7 @@
 #include <bsoncxx/builder/core.hpp>
 #include <bsoncxx/builder/stream/closed_context.hpp>
 #include <bsoncxx/builder/stream/helpers.hpp>
-#include <bsoncxx/util/functor.hpp>
+#include <bsoncxx/stdx/type_traits.hpp>
 
 #include <bsoncxx/config/prelude.hpp>
 
@@ -67,11 +67,10 @@ class array_context {
     ///   The value to append
     ///
     template <class T>
-    BSONCXX_INLINE typename std::enable_if<
-        !(util::is_functor<T, void(array_context<>)>::value ||
-          util::is_functor<T, void(single_context)>::value ||
-          std::is_same<typename std::remove_reference<T>::type, const finalize_type>::value),
-        array_context>::type&
+    BSONCXX_INLINE detail::requires_not_t<array_context&,
+                                          detail::is_invocable<T, array_context<>>,
+                                          detail::is_invocable<T, single_context>,
+                                          detail::is_alike<T, finalize_type>>
     operator<<(T&& t) {
         _core->append(std::forward<T>(t));
         return *this;
@@ -86,11 +85,12 @@ class array_context {
     ///   The callback to invoke
     ///
     template <typename Func>
-    BSONCXX_INLINE typename std::enable_if<(util::is_functor<Func, void(array_context<>)>::value ||
-                                            util::is_functor<Func, void(single_context)>::value),
-                                           array_context>::type&
-    operator<<(Func&& func) {
-        func(*this);
+    BSONCXX_INLINE
+        detail::requires_t<array_context&,
+                           detail::disjunction<detail::is_invocable<Func, array_context>,
+                                               detail::is_invocable<Func, single_context>>>
+        operator<<(Func&& func) {
+        detail::invoke(std::forward<Func>(func), *this);
         return *this;
     }
 
@@ -105,12 +105,10 @@ class array_context {
     /// @return A value type which holds the complete bson document.
     ///
     template <typename T>
-    BSONCXX_INLINE typename std::enable_if<
-        std::is_same<base, closed_context>::value &&
-            std::is_same<typename std::remove_reference<T>::type, const finalize_type>::value,
-        // TODO(MSVC): This should just be 'array::value', but
-        // VS2015U1 can't resolve the name.
-        bsoncxx::array::value>::type
+    BSONCXX_INLINE detail::requires_t<bsoncxx::array::value,
+                                      std::is_same<base, closed_context>,
+                                      detail::is_alike<T, finalize_type>>
+    // VS2015U1 can't resolve the name.
     operator<<(T&&) {
         return _core->extract_array();
     }
diff --git a/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/builder/stream/key_context.hpp b/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/builder/stream/key_context.hpp
index 115f7a388d..5302aae767 100644
--- a/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/builder/stream/key_context.hpp
+++ b/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/builder/stream/key_context.hpp
@@ -19,7 +19,7 @@
 #include <bsoncxx/builder/stream/closed_context.hpp>
 #include <bsoncxx/builder/stream/value_context.hpp>
 #include <bsoncxx/stdx/string_view.hpp>
-#include <bsoncxx/util/functor.hpp>
+#include <bsoncxx/stdx/type_traits.hpp>
 
 #include <bsoncxx/config/prelude.hpp>
 
@@ -108,10 +108,9 @@ class key_context {
     ///   The callback to invoke
     ///
     template <typename T>
-    BSONCXX_INLINE
-        typename std::enable_if<util::is_functor<T, void(key_context<>)>::value, key_context>::type&
-        operator<<(T&& func) {
-        func(*this);
+    BSONCXX_INLINE detail::requires_t<key_context&, detail::is_invocable<T, key_context>>  //
+    operator<<(T&& func) {
+        detail::invoke(std::forward<T>(func), *this);
         return *this;
     }
 
@@ -126,12 +125,9 @@ class key_context {
     /// @return A value type which holds the complete bson document.
     ///
     template <typename T>
-    BSONCXX_INLINE typename std::enable_if<
-        std::is_same<base, closed_context>::value &&
-            std::is_same<typename std::remove_reference<T>::type, const finalize_type>::value,
-        // TODO(MSVC): This should just be 'document::value', but
-        // VS2015U1 can't resolve the name.
-        bsoncxx::document::value>::type
+    BSONCXX_INLINE detail::requires_t<bsoncxx::document::value,
+                                      std::is_same<base, closed_context>,
+                                      detail::is_alike<T, finalize_type>>
     operator<<(T&&) {
         return _core->extract_document();
     }
diff --git a/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/builder/stream/value_context.hpp b/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/builder/stream/value_context.hpp
index fb1d56d0c2..c0312e6e38 100644
--- a/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/builder/stream/value_context.hpp
+++ b/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/builder/stream/value_context.hpp
@@ -18,7 +18,7 @@
 #include <bsoncxx/builder/stream/array_context.hpp>
 #include <bsoncxx/builder/stream/closed_context.hpp>
 #include <bsoncxx/builder/stream/helpers.hpp>
-#include <bsoncxx/util/functor.hpp>
+#include <bsoncxx/stdx/type_traits.hpp>
 
 #include <bsoncxx/config/prelude.hpp>
 
@@ -63,9 +63,8 @@ class value_context {
     ///   The value to append
     ///
     template <class T>
-    BSONCXX_INLINE
-        typename std::enable_if<!util::is_functor<T, void(single_context)>::value, base>::type
-        operator<<(T&& t) {
+    BSONCXX_INLINE detail::requires_not_t<base, detail::is_invocable<T, single_context>>  //
+    operator<<(T&& t) {
         _core->append(std::forward<T>(t));
         return unwrap();
     }
@@ -78,10 +77,9 @@ class value_context {
     ///   The callback to invoke
     ///
     template <typename T>
-    BSONCXX_INLINE
-        typename std::enable_if<util::is_functor<T, void(single_context)>::value, base>::type
-        operator<<(T&& func) {
-        func(*this);
+    BSONCXX_INLINE detail::requires_t<base, detail::is_invocable<T, single_context>>  //
+    operator<<(T&& func) {
+        detail::invoke(std::forward<T>(func), *this);
         return unwrap();
     }
 
diff --git a/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/document/value.hpp b/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/document/value.hpp
index 97e31c50ca..5202f84823 100644
--- a/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/document/value.hpp
+++ b/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/document/value.hpp
@@ -16,7 +16,9 @@
 
 #include <cstdlib>
 #include <memory>
+#include <type_traits>
 
+#include "bsoncxx/stdx/type_traits.hpp"
 #include <bsoncxx/array/view.hpp>
 #include <bsoncxx/document/view.hpp>
 
@@ -84,8 +86,7 @@ class BSONCXX_API value {
     /// @param t
     ///   A user-defined object to serialize into a BSON object.
     ///
-    template <typename T,
-              typename std::enable_if<!std::is_same<T, typename array::view>::value, int>::type = 0>
+    template <typename T, detail::requires_not_t<int, std::is_same<T, array::view>> = 0>
     explicit value(const T& t) : value({}) {
         to_bson(t, *this);
     }
diff --git a/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/stdx/make_unique.hpp b/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/stdx/make_unique.hpp
index abcedc3a4f..3ff81f7ce5 100644
--- a/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/stdx/make_unique.hpp
+++ b/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/stdx/make_unique.hpp
@@ -19,6 +19,8 @@
 #include <type_traits>
 #include <utility>
 
+#include "./type_traits.hpp"
+
 #include <bsoncxx/config/prelude.hpp>
 
 namespace bsoncxx {
diff --git a/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/stdx/type_traits.hpp b/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/stdx/type_traits.hpp
new file mode 100644
index 0000000000..b3a9a376c6
--- /dev/null
+++ b/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/stdx/type_traits.hpp
@@ -0,0 +1,429 @@
+#pragma once
+
+#include <type_traits>
+
+#include <bsoncxx/config/prelude.hpp>
+
+namespace bsoncxx {
+inline namespace v_noabi {
+namespace detail {
+
+#define bsoncxx_ttparam \
+    template <class...> \
+    class
+
+/// Obtain the nested ::type of the given type argument
+template <typename T>
+using type_t = typename T::type;
+
+/// Obtain the value_type member type of the given argument
+template <typename T>
+using value_type_t = typename T::value_type;
+
+template <bool B, typename T = void>
+using enable_if_t = typename std::enable_if<B, T>::type;
+
+#pragma push_macro("DECL_ALIAS")
+#define DECL_ALIAS(Name)  \
+    template <typename T> \
+    using Name##_t = type_t<std::Name<T>>
+DECL_ALIAS(decay);
+DECL_ALIAS(make_signed);
+DECL_ALIAS(make_unsigned);
+DECL_ALIAS(remove_reference);
+DECL_ALIAS(remove_const);
+DECL_ALIAS(remove_volatile);
+DECL_ALIAS(remove_cv);
+DECL_ALIAS(add_const);
+DECL_ALIAS(add_volatile);
+DECL_ALIAS(add_lvalue_reference);
+DECL_ALIAS(add_rvalue_reference);
+#pragma pop_macro("DECL_ALIAS")
+
+template <typename... Ts>
+using common_type_t = type_t<std::common_type<Ts...>>;
+
+/**
+ * @brief Remove top-level const+volatile+reference qualifiers from the given type.
+ */
+template <typename T>
+using remove_cvref_t = remove_cv_t<remove_reference_t<T>>;
+
+/**
+ * @brief Create a reference-to-const for the given type
+ */
+template <typename T>
+using const_reference_t = add_lvalue_reference_t<const remove_cvref_t<T>>;
+
+/**
+ * @brief A "do-nothing" alias template that always evaluates to void
+ *
+ * @tparam Ts Zero or more type arguments, all discarded
+ */
+template <typename... Ts>
+using void_t = void;
+
+/**
+ * @brief Alias for integral_constant<bool, B>
+ */
+template <bool B>
+using bool_constant = std::integral_constant<bool, B>;
+
+/**
+ * @brief Holds a list of types.
+ *
+ * This template is never defined, so cannot be used in contexts that require a complete type.
+ */
+template <typename...>
+struct mp_list;
+
+/// ## Implementation of the C++11 detection idiom
+namespace impl_detection {
+
+// Implementation of detection idiom for is_detected: true case
+template <
+    // A metafunction to try and apply
+    bsoncxx_ttparam Oper,
+    // The arguments to be given. These are deduced from the mp_list argument
+    typename... Args,
+    // Apply the arguments to the metafunction. If this yields a type, this function
+    // will be viable. If substitution fails, this function is discarded from the
+    // overload set.
+    typename SfinaeHere = Oper<Args...>>
+std::true_type is_detected_f(mp_list<Args...>*);
+
+// Failure case for is_detected. Because this function takes an elipsis, this is
+// less preferred than the above overload that accepts a pointer type directly.
+template <bsoncxx_ttparam Oper, typename... Args>
+std::false_type is_detected_f(...);
+
+// Provides the detected_or impl
+template <bool IsDetected>
+struct detection;
+
+// Non-detected case:
+template <>
+struct detection<false> {
+    // We just return the default, since the metafunction will not apply
+    template <typename Default, bsoncxx_ttparam, typename...>
+    using f = Default;
+};
+
+// Detected case:
+template <>
+struct detection<true> {
+    template <typename, bsoncxx_ttparam Oper, typename... Args>
+    using f = Oper<Args...>;
+};
+
+}  // namespace impl_detection
+
+/**
+ * @brief The type yielded by detected_t if the given type operator does not
+ * yield a type.
+ */
+struct nonesuch {
+    ~nonesuch() = delete;
+    nonesuch(nonesuch const&) = delete;
+    void operator=(nonesuch const&) = delete;
+};
+
+/**
+ * @brief Results in true_type if the given metafunction yields a valid type when applied to the
+ * given arguments, otherwise yields false_type
+ *
+ * @tparam Oper A template that evaluates to a type
+ * @tparam Args Some number of arguments to apply to Oper
+ */
+template <bsoncxx_ttparam Oper, typename... Args>
+struct is_detected
+    : decltype(impl_detection::is_detected_f<Oper>(static_cast<mp_list<Args...>*>(nullptr))) {};
+
+/**
+ * @brief If Oper<Args...> evaluates to a type, yields that type. Otherwise, yields
+ * the Dflt type
+ *
+ * @tparam Dflt The default type to return if the metafunction does not apply
+ * @tparam Oper A metafunction to speculatively apply
+ * @tparam Args The arguments to give to the Oper metafunction
+ */
+template <typename Dflt, bsoncxx_ttparam Oper, typename... Args>
+using detected_or = typename impl_detection::detection<
+    is_detected<Oper, Args...>::value>::template f<Dflt, Oper, Args...>;
+
+/**
+ * @brief If Oper<Args...> evaluates to a type, yields that type. Otherwise, yields
+ * the sentinel type `nonesuch`
+ *
+ * @tparam Oper A metafunction to try to apply
+ * @tparam Args The metafunction arguments to apply to Oper
+ */
+template <bsoncxx_ttparam Oper, typename... Args>
+using detected_t = detected_or<nonesuch, Oper, Args...>;
+
+/**
+ * @brief Impl of conditional_t
+ *
+ * Separating the boolean from the type arguments results in significant speedup to compilation
+ * due to type memoization
+ */
+
+template <bool B>
+struct conditional {
+    template <typename IfTrue, typename>
+    using f = IfTrue;
+};
+
+template <>
+struct conditional<false> {
+    template <typename, typename IfFalse>
+    using f = IfFalse;
+};
+
+/**
+ * @brief Pick one of two types based on a boolean
+ *
+ * @tparam B A boolean value
+ * @tparam T If `B` is true, pick this type
+ * @tparam F If `B` is false, pick this type
+ */
+template <bool B, typename T, typename F>
+using conditional_t = typename conditional<B>::template f<T, F>;
+
+// impl for conjunction+disjunction
+namespace impl_logic {
+
+template <typename FalseType, typename Opers>
+struct conj;
+
+template <typename H, typename... Tail>
+struct conj<bool_constant<H::value || !sizeof...(Tail)>, mp_list<H, Tail...>> : H {};
+
+template <typename F, typename H, typename... Tail>
+struct conj<F, mp_list<H, Tail...>> : conj<F, mp_list<Tail...>> {};
+
+template <typename H>
+struct conj<std::false_type, mp_list<H>> : H {};
+
+template <>
+struct conj<std::false_type, mp_list<>> : std::true_type {};
+
+template <typename TrueType, typename Opers>
+struct disj;
+
+template <typename H, typename... Tail>
+struct disj<bool_constant<H::value && sizeof...(Tail)>, mp_list<H, Tail...>> : H {};
+
+template <typename F, typename H, typename... Tail>
+struct disj<F, mp_list<H, Tail...>> : disj<F, mp_list<Tail...>> {};
+
+template <typename H>
+struct disj<std::true_type, mp_list<H>> : H {};
+
+template <>
+struct disj<std::true_type, mp_list<>> : std::false_type {};
+
+}  // namespace impl_logic
+
+/**
+ * @brief inherits unambiguously from the first of `Ts...` for which
+ * `Ts::value` is a valid expression equal to `false`, or the last of `Ts...` otherwise.
+ *
+ * conjunction<> (given no arguments) inherits from std::true_type.
+ *
+ * If any of `Ts::value == false`, then no subsequent `Ts::value` will be instantiated.
+ */
+template <typename... Cond>
+struct conjunction : impl_logic::conj<std::false_type, mp_list<Cond...>> {};
+
+/**
+ * @brief Inherits unambiguous from the first of `Ts...` where `Ts::value` is `true`,
+ * or the last of `Ts...` otherwise.
+ *
+ * Given no arguments, inherits from std::false_type;
+ *
+ * If any of `Ts::value == true`, then no subsequent `Ts::value` will be instantiated.
+ */
+template <typename... Cond>
+struct disjunction : impl_logic::disj<std::true_type, mp_list<Cond...>> {};
+
+/**
+ * @brief Given a boolean type trait, returns a type trait which is the logical negation thereof
+ *
+ * @tparam T A type trait with a static member ::value
+ */
+template <typename T>
+struct negation : bool_constant<!T::value> {};
+
+/**
+ * @brief Yields std::true_type, regardless of type arguments.
+ *
+ * Useful for wrapping potential decltype() substitution failures in positions
+ * that expect a bool_constant type.
+ */
+template <typename...>
+using true_t = std::true_type;
+
+namespace impl_requires {
+
+template <typename R>
+R norm_conjunction(...);
+
+template <typename R, typename... Cs>
+conjunction<Cs...> norm_conjunction(const conjunction<Cs...>&);
+
+template <typename T>
+using norm_conjunction_t = decltype(norm_conjunction<T>(std::declval<const T&>()));
+
+template <typename Constraint, typename = void>
+struct requirement;
+
+template <typename FailingRequirement>
+struct failed_requirement {
+    failed_requirement(int) = delete;
+
+    template <typename T>
+    static T explain(failed_requirement);
+};
+
+template <typename... SubRequirements>
+struct failed_requirement<conjunction<SubRequirements...>> {
+    failed_requirement(int) = delete;
+
+    template <typename T>
+    static auto explain(int)
+        -> common_type_t<decltype(requirement<SubRequirements>::test::template explain<T>(0))...>;
+};
+
+template <typename Constraint, typename>
+struct requirement {
+    using test = failed_requirement<impl_requires::norm_conjunction_t<Constraint>>;
+};
+
+template <typename Constraint>
+struct requirement<Constraint, enable_if_t<Constraint::value>> {
+    struct test {
+        template <typename T>
+        static T explain(int);
+    };
+};
+
+}  // namespace impl_requires
+
+/**
+ * @brief If none of `Ts::value is 'false'`, yields the type `Type`, otherwise
+ * this type is undefined.
+ *
+ * Use this to perform enable-if style template constraints.
+ *
+ * @tparam Type The type to return upon success
+ * @tparam Traits A list of type traits with nested ::value members
+ */
+template <typename Type, typename... Traits>
+#if defined _MSC_VER && _MSC_VER < 1920
+// VS 2015 has trouble with expression SFINAE.
+using requires_t = enable_if_t<conjunction<Traits...>::value, Type>;
+#else
+// Generates better error messages in case of substitution failure than a plain enable_if_t:
+using requires_t =
+    decltype(impl_requires::requirement<conjunction<Traits...>>::test::template explain<Type>(0));
+#endif
+
+/**
+ * @brief If any of `Ts::value` is 'true', this type is undefined, otherwise
+ * yields the type `Type`.
+ *
+ * Use this to perform enable-if template contraints.
+ *
+ * @tparam Type The type to return upon success
+ * @tparam Traits A list of type traits with nested ::value members
+ */
+template <typename Type, typename... Traits>
+using requires_not_t = requires_t<Type, negation<disjunction<Traits...>>>;
+
+// Impl: invoke/is_invocable
+namespace impl_invoke {
+
+#pragma push_macro("RETURNS")
+#define RETURNS(...)                                         \
+    noexcept(noexcept(__VA_ARGS__))->decltype(__VA_ARGS__) { \
+        return __VA_ARGS__;                                  \
+    }                                                        \
+    static_assert(true, "")
+
+template <bool IsMemberObject, bool IsMemberFunction>
+struct invoker {
+    template <typename F, typename... Args>
+    constexpr static auto apply(F&& fun, Args&&... args)
+        RETURNS(static_cast<F&&>(fun)(static_cast<Args&&>(args)...));
+};
+
+template <>
+struct invoker<false, true> {
+    template <typename F, typename Self, typename... Args>
+    constexpr static auto apply(F&& fun, Self&& self, Args&&... args)
+        RETURNS((static_cast<Self&&>(self).*fun)(static_cast<Args&&>(args)...));
+};
+
+template <>
+struct invoker<true, false> {
+    template <typename F, typename Self>
+    constexpr static auto apply(F&& fun, Self&& self) RETURNS(static_cast<Self&&>(self).*fun);
+};
+
+}  // namespace impl_invoke
+
+static constexpr struct invoke_fn {
+    /**
+     * @brief Invoke the given object with the given arguments.
+     *
+     * @param fn An invocable: A callable, member object pointer, or member function pointer.
+     * @param args The arguments to use for invocation.
+     */
+
+    template <typename F, typename... Args, typename Fd = remove_cvref_t<F>>
+    constexpr auto operator()(F&& fn, Args&&... args) const
+        RETURNS(impl_invoke::invoker<std::is_member_object_pointer<Fd>::value,
+                                     std::is_member_function_pointer<Fd>::value>  //
+                ::apply(static_cast<F&&>(fn), static_cast<Args&&>(args)...));
+} invoke;
+
+#pragma pop_macro("RETURNS")
+
+/**
+ * @brief Yields the type that would result from invoking F with the given arguments.
+ *
+ * @tparam Fun A invocable: A function pointer or callable object, or a member pointer
+ * @tparam Args The arguments to apply
+ */
+template <typename F, typename... Args>
+using invoke_result_t = decltype(invoke(std::declval<F>(), std::declval<Args>()...));
+
+/**
+ * @brief Trait type to detect if the given object can be "invoked" using the given arguments.
+ *
+ * @tparam Fun A invocable: A function pointer or callable object, or a member pointer
+ * @tparam Args The arguments to match against
+ */
+template <typename Fun, typename... Args>
+#if defined(_MSC_VER) && _MSC_VER < 1910
+using is_invocable = is_detected<invoke_result_t, Fun, Args...>;
+#else
+struct is_invocable : is_detected<invoke_result_t, Fun, Args...> {
+};
+#endif
+
+/**
+ * @brief Trait detects whether the given types are the same after the removal
+ * of top-level CV-ref qualifiers
+ */
+template <typename T, typename U>
+struct is_alike : std::is_same<remove_cvref_t<T>, remove_cvref_t<U>> {};
+
+}  // namespace detail
+
+}  // namespace v_noabi
+
+}  // namespace bsoncxx
+
+#include <bsoncxx/config/postlude.hpp>
diff --git a/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/types.hpp b/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/types.hpp
index 2d28050af2..6c38bfa5f1 100644
--- a/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/types.hpp
+++ b/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/types.hpp
@@ -22,6 +22,7 @@
 #include <bsoncxx/document/view.hpp>
 #include <bsoncxx/oid.hpp>
 #include <bsoncxx/stdx/string_view.hpp>
+#include <bsoncxx/stdx/type_traits.hpp>
 
 #include <bsoncxx/config/prelude.hpp>
 
@@ -131,9 +132,7 @@ struct BSONCXX_API b_string {
     /// @param t
     ///   The value to wrap.
     ///
-    template <typename T,
-              typename std::enable_if<!std::is_same<b_string, typename std::decay<T>::type>::value,
-                                      int>::type = 0>
+    template <typename T, detail::requires_not_t<int, detail::is_alike<b_string, T>> = 0>
     BSONCXX_INLINE explicit b_string(T&& t) : value(std::forward<T>(t)) {}
 
     stdx::string_view value;
@@ -394,8 +393,7 @@ struct BSONCXX_API b_regex {
     ///
     template <typename T,
               typename U = stdx::string_view,
-              typename std::enable_if<!std::is_same<b_regex, typename std::decay<T>::type>::value,
-                                      int>::type = 0>
+              detail::requires_not_t<int, detail::is_alike<b_regex, T>> = 0>
     BSONCXX_INLINE explicit b_regex(T&& regex, U&& options = U{})
         : regex(std::forward<T>(regex)), options(std::forward<U>(options)) {}
 
@@ -446,9 +444,7 @@ struct BSONCXX_API b_code {
     /// @param t
     ///   The js code
     ///
-    template <typename T,
-              typename std::enable_if<!std::is_same<b_code, typename std::decay<T>::type>::value,
-                                      int>::type = 0>
+    template <typename T, detail::requires_not_t<int, detail::is_alike<b_code, T>> = 0>
     BSONCXX_INLINE explicit b_code(T&& t) : code(std::forward<T>(t)) {}
 
     stdx::string_view code;
@@ -485,9 +481,7 @@ struct BSONCXX_API b_symbol {
     /// @param t
     ///   The symbol.
     ///
-    template <typename T,
-              typename std::enable_if<!std::is_same<b_symbol, typename std::decay<T>::type>::value,
-                                      int>::type = 0>
+    template <typename T, detail::requires_not_t<int, detail::is_alike<b_symbol, T>> = 0>
     BSONCXX_INLINE explicit b_symbol(T&& t) : symbol(std::forward<T>(t)) {}
 
     stdx::string_view symbol;
@@ -524,11 +518,9 @@ struct BSONCXX_API b_codewscope {
     /// @param scope
     ///   A bson document view holding the scope environment.
     ///
-    template <
-        typename T,
-        typename U,
-        typename std::enable_if<!std::is_same<b_codewscope, typename std::decay<T>::type>::value,
-                                int>::type = 0>
+    template <typename T,
+              typename U,
+              detail::requires_not_t<int, detail::is_alike<b_codewscope, T>> = 0>
     BSONCXX_INLINE explicit b_codewscope(T&& code, U&& scope)
         : code(std::forward<T>(code)), scope(std::forward<U>(scope)) {}
 
@@ -628,10 +620,7 @@ struct BSONCXX_API b_decimal128 {
     /// @param t
     ///   The value to wrap.
     ///
-    template <
-        typename T,
-        typename std::enable_if<!std::is_same<b_decimal128, typename std::decay<T>::type>::value,
-                                int>::type = 0>
+    template <typename T, detail::requires_not_t<int, detail::is_alike<b_decimal128, T>> = 0>
     BSONCXX_INLINE explicit b_decimal128(T&& t) : value(std::forward<T>(t)) {}
 };
 
diff --git a/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/types/bson_value/view.hpp b/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/types/bson_value/view.hpp
index e640cca6e5..99408d196e 100644
--- a/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/types/bson_value/view.hpp
+++ b/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/types/bson_value/view.hpp
@@ -18,6 +18,7 @@
 #include <cstdint>
 #include <type_traits>
 
+#include <bsoncxx/stdx/type_traits.hpp>
 #include <bsoncxx/types.hpp>
 
 #include <bsoncxx/config/prelude.hpp>
@@ -306,32 +307,36 @@ class BSONCXX_API view {
     };
 };
 
-// sfinae in the bool return to avoid competing with the value == value
-// operators.
 template <typename T>
-using not_view = typename std::enable_if<
-    std::is_constructible<bson_value::view, T>::value &&
-        !std::is_same<typename std::decay<T>::type, bson_value::view>::value &&
-        !std::is_same<typename std::decay<T>::type, bson_value::value>::value,
-    bool>::type;
+using is_bson_view_compatible = detail::conjunction<
+    std::is_constructible<bson_value::view, T>,
+    detail::negation<detail::disjunction<detail::is_alike<T, bson_value::view>,
+                                         detail::is_alike<T, bson_value::value>>>>;
 
 template <typename T>
-BSONCXX_INLINE not_view<T> operator==(const bson_value::view& lhs, T&& rhs) {
+using not_view = is_bson_view_compatible<T>;
+
+template <typename T>
+BSONCXX_INLINE detail::requires_t<bool, is_bson_view_compatible<T>>  //
+operator==(const bson_value::view& lhs, T&& rhs) {
     return lhs == bson_value::view{std::forward<T>(rhs)};
 }
 
 template <typename T>
-BSONCXX_INLINE not_view<T> operator==(T&& lhs, const bson_value::view& rhs) {
+BSONCXX_INLINE detail::requires_t<bool, is_bson_view_compatible<T>>  //
+operator==(T&& lhs, const bson_value::view& rhs) {
     return bson_value::view{std::forward<T>(lhs)} == rhs;
 }
 
 template <typename T>
-BSONCXX_INLINE not_view<T> operator!=(const bson_value::view& lhs, T&& rhs) {
+BSONCXX_INLINE detail::requires_t<bool, is_bson_view_compatible<T>>  //
+operator!=(const bson_value::view& lhs, T&& rhs) {
     return lhs != bson_value::view{std::forward<T>(rhs)};
 }
 
 template <typename T>
-BSONCXX_INLINE not_view<T> operator!=(T&& lhs, const bson_value::view& rhs) {
+BSONCXX_INLINE detail::requires_t<bool, is_bson_view_compatible<T>>  //
+operator!=(T&& lhs, const bson_value::view& rhs) {
     return bson_value::view{std::forward<T>(lhs)} != rhs;
 }
 
diff --git a/src/bsoncxx/test/CMakeLists.txt b/src/bsoncxx/test/CMakeLists.txt
index b505b81356..f3c224b02e 100644
--- a/src/bsoncxx/test/CMakeLists.txt
+++ b/src/bsoncxx/test/CMakeLists.txt
@@ -38,6 +38,7 @@ add_executable(test_bson
     oid.cpp
     view_or_value.cpp
     make_unique.test.cpp
+    type_traits.test.cpp
 )
 
 # Common target properties for test executables.
@@ -120,5 +121,6 @@ set_dist_list(src_bsoncxx_test_DIST
     test_macro_guards.cpp.in
     to_string.hh
     view_or_value.cpp
+    type_traits.test.cpp
     make_unique.test.cpp
 )
diff --git a/src/bsoncxx/test/type_traits.test.cpp b/src/bsoncxx/test/type_traits.test.cpp
new file mode 100644
index 0000000000..5c3a452d91
--- /dev/null
+++ b/src/bsoncxx/test/type_traits.test.cpp
@@ -0,0 +1,182 @@
+#include <string>
+#include <type_traits>
+
+#include <bsoncxx/stdx/type_traits.hpp>
+#include <third_party/catch/include/catch.hpp>
+
+#if __GNUC__
+// We declare variables that are only used for compilation checking
+// (applies to Clang as well)
+#pragma GCC diagnostic ignored "-Wunused"
+#endif
+
+namespace {
+namespace tt = bsoncxx::detail;
+
+template <typename Result, typename Expect>
+struct assert_same {
+    static_assert(std::is_same<Result, Expect>::value, "Fail");
+    using x = void;
+};
+
+template <typename Expect, typename... Args>
+struct Case {
+    template <bsoncxx_ttparam F>
+    struct apply {
+        using x = typename assert_same<F<Args...>, Expect>::x;
+    };
+};
+
+template <bsoncxx_ttparam Op, typename Case>
+struct one_case {
+    using x = typename Case::template apply<Op>::x;
+};
+
+template <bsoncxx_ttparam Oper, typename... Cases>
+struct check_cases : one_case<Oper, Cases>... {};
+
+constexpr check_cases<  //
+    tt::decay_t,
+    Case<int, int>,
+    Case<int, const int>,
+    Case<int, const int&>,
+    Case<int, const int&&>,
+    Case<int, int&>,
+    Case<int, int&&>,
+    Case<int*, int*>,
+    Case<const int*, const int*>,
+    Case<const int*, const int*&>,
+    Case<const int*, const int[42]>,
+    Case<const int*, const int (&)[42]>,
+    Case<int*, int[42]>,
+    Case<int (*)(int), int (&)(int)>,
+    Case<void, void>>
+    decay;
+
+constexpr check_cases<  //
+    tt::remove_cvref_t,
+    Case<int, int&&>,
+    Case<int, const int&&>,
+    Case<int(int), int(&&)(int)>,
+    Case<int(int), int (&)(int)>,
+    Case<int[42], const int (&)[42]>,
+    Case<int[42], const int[42]>,
+    Case<const int*, const int*&>,
+    Case<int, const int>,
+    Case<void, const void>,
+    Case<void, void>,
+    Case<int, int>>
+    remove_cvref;
+
+constexpr check_cases<  //
+    tt::const_reference_t,
+    Case<void* const&, void*>,
+    Case<const int&, volatile int&&>,
+    Case<const int&, int&&>,
+    Case<const int&, int&>,
+    Case<const void, void>,
+    Case<const int&, int>>
+    const_reference;
+
+constexpr check_cases<  //
+    tt::void_t,
+    Case<void, struct in_situ_never_defined>,
+    Case<void, int>,
+    Case<void, int, int>,
+    Case<void>>
+    void_t;
+
+constexpr assert_same<std::true_type, tt::bool_constant<true>> t;
+constexpr assert_same<std::false_type, tt::bool_constant<false>> f;
+
+static_assert(tt::is_detected<tt::remove_cvref_t, int>::value, "fail");
+
+template <typename T>
+struct hard_error {
+    static_assert(std::is_void<T>::value, "fail");
+};
+
+struct my_false {
+    static constexpr bool value = false;
+};
+
+static_assert(std::is_base_of<my_false, tt::conjunction<my_false, std::false_type, void>>  //
+              ::value,
+              "fail");
+
+static_assert(
+    std::is_base_of<my_false, tt::conjunction<my_false, std::false_type, void, hard_error<int>>>  //
+    ::value,
+    "fail");
+
+template <typename T>
+tt::requires_t<T, std::is_integral<T>> add_one(T v) {
+    return v + 1;
+}
+
+template <typename T>
+tt::requires_t<T, tt::negation<std::is_integral<T>>> add_one(T other) {
+    return other + "one";
+}
+
+TEST_CASE("requires_t") {
+    CHECK(add_one(1) == 2);
+    CHECK(add_one(std::string("twenty-")) == "twenty-one");
+}
+
+struct something {
+    int value;
+
+    int memfn(int, std::string);
+};
+
+static_assert(tt::is_detected<tt::invoke_result_t, decltype(&something::value), something>::value,
+              "fail");
+
+static_assert(
+    std::is_same<tt::invoke_result_t<decltype(&something::value), something&>, int&>::value,
+    "fail");
+
+static_assert(
+    std::is_same<tt::invoke_result_t<decltype(&something::value), something&&>, int&&>::value,
+    "fail");
+
+static_assert(std::is_same<tt::invoke_result_t<decltype(&something::value), const something&>,
+                           const int&>::value,
+              "fail");
+
+static_assert(
+    std::is_same<tt::invoke_result_t<decltype(&something::memfn), something&&, int, const char*>,
+                 int>::value,
+    "fail");
+
+// invoke_result_t disappears when given wrong argument types:
+static_assert(
+    !tt::is_detected<tt::invoke_result_t, decltype(&something::memfn), something&&, int, int>::
+        value,
+    "fail");
+
+struct constrained_callable {
+    // Viable only if F is callable as F(int, Arg)
+    template <typename F, typename Arg>
+    tt::requires_t<double, tt::is_invocable<F, int, Arg>> operator()(F&&, Arg) const;
+};
+
+static_assert(!tt::is_detected<tt::invoke_result_t,
+                               constrained_callable,
+                               void (*)(int, std::string),
+                               double>::value,
+              "fail");
+
+static_assert(tt::is_detected<tt::invoke_result_t,
+                              constrained_callable,
+                              void (*)(int, std::string),
+                              const char*>::value,
+              "fail");
+
+static_assert(
+    tt::is_detected<tt::invoke_result_t, constrained_callable, void (*)(int, double), double>::
+        value,
+    "fail");
+
+}  // namespace
diff --git a/src/mongocxx/lib/mongocxx/v_noabi/mongocxx/test_util/mock.hh b/src/mongocxx/lib/mongocxx/v_noabi/mongocxx/test_util/mock.hh
index a816428bf9..38d098d185 100644
--- a/src/mongocxx/lib/mongocxx/v_noabi/mongocxx/test_util/mock.hh
+++ b/src/mongocxx/lib/mongocxx/v_noabi/mongocxx/test_util/mock.hh
@@ -26,6 +26,8 @@
 #include <unordered_map>
 #include <vector>
 
+#include "bsoncxx/stdx/type_traits.hpp"
+
 #include <mongocxx/config/private/prelude.hh>
 
 namespace mongocxx {
@@ -85,8 +87,10 @@ class mock<R (*)(Args...)> {
             return _callbacks.top();
         }
 
-        template <typename T, typename... U>
-        typename std::enable_if<std::is_same<T, R>::value, rule&>::type interpose(T r, U... rs) {
+        template <typename T,
+                  typename... U,
+                  bsoncxx::detail::requires_t<int, std::is_same<T, R>> = 0>
+        rule& interpose(T r, U... rs) {
             std::array<R, sizeof...(rs) + 1> vec = {r, rs...};
             std::size_t i = 0;