diff --git a/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/config/postlude.hpp b/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/config/postlude.hpp
index 03ad2d8a7b..1c1b915f5a 100644
--- a/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/config/postlude.hpp
+++ b/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/config/postlude.hpp
@@ -95,3 +95,5 @@ static_assert(false, "BSONCXX_ENUM must be undef'ed");
 #pragma pop_macro("BSONCXX_IF_GCC")
 #pragma pop_macro("BSONCXX_IF_CLANG")
 #pragma pop_macro("BSONCXX_IF_GNU_LIKE")
+
+#pragma pop_macro("BSONCXX_FWD")
diff --git a/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/config/prelude.hpp b/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/config/prelude.hpp
index 6a43ff4101..2f154c437f 100644
--- a/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/config/prelude.hpp
+++ b/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/config/prelude.hpp
@@ -45,6 +45,8 @@
 #undef _bsoncxxDisableWarningImpl_for_MSVC
 #pragma push_macro("_bsoncxxDisableWarningImpl_for_GNU")
 #undef _bsoncxxDisableWarningImpl_for_GNU
+#pragma push_macro("BSONCXX_FWD")
+#undef BSONCXX_FWD
 
 // compiler.hpp
 #pragma push_macro("BSONCXX_INLINE")
diff --git a/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/config/util.hpp b/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/config/util.hpp
index b42ce4682b..045c8c80a9 100644
--- a/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/config/util.hpp
+++ b/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/config/util.hpp
@@ -131,3 +131,6 @@
 
 #define _bsoncxxDisableWarningImpl_for_MSVC(...) \
     BSONCXX_IF_MSVC(BSONCXX_PRAGMA(warning(disable : __VA_ARGS__)))
+
+#define BSONCXX_FWD(...) static_cast<decltype(__VA_ARGS__)&&>(__VA_ARGS__)
+
diff --git a/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/stdx/operators.hpp b/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/stdx/operators.hpp
index 8e889b0b1a..f9e553361f 100644
--- a/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/stdx/operators.hpp
+++ b/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/stdx/operators.hpp
@@ -114,6 +114,11 @@ class strong_ordering {
     DEFOP(<=);
     DEFOP(>=);
 #pragma pop_macro("DEFOP")
+
+    // nonstd: Swap greater/less values
+    constexpr strong_ordering inverted() const noexcept {
+        return *this < 0 ? greater : *this > 0 ? less : *this;
+    }
 };
 
 #pragma push_macro("INLINE_VAR")
