diff --git a/libc/src/__support/CPP/optional.h b/libc/src/__support/CPP/optional.h
--- a/libc/src/__support/CPP/optional.h
+++ b/libc/src/__support/CPP/optional.h
@@ -32,41 +32,105 @@
 // in_place that can be used in the constructor.
 LIBC_INLINE_VAR constexpr in_place_t in_place{};
 
-// This is very simple implementation of the std::optional class. It makes
-// several assumptions that the underlying type is trivially constructable,
-// copyable, or movable.
-template <typename T> class optional {
-  template <typename U> class OptionalStorage {
+template <typename T> struct OptionalStorageBase {
+  template <typename U, bool = is_trivially_destructible<U>::value>
+  struct OptionalStorage {
     union {
       char empty;
       U stored_value;
     };
-    bool in_use;
 
-  public:
-    LIBC_INLINE ~OptionalStorage() { reset(); }
+    LIBC_INLINE constexpr OptionalStorage() : empty() {}
+    template <typename... Args>
+    LIBC_INLINE constexpr explicit OptionalStorage(in_place_t, Args &&...args)
+        : stored_value(forward<Args>(args)...) {}
+  };
 
-    LIBC_INLINE constexpr OptionalStorage() : empty(), in_use(false) {}
+  template <typename U> struct OptionalStorage<U, false> {
+    union {
+      char empty;
+      U stored_value;
+    };
 
+    LIBC_INLINE constexpr OptionalStorage() : empty() {}
     template <typename... Args>
     LIBC_INLINE constexpr explicit OptionalStorage(in_place_t, Args &&...args)
-        : stored_value(forward<Args>(args)...), in_use(true) {}
+        : stored_value(forward<Args>(args)...) {}
 
-    LIBC_INLINE void reset() {
-      if (in_use)
-        stored_value.~U();
-      in_use = false;
-    }
+    LIBC_INLINE ~OptionalStorage() {}
+  };
 
-    LIBC_INLINE constexpr bool has_value() const { return in_use; }
+  using stored_type = remove_const_t<T>;
+  OptionalStorage<stored_type> storage;
+  bool in_use = false;
 
-    LIBC_INLINE U &value() & { return stored_value; }
-    LIBC_INLINE constexpr U const &value() const & { return stored_value; }
-    LIBC_INLINE U &&value() && { return move(stored_value); }
-  };
+public:
+  LIBC_INLINE ~OptionalStorageBase() = default;
+  LIBC_INLINE constexpr OptionalStorageBase() = default;
 
+  template <typename... ArgTypes>
+  LIBC_INLINE constexpr OptionalStorageBase(in_place_t, ArgTypes &&...Args)
+      : storage(in_place, forward<ArgTypes>(Args)...), in_use(true) {}
+
+  LIBC_INLINE constexpr void reset() {
+    if (in_use)
+      storage.stored_value.~stored_type();
+    in_use = false;
+  }
+
+  LIBC_INLINE constexpr bool has_value() const { return in_use; }
+
+  LIBC_INLINE constexpr T &value() & { return this->storage.stored_value; }
+  LIBC_INLINE constexpr T const &value() const & {
+    return this->storage.stored_value;
+  }
+  LIBC_INLINE constexpr T &&value() && {
+    return move(this->storage.stored_value);
+  }
+};
+
+// Class template that manages the storage for optionals.
+template <typename T,
+          bool /*_HasTrivialDestructor*/ = is_trivially_destructible_v<T>>
+struct OptionalStorage : OptionalStorageBase<T> {
+  using OptionalStorageBase<T>::OptionalStorageBase;
+  LIBC_INLINE constexpr OptionalStorage() = default;
+};
+
+// storage for optionals with non-trivial destructors.
+template <typename T>
+struct OptionalStorage<T, false> : OptionalStorageBase<T> {
+  using OptionalStorageBase<T>::OptionalStorageBase;
+  LIBC_INLINE constexpr OptionalStorage() = default;
+  LIBC_INLINE constexpr OptionalStorage(const OptionalStorage &) = default;
+  LIBC_INLINE constexpr OptionalStorage(OptionalStorage &&) = default;
+  LIBC_INLINE constexpr OptionalStorage &
+  operator=(const OptionalStorage &) = default;
+  LIBC_INLINE constexpr OptionalStorage &
+  operator=(OptionalStorage &&) = default;
+
+  // Destructor needs to destroy the contained value:
+  LIBC_INLINE ~OptionalStorage() { this->reset(); }
+};
+
+// This is very simple implementation of the std::optional class. It makes
+// several assumptions that the underlying type is trivially copyable, or
+// movable.
+template <typename T> class optional {
   OptionalStorage<T> storage;
 
+  static_assert(!is_same_v<remove_cv_t<T>, nullopt_t>);
+  static_assert(!is_same_v<remove_cv_t<T>, in_place_t>);
+  static_assert(!is_reference_v<T>);
+
+  // SFINAE helpers
+  template <typename T2>
+  using __not_self = __not_<is_same<optional, remove_cvref_t<T2>>>;
+  template <typename T2>
+  using __not_tag = __not_<is_same<in_place_t, remove_cvref_t<T2>>>;
+  template <typename... _Cond>
+  using _Requires = enable_if_t<__and_<_Cond...>::value, bool>;
+
 public:
   LIBC_INLINE constexpr optional() = default;
   LIBC_INLINE constexpr optional(nullopt_t) {}
@@ -77,44 +141,48 @@
   LIBC_INLINE constexpr optional(T &&t) : storage(in_place, move(t)) {}
   LIBC_INLINE constexpr optional(optional &&O) = default;
 
-  template <typename... ArgTypes>
+  // Constructors for engaged optionals.
+  template <typename... ArgTypes,
+            enable_if_t<is_constructible_v<T, ArgTypes...>, bool> = false>
   LIBC_INLINE constexpr optional(in_place_t, ArgTypes &&...Args)
       : storage(in_place, forward<ArgTypes>(Args)...) {}
 
-  LIBC_INLINE optional &operator=(T &&t) {
-    storage = move(t);
+  template <typename T2 = T,
+            _Requires<__not_self<T2>, __not_tag<T2>, is_constructible<T, T2>,
+                      is_convertible<T2, T>> = true>
+  LIBC_INLINE constexpr optional(T2 &&t) : optional(in_place, forward<T2>(t)) {}
+
+  // Assignment operators.
+  LIBC_INLINE constexpr optional &operator=(nullopt_t) {
+    reset();
     return *this;
   }
-  LIBC_INLINE optional &operator=(optional &&) = default;
-
-  LIBC_INLINE static constexpr optional create(const T *t) {
-    return t ? optional(*t) : optional();
+  LIBC_INLINE constexpr optional &operator=(T &&t) {
+    storage = move(t);
+    return *this;
   }
+  LIBC_INLINE constexpr optional &operator=(optional &&) = default;
 
-  LIBC_INLINE optional &operator=(const T &t) {
+  LIBC_INLINE constexpr optional &operator=(const T &t) {
     storage = t;
     return *this;
   }
-  LIBC_INLINE optional &operator=(const optional &) = default;
+  LIBC_INLINE constexpr optional &operator=(const optional &) = default;
 
-  LIBC_INLINE void reset() { storage.reset(); }
+  LIBC_INLINE constexpr void reset() { storage.reset(); }
 
   LIBC_INLINE constexpr const T &value() const & { return storage.value(); }
-  LIBC_INLINE T &value() & { return storage.value(); }
+  LIBC_INLINE constexpr T &value() & { return storage.value(); }
 
   LIBC_INLINE constexpr explicit operator bool() const { return has_value(); }
   LIBC_INLINE constexpr bool has_value() const { return storage.has_value(); }
   LIBC_INLINE constexpr const T *operator->() const { return &storage.value(); }
-  LIBC_INLINE T *operator->() { return &storage.value(); }
+  LIBC_INLINE constexpr T *operator->() { return &storage.value(); }
   LIBC_INLINE constexpr const T &operator*() const & { return value(); }
-  LIBC_INLINE T &operator*() & { return value(); }
-
-  template <typename U> LIBC_INLINE constexpr T value_or(U &&value) const & {
-    return has_value() ? value() : forward<U>(value);
-  }
+  LIBC_INLINE constexpr T &operator*() & { return value(); }
 
-  LIBC_INLINE T &&value() && { return move(storage.value()); }
-  LIBC_INLINE T &&operator*() && { return move(storage.value()); }
+  LIBC_INLINE constexpr T &&value() && { return move(storage.value()); }
+  LIBC_INLINE constexpr T &&operator*() && { return move(storage.value()); }
 };
 
 } // namespace cpp
diff --git a/libc/src/__support/CPP/type_traits.h b/libc/src/__support/CPP/type_traits.h
--- a/libc/src/__support/CPP/type_traits.h
+++ b/libc/src/__support/CPP/type_traits.h
@@ -30,6 +30,8 @@
 using true_type = cpp::integral_constant<bool, true>;
 using false_type = cpp::integral_constant<bool, false>;
 
+template <bool V> using bool_constant = integral_constant<bool, V>;
+
 template <class T>
 struct is_trivially_copyable
     : public integral_constant<bool, __is_trivially_copyable(T)> {};
@@ -54,14 +56,16 @@
 template <typename T> struct remove_cv<const volatile T> : type_identity<T> {};
 template <typename T> using remove_cv_t = typename remove_cv<T>::type;
 
+template <typename T> struct remove_const : type_identity<T> {};
+template <typename T> struct remove_const<const T> : type_identity<T> {};
+template <typename T> using remove_const_t = typename remove_const<T>::type;
+
 template <typename T> struct remove_reference : type_identity<T> {};
 template <typename T> struct remove_reference<T &> : type_identity<T> {};
 template <typename T> struct remove_reference<T &&> : type_identity<T> {};
 template <typename T>
 using remove_reference_t = typename remove_reference<T>::type;
 
-template <typename T> struct add_rvalue_reference : type_identity<T &&> {};
-
 template <typename T> struct remove_cvref {
   using type = remove_cv_t<remove_reference_t<T>>;
 };
@@ -171,6 +175,22 @@
 template <bool B, typename T, typename F>
 using conditional_t = typename conditional<B, T, F>::type;
 
+template <typename...> struct __and_;
+
+template <> struct __and_<> : public true_type {};
+
+template <typename T1> struct __and_<T1> : public T1 {};
+
+template <typename T1, typename T2>
+struct __and_<T1, T2> : public conditional_t<T1::value, T2, T1> {};
+
+template <typename T1, typename T2, typename T3, typename... Tn>
+struct __and_<T1, T2, T3, Tn...>
+    : public conditional_t<T1::value, __and_<T2, T3, Tn...>, T1> {};
+
+template <typename T>
+struct __not_ : public integral_constant<bool, !T::value> {};
+
 template <typename T>
 struct is_void : is_same<void, typename remove_cv<T>::type> {};
 template <typename T>
@@ -194,6 +214,29 @@
                      details::void_t<decltype(details::convertible_to_helper<T>(
                          declval<F>()))>> = true;
 
+template <typename T, typename... Args>
+struct is_constructible
+    : public integral_constant<bool, __is_constructible(T, Args...)> {};
+
+template <typename T, typename... Args>
+inline constexpr bool is_constructible_v = __is_constructible(T, Args...);
+
+template <typename T1, typename T2>
+struct is_convertible
+    : public integral_constant<bool, __is_convertible(T1, T2)> {};
+
+template <typename T>
+struct is_trivially_destructible
+    : public integral_constant<bool, __is_trivially_destructible(T)> {};
+
+template <typename T>
+inline constexpr bool is_trivially_destructible_v =
+    is_trivially_destructible<T>::value;
+
+template <typename T> struct is_reference : bool_constant<__is_reference(T)> {};
+
+template <typename T> inline constexpr bool is_reference_v = __is_reference(T);
+
 } // namespace cpp
 } // namespace __llvm_libc
 
diff --git a/libc/src/__support/UInt.h b/libc/src/__support/UInt.h
--- a/libc/src/__support/UInt.h
+++ b/libc/src/__support/UInt.h
@@ -376,7 +376,7 @@
       return remainder;
     }
     if (other == 0) {
-      return nullopt;
+      return {};
     }
 
     BigInt<Bits, Signed> quotient(0);
diff --git a/libc/test/src/__support/CPP/optional_test.cpp b/libc/test/src/__support/CPP/optional_test.cpp
--- a/libc/test/src/__support/CPP/optional_test.cpp
+++ b/libc/test/src/__support/CPP/optional_test.cpp
@@ -43,14 +43,13 @@
   // For this test case, the destructor increments the pointed-to value.
   int holding = 1;
   optional<Contrived> Complicated(&holding);
-  // Destructor was run once as part of copying the object.
-  ASSERT_EQ(holding, 2);
-  // Destructor was run a second time as part of destruction.
+  ASSERT_EQ(holding, 1);
+  // Destructor was run once as part of destruction.
   Complicated.reset();
-  ASSERT_EQ(holding, 3);
-  // Destructor was not run a third time as the object is already destroyed.
+  ASSERT_EQ(holding, 2);
+  // Destructor was not run a second time as the object is already destroyed.
   Complicated.reset();
-  ASSERT_EQ(holding, 3);
+  ASSERT_EQ(holding, 2);
 
   // Test that assigning an optional to another works when set
   optional<int> Trivial3(12);