@@ -151,8 +156,8 @@ struct compare_three_way {
               typename R,
               typename = decltype(tag_invoke(
                   std::declval<compare_three_way>(), std::declval<L>(), std::declval<R>()))>
-    constexpr strong_ordering impl(L const& l, R const& r, rank<2>) const {
-        return tag_invoke(*this, l, r);
+    constexpr static strong_ordering impl(L const& l, R const& r, rank<2>) {
+        return tag_invoke(compare_three_way{}, l, r);
     }
 
     template <typename L, typename R>
@@ -165,12 +170,20 @@ struct compare_three_way {
  * implementation of tag_invoke(compare_three_way, l, r)
  */
 struct ordering_operators {
+    template <typename L, typename R>
+    constexpr static auto impl(const L& l, const R& r, rank<1>)
+        BSONCXX_RETURNS(tag_invoke(compare_three_way{}, l, r));
+
+    template <typename L, typename R>
+    constexpr static auto impl(const L& l, const R& r, rank<0>)
+        BSONCXX_RETURNS(tag_invoke(compare_three_way{}, r, l).inverted());
+
 #pragma push_macro("DEFOP")
 #undef DEFOP
 #define DEFOP(Oper)                                             \
     template <typename L, typename R>                           \
     constexpr friend auto operator Oper(const L& l, const R& r) \
-        BSONCXX_RETURNS(tag_invoke(compare_three_way{}, l, r) Oper 0)
+        BSONCXX_RETURNS(ordering_operators::impl(l, r, rank<1>{}) Oper 0)
     DEFOP(<);
     DEFOP(>);
     DEFOP(<=);
@@ -178,6 +191,35 @@ struct ordering_operators {
 #pragma pop_macro("DEFOP")
 };
 
+template <typename T, typename U>
+std::false_type is_partially_ordered_with_f(rank<0>);
+
+template <typename T, typename U>
+auto is_partially_ordered_with_f(rank<1>,
+                                 const T& l = soft_declval<T>(),
+                                 const U& r = soft_declval<U>())  //
+    -> true_t<decltype(l > r),
+              decltype(l < r),
+              decltype(l >= r),
+              decltype(l <= r),
+              decltype(r < l),
+              decltype(r > l),
+              decltype(r <= l),
+              decltype(r >= l)>;
+
+template <typename T, typename U>
+struct is_partially_ordered_with : decltype(is_partially_ordered_with_f<T, U>(rank<1>{})) {};
+
+template <typename T>
+struct is_totally_ordered
+    : conjunction<is_equality_comparable<T>, is_partially_ordered_with<T, T>> {};
+
+template <typename T, typename U>
+struct is_totally_ordered_with : conjunction<is_totally_ordered<T>,
+                                             is_totally_ordered<U>,
+                                             is_equality_comparable<T, U>,
+                                             is_partially_ordered_with<T, U>> {};
+
 }  // namespace detail
 }  // namespace bsoncxx
 
diff --git a/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/stdx/optional.hpp b/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/stdx/optional.hpp
index ab574c8998..eb9db49474 100644
--- a/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/stdx/optional.hpp
+++ b/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/stdx/optional.hpp
@@ -14,72 +14,770 @@
 
 #pragma once
 
-#include <bsoncxx/config/prelude.hpp>
+#include <cstddef>
+#include <cstdio>
+#include <exception>
+#include <initializer_list>
+#include <memory>
+#include <stdexcept>
+#include <type_traits>
+#include <utility>
 
-#if defined(BSONCXX_POLY_USE_MNMLSTC)
+#include "./operators.hpp"
+#include "./type_traits.hpp"
 
-#include <core/optional.hpp>
+#include <bsoncxx/config/prelude.hpp>
 
 namespace bsoncxx {
+
 namespace v_noabi {
+
 namespace stdx {
 
-using ::core::make_optional;
-using ::core::nullopt;
-using ::core::nullopt_t;
-using ::core::optional;
+/**
+ * @brief Implementation of an std::optional-like class template
+ *
+ * Presents mostly the same interface as std::optional from C++17.
+ *
+ * @tparam T The type being made "optional"
+ */
+template <typename T>
+class optional;
 
-}  // namespace stdx
-}  // namespace v_noabi
-}  // namespace bsoncxx
+/**
+ * @brief Exception type thrown upon attempted access to a value-less optional<T>
+ * via a throwing accessor API.
+ */
+class bad_optional_access : public std::exception {
+   public:
+    const char* what() const noexcept override {
+        return "bad_optional_access()";
+    }
+};
+/// Tag type to represent an empty optional value
+struct nullopt_t {
+    explicit constexpr nullopt_t(std::nullptr_t) noexcept {}
+};
+/// Tag constant to construct or compare with an empty optional value
+static constexpr nullopt_t nullopt{0};
+/// Tag used to call the emplacement-constructor of optional<T>
+static constexpr struct in_place_t {
+} in_place;
 
-#elif defined(BSONCXX_POLY_USE_BOOST)
+namespace detail {
 
-#include <boost/none.hpp>
-#include <boost/optional/optional.hpp>
-#include <boost/optional/optional_io.hpp>
+// Terminates the program when an illegal use of optional<T> is attempted
+[[noreturn]] inline void terminate_disengaged_optional(const char* what) noexcept {
+    (void)std::fprintf(stderr, "%s: Invalid attempted use of disengaged optional<T>\n", what);
+    std::terminate();
+}
+// Throws bad_optional_access for throwing optional<T> member functions
+[[noreturn]] inline void throw_bad_optional() {
+    throw bad_optional_access();
+}
+// Base class of std::optional. Implementation detail, defined later
+template <typename T>
+struct optional_base_class;
 
-namespace bsoncxx {
-namespace v_noabi {
-namespace stdx {
+// Base case: Things are not optionals.
+template <typename T>
+std::true_type not_an_optional_f(const T&);
+// More-specialized if given an optional<T> or any class derived from a template
+// specialization thereof.
+template <typename T>
+std::false_type not_an_optional_f(const optional<T>&);
 
-using ::boost::optional;
-using nullopt_t = ::boost::none_t;
+// Utility trait to detect specializations of stdx::optional
+template <typename T>
+struct not_an_optional : decltype(not_an_optional_f(std::declval<T const&>())) {};
 
-// TODO(MSVC): This would be better expressed as constexpr, but VS2015U1 can't do it.
-const nullopt_t nullopt{::boost::none};
-using ::boost::make_optional;
+template <typename T, typename Ucvr, typename U>
+struct enable_opt_conversion
+    : bsoncxx::detail::conjunction<  //
+          std::is_constructible<T, Ucvr>,
+          bsoncxx::detail::disjunction<  //
+              std::is_same<T, bool>,
+              bsoncxx::detail::negation<
+                  bsoncxx::detail::conjunction<std::is_constructible<T, optional<U>&>,
+                                               std::is_constructible<T, optional<U> const&>,
+                                               std::is_constructible<T, optional<U>&&>,
+                                               std::is_constructible<T, optional<U> const&&>,
+                                               std::is_convertible<optional<U>&, T>,
+                                               std::is_convertible<optional<U> const&, T>,
+                                               std::is_convertible<optional<U>&&, T>,
+                                               std::is_convertible<optional<U> const&&, T>>>>> {};
 
-}  // namespace stdx
-}  // namespace v_noabi
-}  // namespace bsoncxx
+template <typename From, typename To>
+struct enable_opt_value_conversion   //
+    : bsoncxx::detail::conjunction<  //
+          std::is_constructible<To, From&&>,
+          bsoncxx::detail::negation<bsoncxx::detail::is_alike<From, in_place_t>>,
+          bsoncxx::detail::negation<bsoncxx::detail::is_alike<From, optional<To>>>,
+          bsoncxx::detail::disjunction<
+              bsoncxx::detail::negation<bsoncxx::detail::is_alike<To, bool>>,  //
+              detail::not_an_optional<bsoncxx::detail::remove_cvref_t<From>>>> {};
 
-#elif defined(BSONCXX_POLY_USE_STD)
+}  // namespace detail
 
-#include <optional>
+template <typename T>
+class optional : bsoncxx::detail::equality_operators,
+                 bsoncxx::detail::ordering_operators,
+                 public detail::optional_base_class<T>::type {
+   public:
+    /// The type of value held within this optional
+    using value_type = T;
+    /// An lvalue-reference-to-mutable T
+    using reference = bsoncxx::detail::add_lvalue_reference_t<T>;
+    /// An lvalue-reference-to-const T
+    using const_reference =
+        bsoncxx::detail::add_lvalue_reference_t<bsoncxx::detail::add_const_t<T>>;
+    /// An rvalue-reference-to-mutable T
+    using rvalue_reference = bsoncxx::detail::add_rvalue_reference_t<T>;
+    /// An rvalue-reference-to-const T
+    using const_rvalue_reference =
+        bsoncxx::detail::add_rvalue_reference_t<bsoncxx::detail::add_const_t<T>>;
+    /// A pointer-to-mutable T
+    using pointer = bsoncxx::detail::add_pointer_t<T>;
+    /// A pointer-to-const T
+    using const_pointer = bsoncxx::detail::add_pointer_t<const T>;
 
-namespace bsoncxx {
-namespace v_noabi {
-namespace stdx {
+    // Constructors [1]
+    optional() = default;
+    constexpr optional(nullopt_t) noexcept {}
+
+    // Ctor [2] and [3] are provided by base classes
+    optional(const optional&) = default;
+    optional(optional&&) = default;
+    // Same with assignments
+    optional& operator=(const optional&) = default;
+    optional& operator=(optional&&) = default;
+    ~optional() = default;
+
+    // In-place constructors
+    template <typename... Args>
+    bsoncxx_cxx14_constexpr explicit optional(in_place_t, Args&&... args) noexcept(
+        noexcept(T(BSONCXX_FWD(args)...))) {
+        this->emplace(BSONCXX_FWD(args)...);
+    }
+
+    template <typename U, typename... Args>
+    bsoncxx_cxx14_constexpr explicit optional(
+        in_place_t,
+        std::initializer_list<U> il,
+        Args&&... args) noexcept(noexcept(T(il, BSONCXX_FWD(args)...))) {
+        this->emplace(il, BSONCXX_FWD(args)...);
+    }
+
+    // Explicit converting constructor. Only available if implicit conversion is
+    // not possible.
+    template <
+        typename U = T,
+        bsoncxx::detail::requires_t<int,
+                                    detail::enable_opt_value_conversion<U&&, T>,
+                                    bsoncxx::detail::negation<std::is_convertible<U&&, T>>> = 0>
+    bsoncxx_cxx14_constexpr explicit optional(U&& arg) noexcept(
+        std::is_nothrow_constructible<T, U&&>::value)
+        : optional(in_place, BSONCXX_FWD(arg)) {}
+
+    // Implicit converting constructor. Only available if implicit conversion is
+    // possible.
+    template <typename U = T,
+              bsoncxx::detail::requires_t<int,
+                                          detail::enable_opt_value_conversion<U&&, T>,
+                                          std::is_convertible<U&&, T>> = 0>
+    bsoncxx_cxx14_constexpr optional(U&& arg) noexcept(std::is_nothrow_constructible<T, U&&>::value)
+        : optional(in_place, BSONCXX_FWD(arg)) {}
+
+    template <typename U,
+              bsoncxx::detail::requires_t<
+                  int,
+                  detail::enable_opt_conversion<T, const U&, U>,
+                  bsoncxx::detail::negation<std::is_convertible<U const&, T>>> = 0>
+    bsoncxx_cxx14_constexpr explicit optional(optional<U> const& other) noexcept(
+        std::is_nothrow_constructible<T, bsoncxx::detail::add_lvalue_reference_t<const U>>::value) {
+        if (other.has_value()) {
+            this->emplace(*other);
+        }
+    }
+
+    template <typename U,
+              bsoncxx::detail::requires_t<int,
+                                          detail::enable_opt_conversion<T, const U&, U>,
+                                          std::is_convertible<U const&, T>> = 0>
+    bsoncxx_cxx14_constexpr optional(optional<U> const& other) noexcept(
+        std::is_nothrow_constructible<T, bsoncxx::detail::add_lvalue_reference_t<const U>>::value) {
+        if (other.has_value()) {
+            this->emplace(*other);
+        }
+    }
+
+    template <
+        typename U,
+        bsoncxx::detail::requires_t<int,
+                                    detail::enable_opt_conversion<T, U&&, U>,
+                                    bsoncxx::detail::negation<std::is_convertible<U&&, T>>> = 0>
+    bsoncxx_cxx14_constexpr explicit optional(optional<U>&& other) noexcept(
+        std::is_nothrow_constructible<T, bsoncxx::detail::add_lvalue_reference_t<U&&>>::value) {
+        if (other.has_value()) {
+            this->emplace(*BSONCXX_FWD(other));
+        }
+    }
+
+    template <typename U,
+              bsoncxx::detail::requires_t<int,
+                                          detail::enable_opt_conversion<T, U&&, U>,
+                                          std::is_convertible<U&&, T>> = 0>
+    bsoncxx_cxx14_constexpr optional(optional<U>&& other) noexcept(
+        std::is_nothrow_constructible<T, bsoncxx::detail::add_lvalue_reference_t<U&&>>::value) {
+        if (other.has_value()) {
+            this->emplace(*BSONCXX_FWD(other));
+        }
+    }
+
+    constexpr bool has_value() const noexcept {
+        return this->_has_value;
+    }
+    constexpr explicit operator bool() const noexcept {
+        return this->has_value();
+    }
+
+    // Unchecked dereference operators
+    bsoncxx_cxx14_constexpr reference operator*() & noexcept {
+        _assert_has_value("operator*() &");
+        return this->_storage.value;
+    }
+    bsoncxx_cxx14_constexpr const_reference operator*() const& noexcept {
+        _assert_has_value("operator*() const&");
+        return this->_storage.value;
+    }
+    bsoncxx_cxx14_constexpr rvalue_reference operator*() && noexcept {
+        _assert_has_value("operator*() &&");
+        return static_cast<rvalue_reference>(**this);
+    }
+    bsoncxx_cxx14_constexpr const_rvalue_reference operator*() const&& noexcept {
+        _assert_has_value("operator*() const&&");
+        return static_cast<const_rvalue_reference>(**this);
+    }
+
+    // (Unchecked) member-access operators
+    bsoncxx_cxx14_constexpr pointer operator->() noexcept {
+        _assert_has_value("operator->()");
+        return std::addressof(**this);
+    }
+    bsoncxx_cxx14_constexpr const_pointer operator->() const noexcept {
+        _assert_has_value("operator->() const");
+        return std::addressof(**this);
+    }
+
+    // Checked accessors
+    bsoncxx_cxx14_constexpr reference value() & {
+        _throw_if_empty();
+        return **this;
+    }
+    bsoncxx_cxx14_constexpr const_reference value() const& {
+        _throw_if_empty();
+        return **this;
+    }
+    bsoncxx_cxx14_constexpr rvalue_reference value() && {
+        _throw_if_empty();
+        return static_cast<rvalue_reference>(**this);
+    }
+    bsoncxx_cxx14_constexpr const_rvalue_reference value() const&& {
+        _throw_if_empty();
+        return static_cast<const_rvalue_reference>(**this);
+    }
+
+    // Checked value-or-alternative
+    template <typename U>
+    bsoncxx_cxx14_constexpr value_type value_or(U&& dflt) const& {
+        if (has_value()) {
+            return **this;
+        } else {
+            return static_cast<value_type>(BSONCXX_FWD(dflt));
+        }
+    }
+
+    template <typename U>
+    bsoncxx_cxx14_constexpr value_type value_or(U&& dflt) && {
+        if (has_value()) {
+            return *std::move(*this);
+        } else {
+            return static_cast<value_type>(BSONCXX_FWD(dflt));
+        }
+    }
+
+   private:
+    bsoncxx_cxx14_constexpr void _assert_has_value(const char* msg) const noexcept {
+        if (!this->has_value()) {
+            detail::terminate_disengaged_optional(msg);
+        }
+    }
+
+    bsoncxx_cxx14_constexpr void _throw_if_empty() const {
+        if (!this->has_value()) {
+            detail::throw_bad_optional();
+        }
+    }
+};
+
+/**
+ * @brief Construct an optional by decay-copying the given value into a new
+ * optional<decay_t<T>>
+ *
+ * @param value The value being made into an optional
+ */
+template <typename T>
+bsoncxx_cxx14_constexpr optional<bsoncxx::detail::decay_t<T>> make_optional(T&& value) noexcept(
+    std::is_nothrow_constructible<bsoncxx::detail::decay_t<T>, T&&>::value) {
+    return optional<bsoncxx::detail::decay_t<T>>(BSONCXX_FWD(value));
+}
+
+/**
+ * @brief Emplace-construct a new optional of the given type with the given
+ * constructor arguments
+ *
+ * @tparam T The type to be constructed
+ * @param args Constructor arguments
+ */
+template <typename T, typename... Args>
+bsoncxx_cxx14_constexpr optional<T> make_optional(Args&&... args) noexcept(
+    std::is_nothrow_constructible<T, Args&&...>::value) {
+    return optional<T>(in_place, BSONCXX_FWD(args)...);
+}
+
+/**
+ * @brief Emplace-construct a new optional of the given type with the given
+ * arguments (accepts an init-list as the first argument)
+ */
+template <typename T, typename U, typename... Args>
+bsoncxx_cxx14_constexpr optional<T>
+make_optional(std::initializer_list<U> il, Args&&... args) noexcept(
+    std::is_nothrow_constructible<T, std::initializer_list<U>, Args&&...>::value) {
+    return optional<T>(in_place, il, BSONCXX_FWD(args)...);
+}
+
+namespace detail {
+
+/**
+ * @brief Union template that defines the storage for an optional's data.
+ */
+template <typename T, bool = std::is_trivially_destructible<T>::value>
+union storage_for {
+    // Placeholder member for disengaged optional
+    char nothing;
+    // Member that holds the actual value
+    T value;
+
+    // Default-construct activates the placeholder
+    storage_for() noexcept : nothing(0) {}
+
+    // Empty special members allow the union to be used in semiregular contexts,
+    // but it is the responsibility of the using class to implement them properly
+    ~storage_for() {}
+    storage_for(const storage_for&) = delete;
+    storage_for& operator=(const storage_for&) = delete;
+};
+
+template <typename T>
+union storage_for<T, true /* Is trivially destructible */> {
+    char nothing;
+    T value;
+    storage_for() noexcept : nothing(0) {}
+    storage_for(const storage_for&) = delete;
+    storage_for& operator=(const storage_for&) = delete;
+};
+
+// Whether a type is copyable, moveable, or immobile
+enum copymove_classification {
+    copyable,
+    movable,
+    immobile,
+};
+
+/// Classify the constructibility of the given type
+template <typename T,
+          bool CanCopy = std::is_copy_constructible<T>::value,
+          bool CanMove = std::is_move_constructible<T>::value>
+constexpr copymove_classification classify_construct() {
+    return CanCopy ? copyable : CanMove ? movable : immobile;
+}
+
+/// Classify the assignability of the given type
+template <typename T,
+          bool CanCopy = std::is_copy_assignable<T>::value,
+          bool CanMove = std::is_move_assignable<T>::value>
+constexpr copymove_classification classify_assignment() {
+    return CanCopy ? copyable : CanMove ? movable : immobile;
+}
+
+/**
+ * @brief Common base class for optional storage implementation
+ *
+ * @tparam T
+ */
+template <typename T>
+class optional_common_base;
 
-using ::std::make_optional;
-using ::std::nullopt;
-using ::std::nullopt_t;
-using ::std::optional;
+/// Define the special member constructors for optional<T>
+template <typename T, copymove_classification = classify_construct<T>()>
+struct optional_construct_base;
+
+/// Define the special member assignment operators for optional<T>
+template <typename T, copymove_classification = classify_assignment<T>()>
+struct optional_assign_base;
+
+template <bool TrivialDestruct>
+struct optional_destruct_helper;
+
+template <typename T>
+using optional_destruct_base =
+    typename optional_destruct_helper<std::is_trivially_destructible<T>::value>::template base<T>;
+
+template <typename T>
+struct optional_assign_base<T, copyable> : optional_construct_base<T> {};
+
+template <typename T>
+struct optional_assign_base<T, movable> : optional_construct_base<T> {
+    // Constructors defer to base
+    optional_assign_base() = default;
+    optional_assign_base(optional_assign_base const&) = default;
+    optional_assign_base(optional_assign_base&&) = default;
+    ~optional_assign_base() = default;
+
+    // No copy
+    bsoncxx_cxx14_constexpr optional_assign_base& operator=(const optional_assign_base&) = delete;
+    // Allow move-assign:
+    bsoncxx_cxx14_constexpr optional_assign_base& operator=(optional_assign_base&& other) = default;
+};
+
+template <typename T>
+struct optional_assign_base<T, immobile> : optional_construct_base<T> {
+    optional_assign_base() = default;
+    optional_assign_base(optional_assign_base const&) = default;
+    optional_assign_base(optional_assign_base&&) = default;
+    ~optional_assign_base() = default;
+
+    // No assignment at all
+    optional_assign_base& operator=(const optional_assign_base&) = delete;
+    optional_assign_base& operator=(optional_assign_base&&) = delete;
+};
+
+template <typename T>
+struct optional_construct_base<T, copyable> : optional_destruct_base<T> {};
+
+template <typename T>
+struct optional_construct_base<T, movable> : optional_destruct_base<T> {
+    optional_construct_base() = default;
+
+    optional_construct_base(const optional_construct_base&) = delete;
+    optional_construct_base(optional_construct_base&& other) = default;
+    optional_construct_base& operator=(const optional_construct_base&) = default;
+    optional_construct_base& operator=(optional_construct_base&&) = default;
+};
+
+template <typename T>
+struct optional_construct_base<T, immobile> : optional_destruct_base<T> {
+    optional_construct_base() = default;
+    optional_construct_base(const optional_construct_base&) = delete;
+    optional_construct_base& operator=(const optional_construct_base&) = default;
+    optional_construct_base& operator=(optional_construct_base&&) = default;
+};
+
+template <>
+struct optional_destruct_helper<false /* Non-trivial */> {
+    template <typename T>
+    struct base : optional_common_base<T> {
+        // Special members defer to base
+        base() = default;
+        base(base const&) = default;
+        base(base&&) = default;
+        base& operator=(const base&) = default;
+        base& operator=(base&&) = default;
+        ~base() {
+            // Here we destroy the contained object during destruction.
+            this->reset();
+        }
+    };
+};
+
+template <>
+struct optional_destruct_helper<true /* Trivial */> {
+    // Just fall-through to the common base, which has no special destructor
+    template <typename T>
+    using base = optional_common_base<T>;
+};
+
+// Optional's ADL-only operators live here:
+struct optional_operators_base {
+    template <typename T, typename U>
+    friend bsoncxx_cxx14_constexpr auto tag_invoke(bsoncxx::detail::equal_to,
+                                                   optional<T> const& left,
+                                                   optional<U> const& right) noexcept
+        -> bsoncxx::detail::requires_t<bool, bsoncxx::detail::is_equality_comparable<T, U>> {
+        if (left.has_value() != right.has_value()) {
+            return false;
+        }
+        return !left.has_value() || *left == *right;
+    }
+
+    template <typename T, typename U>
+    friend constexpr auto tag_invoke(bsoncxx::detail::equal_to,
+                                     optional<T> const& left,
+                                     U const& right) noexcept -> bsoncxx::detail::
+        requires_t<bool, not_an_optional<U>, bsoncxx::detail::is_equality_comparable<T, U>> {
+        return left.has_value() && *left == right;
+    }
+
+    template <typename T>
+    friend constexpr bool tag_invoke(bsoncxx::detail::equal_to,
+                                     optional<T> const& opt,
+                                     nullopt_t) noexcept {
+        return !opt.has_value();
+    }
+
+    template <typename T, typename U>
+    bsoncxx_cxx14_constexpr friend auto tag_invoke(bsoncxx::detail::compare_three_way compare,
+                                                   optional<T> const& left,
+                                                   optional<U> const& right)
+        -> bsoncxx::detail::requires_t<bsoncxx::detail::strong_ordering,
+                                       bsoncxx::detail::is_totally_ordered_with<T, U>> {
+        if (left.has_value()) {
+            if (right.has_value()) {
+                return compare(*left, *right);
+            } else {
+                // non-null is greater than any null
+                return bsoncxx::detail::strong_ordering::greater;
+            }
+        } else {
+            if (right.has_value()) {
+                // Null is less than any non-null
+                return bsoncxx::detail::strong_ordering::less;
+            } else {
+                // Both are null
+                return bsoncxx::detail::strong_ordering::equal;
+            }
+        }
+    }
+
+    template <typename T, typename U>
+    bsoncxx_cxx14_constexpr friend auto tag_invoke(bsoncxx::detail::compare_three_way compare,
+                                                   optional<T> const& left,
+                                                   U const& right)
+        -> bsoncxx::detail::requires_t<bsoncxx::detail::strong_ordering,
+                                       not_an_optional<U>,
+                                       bsoncxx::detail::is_totally_ordered_with<T, U>> {
+        if (left.has_value()) {
+            return compare(*left, right);
+        }
+        // null optional is less-than any non-null value
+        return bsoncxx::detail::strong_ordering::less;
+    }
+
+    template <typename T>
+    constexpr friend bsoncxx::detail::strong_ordering tag_invoke(
+        bsoncxx::detail::compare_three_way compare, optional<T> const& left, nullopt_t) {
+        return compare(left.has_value(), false);
+    }
+};
+
+// An ADL-visible swap() should only be available for swappable objects
+template <typename T, bool IsSwappable = bsoncxx::detail::is_swappable<T>::value>
+struct optional_swap_mixin {};
+
+template <typename T>
+struct optional_swap_mixin<T, true> {
+    bsoncxx_cxx14_constexpr friend void swap(optional<T>& left, optional<T>& right) noexcept(
+        std::is_nothrow_move_constructible<T>::value&&
+            bsoncxx::detail::is_nothrow_swappable<T>::value) {
+        left.swap(right);
+    }
+};
+
+// Common base class of all optionals
+template <typename T>
+class optional_common_base : optional_operators_base, optional_swap_mixin<T> {
+    using storage_type = detail::storage_for<bsoncxx::detail::remove_const_t<T>>;
+
+   public:
+    optional_common_base() = default;
+    ~optional_common_base() = default;
+
+    optional_common_base(const optional_common_base& other) noexcept(
+        std::is_nothrow_copy_constructible<T>::value) {
+        if (other._has_value) {
+            this->emplace(other._storage.value);
+        }
+    }
+
+    optional_common_base(optional_common_base&& other) noexcept(
+        std::is_nothrow_move_constructible<T>::value) {
+        if (other._has_value) {
+            this->_emplace_construct_anew(std::move(other)._storage.value);
+        }
+    }
+
+    optional_common_base& operator=(const optional_common_base& other) noexcept(
+        std::is_nothrow_copy_assignable<T>::value) {
+        this->_assign(BSONCXX_FWD(other));
+        return *this;
+    }
+
+    optional_common_base& operator=(optional_common_base&& other) noexcept(
+        std::is_nothrow_move_assignable<T>::value) {
+        this->_assign(BSONCXX_FWD(other));
+        return *this;
+    }
+
+    /**
+     * @internal
+     * @brief If the optional is holding a value, destroy that value and set ourselves null
+     */
+    void reset() noexcept {
+        if (this->_has_value) {
+            this->_storage.value.~T();
+        }
+        this->_has_value = false;
+    }
+
+    /**
+     * @internal
+     * @brief If the optional is holding a value, destroy that value. Construct
+     * a new value in-place using the given arguments.
+     */
+    template <typename... Args>
+    T& emplace(Args&&... args) {
+        this->reset();
+        this->_emplace_construct_anew(BSONCXX_FWD(args)...);
+        return this->_storage.value;
+    }
+
+    /**
+     * @internal
+     * @brief If the optional is holding a value, destroy that value. Construct
+     * a new value in-place using the given arguments.
+     */
+    template <typename U, typename... Args>
+    T& emplace(std::initializer_list<U> il, Args&&... args) {
+        this->reset();
+        this->_emplace_construct_anew(il, BSONCXX_FWD(args)...);
+        return this->_storage.value;
+    }
+
+    /**
+     * @internal
+     * @brief Special swap for optional values that removes need for a temporary
+     */
+    bsoncxx_cxx14_constexpr void swap(optional_common_base& other) noexcept(
+        std::is_nothrow_move_constructible<T>::value&&
+            bsoncxx::detail::is_nothrow_swappable<T>::value) {
+        if (other._has_value) {
+            if (this->_has_value) {
+                using std::swap;
+                // Defer to the underlying swap
+                swap(this->_storage.value, other._storage.value);
+            } else {
+                // "steal" the other's value
+                this->emplace(std::move(other._storage.value));
+                other.reset();
+            }
+        } else if (this->_has_value) {
+            other.emplace(std::move(this->_storage.value));
+            this->reset();
+        } else {
+            // Neither optional has a value, so do nothing
+        }
+    }
+
+   private:
+    friend optional<T>;
+    storage_type _storage;
+    bool _has_value = false;
+
+    /**
+     * @internal
+     * @brief In-place construct a new value from the given arguments. Assumes
+     * that the optional does not have a live value.
+     */
+    template <typename... Args>
+    void _emplace_construct_anew(Args&&... args) noexcept(
+        std::is_nothrow_constructible<T, Args&&...>::value) {
+        new (std::addressof(this->_storage.value)) T(BSONCXX_FWD(args)...);
+        this->_has_value = true;
+    }
+
+    /**
+     * @internal
+     * @brief Perform the semantics of the assignment operator.
+     */
+    template <typename U>
+    void _assign(U&& other_storage) {
+        if (other_storage._has_value) {
+            // We are receiving a value
+            if (this->_has_value) {
+                // We already have a value. Invoke the underlying assignment.
+                this->_storage.value = BSONCXX_FWD(other_storage)._storage.value;
+            } else {
+                // We don't have a value. Use the constructor.
+                this->_emplace_construct_anew(BSONCXX_FWD(other_storage)._storage.value);
+            }
+        } else {
+            // We are receiving nullopt. Destroy our value, if present:
+            this->reset();
+        }
+    }
+};
+
+template <typename T>
+struct optional_base_class {
+    using type = optional_assign_base<T>;
+};
+
+template <typename T,
+          bool CanHash =
+              std::is_default_constructible<std::hash<bsoncxx::detail::remove_const_t<T>>>::value>
+struct optional_hash;
+
+// Hash is "disabled" if the underlying type is not hashable (disabled = cannot construct the hash
+// invocable)
+template <typename T>
+struct optional_hash<T, false> {
+    optional_hash() = delete;
+    optional_hash(const optional_hash&) = delete;
+};
+
+template <typename T>
+struct optional_hash<T, true> {
+    using Td = bsoncxx::detail::remove_const_t<T>;
+    constexpr std::size_t operator()(const optional<T>& opt) const
+        noexcept(noexcept(std::hash<Td>()(std::declval<Td const&>()))) {
+        return opt.has_value() ? std::hash<Td>()(*opt)  //
+                               : std::hash<void*>()(nullptr);
+    }
+};
+
+}  // namespace detail
 
 }  // namespace stdx
+
 }  // namespace v_noabi
+
 }  // namespace bsoncxx
 
-#else
-#error "Cannot find a valid polyfill for optional"
-#endif
+namespace std {
+
+template <typename T>
+struct hash<bsoncxx::v_noabi::stdx::optional<T>>
+    : bsoncxx::v_noabi::stdx::detail::optional_hash<T> {};
+
+}  // namespace std
 
 #include <bsoncxx/config/postlude.hpp>
 
 namespace bsoncxx {
 namespace stdx {
 
+using ::bsoncxx::v_noabi::stdx::in_place;
+using ::bsoncxx::v_noabi::stdx::in_place_t;
 using ::bsoncxx::v_noabi::stdx::make_optional;
 using ::bsoncxx::v_noabi::stdx::nullopt;
 using ::bsoncxx::v_noabi::stdx::nullopt_t;
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
index 8c1f7a9e7a..a075d25fbe 100644
--- a/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/stdx/type_traits.hpp
+++ b/src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/stdx/type_traits.hpp
@@ -15,6 +15,7 @@
 #pragma once
 
 #include <type_traits>
+#include <utility>
 
 #include <bsoncxx/config/prelude.hpp>
 
@@ -316,7 +317,7 @@ using true_t = std::true_type;
 namespace impl_requires {
 
 template <typename R>
-R norm_conjunction(...);
+R norm_conjunction(const R&);
 
 template <typename R, typename... Cs>
 conjunction<Cs...> norm_conjunction(const conjunction<Cs...>&);
@@ -473,6 +474,47 @@ struct rank : rank<N - 1> {};
 template <>
 struct rank<0> {};
 
+namespace swap_detection {
+
+using std::swap;
+
+///! Declare an unusable variadic swap. If not present, MSVC 19.00 (VS2015) errors in
+///! this header and complains "'std::swap': function does not take 1 arguments" (???)
+void swap(...) = delete;
+
+template <typename T, typename U>
+auto is_swappable_f(rank<0>) -> std::false_type;
+
+template <typename T, typename U>
+auto is_swappable_f(rank<1>)                                       //
+    noexcept(noexcept(swap(std::declval<T>(), std::declval<U>()))  //
+             && noexcept(swap(std::declval<U>(), std::declval<T>())))
+        -> true_t<decltype(swap(std::declval<T>(), std::declval<U>())),
+                  decltype(swap(std::declval<U>(), std::declval<T>()))>;
+
+template <typename T, typename U>
+auto is_nothrow_swappable_f(rank<0>) -> std::false_type;
+
+template <typename T, typename U>
+auto is_nothrow_swappable_f(rank<1>)  //
+    -> bool_constant<noexcept(swap(std::declval<T>(), std::declval<U>())) &&
+                     noexcept(swap(std::declval<U>(), std::declval<T>()))>;
+
+}  // namespace swap_detection
+
+template <typename T, typename U>
+struct is_swappable_with : decltype(swap_detection::is_swappable_f<T, U>(rank<1>{})) {};
+
+template <typename T, typename U>
+struct is_nothrow_swappable_with
+    : decltype(swap_detection::is_nothrow_swappable_f<T, U>(rank<1>{})) {};
+
+template <typename T>
+struct is_swappable : is_swappable_with<T&, T&> {};
+
+template <typename T>
+struct is_nothrow_swappable : is_nothrow_swappable_with<T&, T&> {};
+
 }  // namespace detail
 }  // namespace bsoncxx
 
diff --git a/src/bsoncxx/test/CMakeLists.txt b/src/bsoncxx/test/CMakeLists.txt
index 34d77778e5..b980f72567 100644
--- a/src/bsoncxx/test/CMakeLists.txt
+++ b/src/bsoncxx/test/CMakeLists.txt
@@ -36,6 +36,7 @@ add_executable(test_bson
     bson_value.cpp
     json.cpp
     oid.cpp
+    optional.test.cpp
     view_or_value.cpp
     make_unique.test.cpp
     string_view.test.cpp
@@ -93,7 +94,7 @@ if(ENABLE_MACRO_GUARD_TESTS)
             DEFINE_NO_DEPRECATED
             BSONCXX_NO_DEPRECATED
             BSONCXX_UNREACHABLE # prelude.hpp
-            _bsoncxxDisableWarningImpl_for_GCC
+            _bsoncxxDisableWarningImpl_for_GCC  # util.hpp
             _bsoncxxDisableWarningImpl_for_GNU
             _bsoncxxDisableWarningImpl_for_MSVC
             _bsoncxxDisableWarningImpl_for_Clang
@@ -104,6 +105,7 @@ if(ENABLE_MACRO_GUARD_TESTS)
             BSONCXX_CONCAT_IMPL
             bsoncxx_cxx14_constexpr
             BSONCXX_FORCE_SEMICOLON
+            BSONCXX_FWD
             BSONCXX_PRAGMA
             _bsoncxxPragma
             BSONCXX_STRINGIFY
@@ -138,6 +140,7 @@ set_dist_list(src_bsoncxx_test_DIST
     catch.hh
     json.cpp
     oid.cpp
+    optional.test.cpp
     test_macro_guards.cpp.in
     to_string.hh
     view_or_value.cpp
diff --git a/src/bsoncxx/test/catch.hh b/src/bsoncxx/test/catch.hh
index 948b9b511d..8f5e3421cf 100644
--- a/src/bsoncxx/test/catch.hh
+++ b/src/bsoncxx/test/catch.hh
@@ -94,6 +94,20 @@ struct StringMaker<stdx::optional<bsoncxx::stdx::nullopt_t>> {
         return "{nullopt}";
     }
 };
+
+template <>
+struct StringMaker<bsoncxx::detail::strong_ordering> {
+    static std::string convert(bsoncxx::detail::strong_ordering o) {
+        if (o < 0) {
+            return "[less-than]";
+        } else if (o > 0) {
+            return "[greater-than]";
+        } else {
+            return "[equal/equivalent]";
+        }
+    }
+};
+
 }  // namespace Catch
 
 #include <bsoncxx/config/private/postlude.hh>
diff --git a/src/bsoncxx/test/optional.test.cpp b/src/bsoncxx/test/optional.test.cpp
new file mode 100644
index 0000000000..bfa0c83cfa
--- /dev/null
+++ b/src/bsoncxx/test/optional.test.cpp
@@ -0,0 +1,621 @@
+#include <bsoncxx/stdx/optional.hpp>
+//
+#include <cstddef>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <type_traits>
+
+#include <bsoncxx/stdx/make_unique.hpp>
+#include <bsoncxx/stdx/operators.hpp>
+#include <bsoncxx/stdx/string_view.hpp>
+#include <bsoncxx/stdx/type_traits.hpp>
+#include <bsoncxx/test/catch.hh>
+
+using bsoncxx::stdx::in_place;
+using bsoncxx::stdx::nullopt;
+using bsoncxx::stdx::optional;
+
+#if defined(_MSC_VER) && _MSC_VER < 1910 || defined(__apple_build_version__)
+/// ! Prior to LWG 2543, uttering the name of an invalid std::hash is ill-formed.
+/// ! This is fixed in C++11, but MSVC 2015 (19.00) and old AppleClang libc++ don't
+/// !have the fix. As such, one cannot detect whether a type is hashable.
+#define NO_LWG_2543
+#endif
+
+namespace {
+
+template <typename T>
+using deref_t = decltype(*std::declval<T>());
+
+template <typename T>
+using value_t = decltype(std::declval<T>().value());
+
+template <typename T>
+using arrow_t = decltype(std::declval<T>().operator->());
+
+#ifndef NO_LWG_2543
+template <typename T, typename Td = bsoncxx::detail::remove_const_t<T>>
+struct is_hashable
+    : bsoncxx::detail::conjunction<std::is_default_constructible<std::hash<Td>>,
+                                   bsoncxx::detail::is_invocable<std::hash<Td>, const T&>> {};
+#else
+
+template <typename T>
+struct is_hashable : std::false_type {};
+#endif
+
+struct not_default_constructible {
+    explicit not_default_constructible(int);
+};
+
+struct allows_moving_explicit_conversion {
+    // Requires an rvalue-reference to an unalike type
+    explicit allows_moving_explicit_conversion(int&&) {}
+};
+
+struct allows_moving_implicit_conversion {
+    // Requires an rvalue-reference to an unalike type
+    allows_moving_implicit_conversion(int&&) {}
+};
+
+struct immobile {
+    std::mutex mtx;
+};
+
+struct not_ordered {};
+
+struct not_copyable {
+    not_copyable(not_copyable&&) = default;
+    not_copyable& operator=(not_copyable&&) = default;
+};
+
+template <bsoncxx_ttparam Trait, typename T>
+bool assert_sameness() {
+    static_assert(Trait<T>::value == Trait<optional<T>>::value, "Fail");
+    return true;
+}
+
+template <typename From1, typename To1, typename From2, typename To2>
+bool check_convert_alike() {
+    static_assert(std::is_convertible<From1, To1>::value  //
+                      == std::is_convertible<From2, To2>::value,
+                  "fail");
+    static_assert(std::is_convertible<From1&, To1>::value  //
+                      == std::is_convertible<From2&, To2>::value,
+                  "fail");
+    static_assert(std::is_convertible<From1 const&, To1>::value  //
+                      == std::is_convertible<From2 const&, To2>::value,
+                  "fail");
+    static_assert(std::is_convertible<From1&&, To1>::value  //
+                      == std::is_convertible<From2&&, To2>::value,
+                  "fail");
+    static_assert(std::is_convertible<From1 const&&, To1>::value  //
+                      == std::is_convertible<From2 const&&, To2>::value,
+                  "fail");
+    return true;
+}
+
+template <typename From1, typename To1, typename From2, typename To2>
+bool check_construct_alike() {
+    static_assert(std::is_constructible<To1, From1>::value  //
+                      == std::is_constructible<To2, From2>::value,
+                  "fail");
+    static_assert(std::is_constructible<To1, From1&>::value  //
+                      == std::is_constructible<To2, From2&>::value,
+                  "fail");
+    static_assert(std::is_constructible<To1, From1 const&>::value  //
+                      == std::is_constructible<To2, From2 const&>::value,
+                  "fail");
+    static_assert(std::is_constructible<To1, From1&&>::value  //
+                      == std::is_constructible<To2, From2&&>::value,
+                  "fail");
+    static_assert(std::is_constructible<To1, From1 const&&>::value  //
+                      == std::is_constructible<To2, From2 const&&>::value,
+                  "fail");
+    return true;
+}
+
+template <typename From, typename To>
+bool check_conversions() {
+    return check_convert_alike<From, To, optional<From>, optional<To>>() &&
+           check_convert_alike<From, To, From, optional<To>>() &&
+           check_construct_alike<From, To, optional<From>, optional<To>>() &&
+           check_construct_alike<From, To, From, optional<To>>();
+}
+
+template <typename T>
+bool static_checks() {
+    assert_sameness<std::is_copy_constructible, T>();
+    assert_sameness<std::is_copy_assignable, T>();
+    assert_sameness<std::is_move_constructible, T>();
+    assert_sameness<std::is_move_assignable, T>();
+    assert_sameness<is_hashable, T>();
+    assert_sameness<bsoncxx::detail::is_equality_comparable, T>();
+    assert_sameness<bsoncxx::detail::is_totally_ordered, T>();
+    assert_sameness<std::is_trivially_destructible, T>();
+    static_assert(bsoncxx::detail::is_equality_comparable<T, optional<T>>::value ==
+                      bsoncxx::detail::is_equality_comparable<T>::value,
+                  "fail");
+    static_assert(bsoncxx::detail::is_totally_ordered_with<T, optional<T>>::value ==
+                      bsoncxx::detail::is_totally_ordered<optional<T>>::value,
+                  "fail");
+    static_assert(
+        std::is_constructible<optional<T>, T>::value == std::is_constructible<T, T>::value, "fail");
+    static_assert(std::is_constructible<optional<T>, bsoncxx::stdx::nullopt_t>{}, "fail");
+    // Assert we return proper reference types
+    static_assert(std::is_same<deref_t<optional<T>>, T&&>{}, "fail");
+    static_assert(std::is_same<deref_t<optional<T> const>, const T&&>{}, "fail");
+    static_assert(std::is_same<deref_t<optional<T> const&>, const T&>{}, "fail");
+    static_assert(std::is_same<deref_t<optional<T>&>, T&>{}, "fail");
+    // .value()
+    static_assert(std::is_same<value_t<optional<T>>, T&&>{}, "fail");
+    static_assert(std::is_same<value_t<optional<T> const>, const T&&>{}, "fail");
+    static_assert(std::is_same<value_t<optional<T> const&>, const T&>{}, "fail");
+    static_assert(std::is_same<value_t<optional<T>&>, T&>{}, "fail");
+    // operator->
+    static_assert(std::is_same<arrow_t<optional<T>>, T*>{}, "fail");
+    static_assert(std::is_same<arrow_t<optional<T> const>, const T*>{}, "fail");
+    static_assert(std::is_same<arrow_t<optional<T> const&>, const T*>{}, "fail");
+    static_assert(std::is_same<arrow_t<optional<T>&>, T*>{}, "fail");
+    return check_conversions<T, T>();
+}
+
+}  // namespace
+
+static_assert(bsoncxx::detail::is_totally_ordered<std::string>{}, "fail");
+static_assert(bsoncxx::detail::is_totally_ordered<int>{}, "fail");
+static_assert(!bsoncxx::detail::is_totally_ordered<not_ordered>{}, "fail");
+
+#ifndef NO_LWG_2543
+static_assert(is_hashable<optional<int>>::value, "fail");
+static_assert(!is_hashable<optional<immobile>>::value, "fail");
+#endif
+
+// Having this static_assert appear prior to static_checks<int> prevents a later static assert error
+// that occurs only on MSVC 19.29 (VS2019). Obviously.
+static_assert(bsoncxx::detail::is_totally_ordered<optional<int>>{}, "fail");
+// It's a useful check on its own, but now you are cursed with this knowledge just as I have been.
+// pain.
+
+TEST_CASE("Trait checks") {
+    CHECK(static_checks<int>());
+    CHECK(static_checks<const int>());
+    CHECK(static_checks<std::string>());
+    CHECK(static_checks<const std::string>());
+    CHECK(static_checks<std::unique_ptr<int>>());
+    CHECK(static_checks<const std::unique_ptr<int>>());
+    CHECK(static_checks<immobile>());
+    CHECK(static_checks<const immobile>());
+    CHECK(static_checks<not_copyable>());
+    CHECK(static_checks<const not_copyable>());
+    CHECK(static_checks<not_default_constructible>());
+    CHECK(static_checks<const not_default_constructible>());
+    CHECK(static_checks<allows_moving_explicit_conversion>());
+    CHECK(static_checks<const allows_moving_explicit_conversion>());
+    CHECK(static_checks<allows_moving_implicit_conversion>());
+    CHECK(static_checks<const allows_moving_implicit_conversion>());
+    CHECK(check_conversions<int, int>());
+    CHECK(check_conversions<const int, int>());
+    CHECK(check_conversions<int, const int>());
+    CHECK(check_conversions<int, double>());
+    CHECK(check_conversions<double, std::string>());
+    CHECK(check_conversions<std::string, double>());
+    CHECK(check_conversions<std::string, const char*>());
+    CHECK(check_conversions<const char*, std::string>());
+    CHECK(check_conversions<int*, std::unique_ptr<int>>());
+    CHECK(check_conversions<int, allows_moving_explicit_conversion>());
+    CHECK(check_conversions<int, allows_moving_implicit_conversion>());
+}
+
+TEST_CASE("optional constructors") {
+    // (1)
+    {
+        optional<int> opt = optional<int>();
+        CHECK_FALSE(opt);
+
+        optional<int> opt2 = optional<int>(nullopt);
+        CHECK_FALSE(opt2);
+    }
+    // (2)
+    {
+        optional<int> opt1 = optional<int>();
+        optional<int> opt2 = optional<int>(opt1);
+        CHECK_FALSE(opt2);
+    }
+
+    // (3)
+    {
+        optional<int> opt1 = optional<int>(123);
+        optional<int> opt2 = optional<int>(std::move(opt1));
+        CHECK(*opt2 == 123);
+    }
+
+    // (4)
+    {
+        struct Src {
+            int s;
+        };
+        struct Dest {
+            // Can construct a Dest from Src.
+            Dest(Src s) {
+                this->d = s.s;
+            }
+            int d;
+        };
+
+        Src s;
+        s.s = 123;
+        optional<Src> opt_src = optional<Src>(s);
+        optional<Dest> opt_dest = opt_src;
+        CHECK(opt_dest->d == 123);
+    }
+
+    // (5)
+    {
+        struct Src {
+            int s;
+        };
+        struct Dest {
+            // Can construct a Dest from Src.
+            Dest(Src s) {
+                this->d = s.s;
+            }
+            int d;
+        };
+
+        Src s;
+        s.s = 123;
+        optional<Src> opt_src = optional<Src>(s);
+        optional<Dest> opt_dest = std::move(opt_src);
+        CHECK(opt_dest->d == 123);
+    }
+
+    // (6)
+    {
+        struct Foo {
+            Foo(int a, int b) {
+                this->c = a + b;
+            }
+            int c;
+        };
+        optional<Foo> opt = optional<Foo>(in_place, 1, 2);
+        CHECK(opt->c == 3);
+    }
+
+    // (7)
+    {
+        struct Foo {
+            Foo(std::initializer_list<int>) {}
+        };
+        std::initializer_list<int> il = {1, 2};
+        optional<Foo> opt = optional<Foo>(in_place, il);
+        (void)opt;
+    }
+
+    // (8)
+    {
+        struct Foo {
+            int f;
+        };
+        Foo f{0};
+        optional<Foo> opt = optional<Foo>(std::move(f));
+        (void)opt;
+    }
+}
+
+TEST_CASE("optional assignment operator") {
+    // (1)
+    {
+        optional<int> foo;
+        optional<int>& ref = (foo = nullopt);
+        CHECK(!foo);
+        CHECK(!ref);
+    }
+
+    // (2)
+    {
+        optional<int> foo;
+        optional<int> other = 123;
+        optional<int>& ref = (foo = other);
+        CHECK(foo);
+        CHECK(*foo == 123);
+        CHECK(ref);
+        CHECK(*ref == 123);
+    }
+
+    // (3)
+    {
+        optional<int> foo;
+        optional<int> other = 123;
+        optional<int>& ref = (foo = std::move(other));
+        CHECK(foo);
+        CHECK(*foo == 123);
+        CHECK(ref);
+        CHECK(*ref == 123);
+    }
+
+    // (4)
+    {
+        optional<int> foo = 123;
+        CHECK(*foo == 123);
+    }
+
+    // (5)
+    {
+        struct Src {
+            int s;
+        };
+        struct Dest {
+            // Can construct a Dest from Src.
+            Dest(Src s) {
+                this->d = s.s;
+            }
+            int d;
+        };
+
+        Src s;
+        s.s = 123;
+        optional<Src> opt_src = optional<Src>(s);
+        optional<Dest> opt_dest = opt_src;
+        CHECK(opt_dest->d == 123);
+    }
+
+    // (6)
+    {
+        struct Src {};
+        struct Dest {
+            // Can construct a Dest from Src.
+            Dest(Src) {}
+        };
+
+        Src s;
+        optional<Src> opt_src = optional<Src>(s);
+        optional<Dest> opt_dest = std::move(opt_src);
+        (void)opt_dest;
+    }
+}
+
+TEST_CASE("optional operator->") {
+    struct Foo {
+        int x;
+    };
+    optional<Foo> opt = Foo();
+    opt->x = 123;
+    CHECK(opt->x == 123);
+}
+
+TEST_CASE("optional operator bool") {
+    struct Foo {
+        int x;
+    };
+    optional<Foo> opt = Foo();
+    CHECK(opt);
+    CHECK(opt.has_value());
+    opt = nullopt;
+    CHECK(!opt);
+    CHECK(!opt.has_value());
+}
+
+TEST_CASE("optional value()") {
+    optional<int> opt = 123;
+    CHECK(opt.value() == 123);
+}
+
+TEST_CASE("optional value_or()") {
+    struct Src {
+        Src(int x) : x(x) {}
+        int x;
+    };
+    struct Dest {
+        // Can construct a Dest from Src.
+        Dest(Src s) : x(s.x) {}
+        int x;
+    };
+
+    optional<Dest> opt = nullopt;
+    Dest d = opt.value_or(Src(123));
+    CHECK(d.x == 123);
+}
+
+TEST_CASE("optional reset()") {
+    optional<int> opt = 123;
+    opt.reset();
+    CHECK(!opt);
+}
+
+TEST_CASE("optional emplace()") {
+    optional<int> opt = 123;
+    opt.emplace(456);
+    CHECK(*opt == 456);
+}
+
+TEST_CASE("make_optional") {
+    auto opt = bsoncxx::stdx::make_optional(123);
+    CHECK(opt);
+    CHECK(*opt == 123);
+}
+
+TEST_CASE("optional swap") {
+    optional<int> opt1 = 123;
+    optional<int> opt2 = nullopt;
+    CHECK(opt1.has_value());
+    CHECK(!opt2.has_value());
+    opt1.swap(opt2);
+    CHECK(!opt1.has_value());
+    CHECK(opt2.has_value());
+}
+
+TEST_CASE("optional: Nontrivial contents") {
+    optional<std::string> str = "abcd1234";
+    CHECK(str == "abcd1234");
+    {
+        auto dup = str;
+        CHECK(dup == str);
+    }
+    CHECK(str == "abcd1234");
+
+    optional<std::unique_ptr<int>> aptr;
+    CHECK(aptr != nullptr);
+    CHECK(aptr == bsoncxx::stdx::nullopt);
+    {
+        auto dup = std::move(aptr);
+        CHECK(aptr == dup);
+    }
+    aptr = bsoncxx::stdx::make_unique<int>(31);
+    CHECK(aptr != nullopt);
+    REQUIRE(aptr != nullptr);
+    CHECK(**aptr == 31);
+    {
+        auto dup = std::move(aptr);
+        CHECK(aptr);
+        CHECK(aptr == nullptr);
+        REQUIRE(dup);
+        REQUIRE(dup != nullptr);
+        CHECK(**dup == 31);
+    }
+    CHECK(aptr == nullptr);
+}
+
+TEST_CASE("Comparisons") {
+    optional<int> a = 21;
+    optional<int> b = 23;
+    optional<int> c;
+    CHECK(a != nullopt);
+    CHECK(a == 21);
+    CHECK(b != nullopt);
+    CHECK(b == 23);
+    CHECK(c == nullopt);
+    // Null compares less-than values:
+    CHECK(c < 42);
+    CHECK(a < b);
+    CHECK(c < a);
+    CHECK(c < b);
+    CHECK(c == nullopt);
+    CHECK(nullopt < a);
+    CHECK(nullopt == c);
+    CHECK(a != b);
+    CHECK(c != a);
+    CHECK(c != b);
+    CHECK(c == c);
+
+    optional<double> dbl = 3.14;
+    CHECK(dbl != a);
+}
+
+template <typename T, typename U>
+void check_ordered(T const& lesser, U const& greater, std::string desc) {
+    CAPTURE(__func__, desc);
+    CHECK(lesser < greater);
+    CHECK(greater > lesser);
+    CHECK(lesser <= greater);
+    CHECK(greater >= lesser);
+    CHECK_FALSE(greater < lesser);
+    CHECK_FALSE(lesser > greater);
+    CHECK(lesser != greater);
+    CHECK_FALSE(lesser == greater);
+}
+
+template <typename T, typename U>
+void check_equivalent(T const& a, U const& b, std::string desc) {
+    CAPTURE(__func__, desc);
+    CHECK(a == b);
+    CHECK(b == a);
+    CHECK_FALSE(a != b);
+    CHECK_FALSE(b != a);
+    CHECK(a <= b);
+    CHECK(b >= a);
+    CHECK_FALSE(a < b);
+    CHECK_FALSE(b > a);
+    CHECK_FALSE(b < a);
+    CHECK_FALSE(a > b);
+}
+
+template <typename T, typename U>
+void regular_cases(T low_value, U high_value) {
+    optional<T> a, b;
+    check_equivalent(a, b, "Null optionals");
+    check_equivalent(a, nullopt, "Compare with nullopt");
+    a = low_value;
+    check_equivalent(a, a, "Self-compare");
+    check_equivalent(a, low_value, "Engaged == value");
+    check_ordered(a, high_value, "low enganged < high value");
+    check_ordered(b, a, "Value > null optional");
+    check_ordered(nullopt, a, "Value > nullopt");
+    using std::swap;
+    swap(a, b);
+    check_equivalent(b, low_value, "low-value after swap");
+    check_ordered(b, high_value, "High-value compare after swap");
+    check_ordered(a, b, "Optional compare after swap");
+    swap(a, b);
+    b.emplace(high_value);
+    check_ordered(a, b, "Engaged compare");
+    swap(a, b);
+    check_ordered(b, a, "Engaged compare after swap");
+    swap(a, b);
+
+    a = b;
+    check_equivalent(a, b, "Equal after assignment");
+    check_equivalent(a, high_value, "'a' received high value");
+    check_ordered(low_value, a, "'a' is greater than high-value after assignment");
+}
+
+TEST_CASE("Optional: Cross-comparisons") {
+    regular_cases<int>(2, 4);
+    regular_cases<double>(2, 4.0);
+    regular_cases(std::string("abc"), std::string("xyz"));
+    regular_cases(std::string("abc"), "xyz");
+    regular_cases(std::string("abc"), bsoncxx::stdx::string_view("xyz"));
+    regular_cases(bsoncxx::stdx::string_view("abc"), std::string("xyz"));
+}
+
+template <typename T>
+std::size_t hashit(const T& what) {
+    return std::hash<T>{}(what);
+}
+
+TEST_CASE("Optional-of-const-T") {
+    optional<const int> a;
+    check_equivalent(a, nullopt, "Null of const");
+    a.emplace(21);
+    check_equivalent(a, 21, "Const 21");
+    CHECK(hashit(a) == hashit(21));
+    auto b = a;
+    CHECK(a == b);
+}
+
+TEST_CASE("Optional: Hashing") {
+    optional<int> a, b;
+    CHECK(hashit(a) == hashit(a));
+    CHECK(hashit(a) == hashit(b));
+    b.emplace(41);
+    CHECK(hashit(41) == hashit(b));
+    CHECK(hashit(a) != hashit(b));  // (Extremely probable, but not certain)
+    a.emplace(41);
+    CHECK(hashit(a) == hashit(b));
+    optional<const int> c = b;
+    CHECK(hashit(c) == hashit(a));
+}
+
+struct in_place_convertible {
+    bool constructed_from_in_place = false;
+    in_place_convertible() = default;
+    in_place_convertible(bsoncxx::stdx::in_place_t) : constructed_from_in_place(true) {}
+};
+
+TEST_CASE("optional<T> conversions") {
+    static_assert(!std::is_constructible<optional<bool>, optional<std::string>>{}, "fail");
+
+    optional<std::string> s1(bsoncxx::stdx::in_place);
+    CHECK(s1 == "");
+
+    optional<in_place_convertible> q(bsoncxx::stdx::in_place);
+    REQUIRE(q.has_value());
+    CHECK_FALSE(q->constructed_from_in_place);
+
+    optional<const char*> c_str = "foo";
+    optional<std::string> string = c_str;
+    optional<std::string> string2 = std::move(c_str);
+    CHECK(string == c_str);
+    CHECK(string2 == c_str);
+}
diff --git a/src/mongocxx/lib/mongocxx/v_noabi/mongocxx/private/libbson.cpp b/src/mongocxx/lib/mongocxx/v_noabi/mongocxx/private/libbson.cpp
index 064b33bdde..46e2175b0c 100644
--- a/src/mongocxx/lib/mongocxx/v_noabi/mongocxx/private/libbson.cpp
+++ b/src/mongocxx/lib/mongocxx/v_noabi/mongocxx/private/libbson.cpp
@@ -31,23 +31,7 @@ void doc_to_bson_t(const bsoncxx::v_noabi::document::view& doc, bson_t* bson) {
 
 }  // namespace
 
-#if !defined(BSONCXX_POLY_USE_STD)
-
-scoped_bson_t::scoped_bson_t(bsoncxx::v_noabi::document::view_or_value doc)
-    : _is_initialized{true}, _doc{std::move(doc)} {
-    doc_to_bson_t(*_doc, &_bson);
-}
-
-void scoped_bson_t::init_from_static(bsoncxx::v_noabi::document::view_or_value doc) {
-    _is_initialized = true;
-    _doc = std::move(doc);
-    doc_to_bson_t(*_doc, &_bson);
-}
-
-#endif
-
-scoped_bson_t::scoped_bson_t(
-    bsoncxx::v_noabi::stdx::optional<bsoncxx::v_noabi::document::view_or_value> doc)
+scoped_bson_t::scoped_bson_t(bsoncxx::stdx::optional<bsoncxx::document::view_or_value> doc)
     : _is_initialized{doc} {
     if (doc) {
         _doc = std::move(doc);
diff --git a/src/mongocxx/lib/mongocxx/v_noabi/mongocxx/private/libbson.hh b/src/mongocxx/lib/mongocxx/v_noabi/mongocxx/private/libbson.hh
index e07ecd21a7..288c1e0d8e 100644
--- a/src/mongocxx/lib/mongocxx/v_noabi/mongocxx/private/libbson.hh
+++ b/src/mongocxx/lib/mongocxx/v_noabi/mongocxx/private/libbson.hh
@@ -52,24 +52,6 @@ class MONGOCXX_TEST_API scoped_bson_t {
     //
     scoped_bson_t();
 
-// In C++17 mode, we don't need these overloads - they end up being ambiguous. The C++17 optional
-// can deal with out it.
-#if !defined(BSONCXX_POLY_USE_STD)
-    //
-    // Constructs a new scoped_bson_t from a document view_or_value.
-    //
-    // The internal bson_t is considered initialized.
-    //
-    explicit scoped_bson_t(bsoncxx::v_noabi::document::view_or_value doc);
-
-    //
-    // Initializes a bson_t from the provided document.
-    //
-    // The internal bson_t is considered initialized.
-    //
-    void init_from_static(bsoncxx::v_noabi::document::view_or_value doc);
-#endif
-
     //
     // Constructs a new scoped_bson_t from an optional document view_or_value.
     //