From f8e24c4c2d52ac06bd65382e755e0c9e1b2a93f5 Mon Sep 17 00:00:00 2001
From: Yong Gyu Lee <cosgenio@gmail.com>
Date: Mon, 17 Jun 2024 02:45:45 +0900
Subject: [PATCH] Update optional

---
 include/preview/__optional/hash.h             |  40 +-
 .../__optional/internal/check_overload.h      |  66 --
 .../__optional/internal/copy_assignment.h     |  51 --
 .../preview/__optional/internal/copy_ctor.h   |  43 --
 include/preview/__optional/internal/dtor.h    | 122 ----
 include/preview/__optional/internal/hash.h    |  32 -
 .../__optional/internal/move_assignment.h     |  53 --
 .../preview/__optional/internal/move_ctor.h   |  43 --
 include/preview/__optional/internal/traits.h  |  54 --
 include/preview/__optional/optional.h         | 599 ++++++++++++------
 include/preview/__optional/swap.h             |  14 +-
 11 files changed, 443 insertions(+), 674 deletions(-)
 delete mode 100644 include/preview/__optional/internal/check_overload.h
 delete mode 100644 include/preview/__optional/internal/copy_assignment.h
 delete mode 100644 include/preview/__optional/internal/copy_ctor.h
 delete mode 100644 include/preview/__optional/internal/dtor.h
 delete mode 100644 include/preview/__optional/internal/hash.h
 delete mode 100644 include/preview/__optional/internal/move_assignment.h
 delete mode 100644 include/preview/__optional/internal/move_ctor.h
 delete mode 100644 include/preview/__optional/internal/traits.h

diff --git a/include/preview/__optional/hash.h b/include/preview/__optional/hash.h
index 4339fb72..dbf68ecd 100644
--- a/include/preview/__optional/hash.h
+++ b/include/preview/__optional/hash.h
@@ -10,19 +10,47 @@
 # include <functional>
 # include <type_traits>
 #
-# include "preview/__optional/internal/hash.h"
 # include "preview/__optional/optional.h"
 
+namespace preview {
+namespace detail {
+
+template<typename Optional>
+struct optional_enabled_hash;
+
+template<typename T>
+struct optional_enabled_hash<optional<T>> {
+  std::size_t operator()(const optional<T>& key) const noexcept {
+    return key.has_value() ? std::hash<std::remove_const_t<T>>()(*key) : 0;
+  }
+};
+
+struct optional_disabled_hash {
+  optional_disabled_hash() = delete;
+};
+
+template<typename Optional>
+struct optional_hash;
+
+template<typename T>
+struct optional_hash<optional<T>>
+    : std::conditional_t<
+        std::is_default_constructible<std::hash<T>>::value,
+        optional_enabled_hash<optional<T>>,
+        optional_disabled_hash
+    > {};
+
+} // namespace detail
+} // namespace preview
+
 namespace std {
 
 template<typename T>
-struct hash<preview::optional<T>> : preview::internal::optional::hash_constructible<std::remove_const_t<T>> {
+struct hash<preview::optional<T>>
+    : preview::detail::optional_hash<preview::optional<T>>
+{
   using argument_type = preview::optional<T>;
   using result_type = std::size_t;
-
-  result_type operator()(const argument_type& key) const {
-    return key.has_value() ? ::std::hash<std::remove_const_t<T>>()(*key) : 0;
-  }
 };
 
 } // namespace std
diff --git a/include/preview/__optional/internal/check_overload.h b/include/preview/__optional/internal/check_overload.h
deleted file mode 100644
index 3ced7135..00000000
--- a/include/preview/__optional/internal/check_overload.h
+++ /dev/null
@@ -1,66 +0,0 @@
-# /*
-#  * Created by YongGyu Lee on 2021/05/30.
-#  */
-#
-#
-# ifndef PREVIEW_OPTIONAL_INTERNAL_CHECK_OVERLOAD_H_
-# define PREVIEW_OPTIONAL_INTERNAL_CHECK_OVERLOAD_H_
-#
-# include <type_traits>
-
-
-namespace preview {
-namespace internal {
-namespace optional {
-
-template<typename T, bool v = std::is_copy_constructible<T>::value>
-struct check_copy_constructible {};
-template<typename T>
-struct check_copy_constructible<T, false> {
-  check_copy_constructible() = default;
-  check_copy_constructible(check_copy_constructible const&) = delete;
-  check_copy_constructible(check_copy_constructible &&) = default;
-  check_copy_constructible& operator=(check_copy_constructible const&) = default;
-  check_copy_constructible& operator=(check_copy_constructible &&) = default;
-};
-
-template<typename T, bool v = std::is_move_constructible<T>::value>
-struct check_move_constructible {};
-template<typename T>
-struct check_move_constructible<T, false> {
-  check_move_constructible() = default;
-  check_move_constructible(check_move_constructible const&) = default;
-  check_move_constructible(check_move_constructible &&) = delete;
-  check_move_constructible& operator=(check_move_constructible const&) = default;
-  check_move_constructible& operator=(check_move_constructible &&) = default;
-};
-
-template<typename T, bool v = std::is_copy_constructible<T>::value && std::is_copy_assignable<T>::value>
-struct check_copy_assignable {};
-template<typename T>
-struct check_copy_assignable<T, false> {
-  check_copy_assignable() = default;
-  check_copy_assignable(check_copy_assignable const&) = default;
-  check_copy_assignable(check_copy_assignable &&) = default;
-  check_copy_assignable& operator=(check_copy_assignable const&) = delete;
-  check_copy_assignable& operator=(check_copy_assignable &&) = default;
-};
-
-template<typename T, bool v = std::is_move_constructible<T>::value && std::is_move_assignable<T>::value>
-struct check_move_assignable {};
-template<typename T>
-struct check_move_assignable<T, false> {
-  check_move_assignable() = default;
-  check_move_assignable(check_move_assignable const&) = default;
-  check_move_assignable(check_move_assignable &&) = default;
-  check_move_assignable& operator=(check_move_assignable const&) = default;
-  check_move_assignable& operator=(check_move_assignable &&) = delete;
-};
-
-
-
-} // namespace optional
-} // namespace internal
-} // namespace preview
-
-# endif // PREVIEW_OPTIONAL_INTERNAL_CHECK_OVERLOAD_H_
diff --git a/include/preview/__optional/internal/copy_assignment.h b/include/preview/__optional/internal/copy_assignment.h
deleted file mode 100644
index 6d71df9d..00000000
--- a/include/preview/__optional/internal/copy_assignment.h
+++ /dev/null
@@ -1,51 +0,0 @@
-# /*
-#  * Created by YongGyu Lee on 2021/05/24.
-#  */
-#
-# ifndef PREVIEW_OPTIONAL_INTERNAL_COPY_ASSIGNMENT_H_
-# define PREVIEW_OPTIONAL_INTERNAL_COPY_ASSIGNMENT_H_
-#
-# include <type_traits>
-#
-# include "preview/__optional/internal/move_ctor.h"
-
-namespace preview {
-namespace internal {
-namespace optional {
-
-template<typename T, bool v =
-  std::is_trivially_copy_constructible<T>::value &&
-  std::is_trivially_copy_assignable<T>::value &&
-  std::is_trivially_destructible<T>::value>
-struct copy_assign : move_ctor<T> {
-  using base = move_ctor<T>;
-  using base::base;
-};
-
-template<typename T>
-struct copy_assign<T, false> : move_ctor<T> {
-  using base = move_ctor<T>;
-  using base::base;
-
-  copy_assign() = default;
-  copy_assign(copy_assign const&) = default;
-  copy_assign(copy_assign &&) = default;
-  copy_assign& operator=(copy_assign const& other) {
-    if (!other.valid) {
-      this->reset();
-    } else {
-      if (this->valid)
-        this->val = other.val;
-      else
-        this->construct(other.val);
-    }
-    return *this;
-  }
-  copy_assign& operator=(copy_assign &&) = default;
-};
-
-} // namespace optional
-} // namespace internal
-} // namespace preview
-
-# endif // PREVIEW_OPTIONAL_INTERNAL_COPY_ASSIGNMENT_H_
diff --git a/include/preview/__optional/internal/copy_ctor.h b/include/preview/__optional/internal/copy_ctor.h
deleted file mode 100644
index 59cfa4aa..00000000
--- a/include/preview/__optional/internal/copy_ctor.h
+++ /dev/null
@@ -1,43 +0,0 @@
-# /*
-#  * Created by YongGyu Lee on 2021/05/24.
-#  */
-#
-# ifndef PREVIEW_OPTIONAL_INTERNAL_COPY_CTOR_H_
-# define PREVIEW_OPTIONAL_INTERNAL_COPY_CTOR_H_
-#
-# include <type_traits>
-#
-# include "preview/__optional/internal/dtor.h"
-
-namespace preview {
-namespace internal {
-namespace optional {
-
-template<typename T, bool v = std::is_trivially_copy_constructible<T>::value>
-struct copy_ctor : dtor<T> {
-  using base = dtor<T>;
-  using base::base;
-};
-
-template<typename T>
-struct copy_ctor<T, false> : dtor<T> {
-  using base = dtor<T>;
-  using base::base;
-
-  copy_ctor() = default;
-  copy_ctor(copy_ctor const& other) {
-    if (other.valid) {
-      this->construct(other.val);
-    }
-  }
-  copy_ctor(copy_ctor &&) = default;
-  copy_ctor& operator=(copy_ctor const&) = default;
-  copy_ctor& operator=(copy_ctor &&) = default;
-};
-
-} // namespace optional
-} // namespace internal
-} // namespace preview
-
-
-# endif // PREVIEW_OPTIONAL_INTERNAL_COPY_CTOR_H_
diff --git a/include/preview/__optional/internal/dtor.h b/include/preview/__optional/internal/dtor.h
deleted file mode 100644
index fd81c1c8..00000000
--- a/include/preview/__optional/internal/dtor.h
+++ /dev/null
@@ -1,122 +0,0 @@
-# /*
-#  * Created by YongGyu Lee on 2021/05/24.
-#  */
-#
-# ifndef PREVIEW_OPTIONAL_INTERNAL_DTOR_H_
-# define PREVIEW_OPTIONAL_INTERNAL_DTOR_H_
-#
-# include <memory>
-# include <type_traits>
-# include <utility>
-#
-# include "preview/__memory/addressof.h"
-# include "preview/__utility/in_place.h"
-
-namespace preview {
-namespace internal {
-namespace optional {
-
-template<typename T, bool v = /* true */ std::is_trivially_destructible<T>::value>
-struct dtor {
-  using value_type = T;
-
-  constexpr dtor() noexcept
-    : null{} {}
-
-  template<typename ...Args>
-  constexpr explicit dtor(in_place_t, Args&&... args)
-    : val(std::forward<Args>(args)...),
-      valid(true) {}
-
-  void reset() {
-    if (valid) {
-      val.~value_type();
-      valid = false;
-    }
-  }
-
-  constexpr inline const value_type* pointer() const noexcept { return preview::addressof(val); }
-  constexpr inline       value_type* pointer()       noexcept { return preview::addressof(val); }
-
-  constexpr inline const value_type& ref() const&  noexcept { return val;             }
-  constexpr inline       value_type& ref()      &  noexcept { return val;             }
-  constexpr inline const value_type& ref() const&& noexcept { return std::move(val);  }
-  constexpr inline       value_type& ref()      && noexcept { return std::move(val);  }
-
-  template<typename ...Args>
-  void construct(Args&&... args) {
-    ::new((void*)preview::addressof(val)) value_type(std::forward<Args>(args)...);
-    valid = true;
-  }
-
-  template<typename Other>
-  void construct_if(Other&& other) {
-    if (other)
-      construct(*std::forward<Other>(other));
-  }
-
-  ~dtor() = default;
-
-  union {
-    char null;
-    value_type val;
-  };
-  bool valid = false;
-};
-
-template<typename T>
-struct dtor<T, false> {
-  using value_type = T;
-
-  constexpr dtor() noexcept
-    : null{} {}
-
-  template<typename ...Args>
-  constexpr explicit dtor(in_place_t, Args&&... args)
-    : val(std::forward<Args>(args)...),
-      valid(true) {}
-
-  void reset() {
-    if (valid) {
-      val.~value_type();
-      valid = false;
-    }
-  }
-
-  constexpr inline const value_type* pointer() const noexcept { return preview::addressof(val); }
-  constexpr inline       value_type* pointer()       noexcept { return preview::addressof(val); }
-
-  constexpr inline const value_type& ref() const&  noexcept { return val;             }
-  constexpr inline       value_type& ref()      &  noexcept { return val;             }
-  constexpr inline const value_type& ref() const&& noexcept { return std::move(val);  }
-  constexpr inline       value_type& ref()      && noexcept { return std::move(val);  }
-
-  template<typename ...Args>
-  void construct(Args&&... args) {
-    ::new((void*)preview::addressof(val)) value_type(std::forward<Args>(args)...);
-    valid = true;
-  }
-
-  template<typename Other>
-  void construct_if(Other&& other) {
-    if (other)
-      construct(*std::forward<Other>(other));
-  }
-
-  ~dtor() {
-    if (valid)
-      val.T::~T();
-  };
-
-  union {
-    char null;
-    T val;
-  };
-  bool valid = false;
-};
-
-} // namespace optional
-} // namespace internal
-} // namespace preview
-
-# endif // PREVIEW_OPTIONAL_INTERNAL_DTOR_H_
diff --git a/include/preview/__optional/internal/hash.h b/include/preview/__optional/internal/hash.h
deleted file mode 100644
index 80a7c991..00000000
--- a/include/preview/__optional/internal/hash.h
+++ /dev/null
@@ -1,32 +0,0 @@
-# /*
-#  * Created by YongGyu Lee on 2021/05/25.
-#  */
-#
-# ifndef PREVIEW_OPTIONAL_INTERNAL_HASH_H_
-# define PREVIEW_OPTIONAL_INTERNAL_HASH_H_
-#
-# include <functional>
-# include <type_traits>
-
-namespace preview {
-namespace internal {
-namespace optional {
-
-struct not_constructible {
-  not_constructible() = delete;
-};
-
-struct constructible {};
-
-template<typename T>
-using hash_constructible =
-std::conditional_t<
-  std::is_default_constructible<std::hash<T>>::value,
-  constructible,
-  not_constructible>;
-
-} // namespace optional
-} // namespace internal
-} // namespace preview
-
-# endif // PREVIEW_OPTIONAL_INTERNAL_HASH_H_
diff --git a/include/preview/__optional/internal/move_assignment.h b/include/preview/__optional/internal/move_assignment.h
deleted file mode 100644
index 94c5afa1..00000000
--- a/include/preview/__optional/internal/move_assignment.h
+++ /dev/null
@@ -1,53 +0,0 @@
-# /*
-#  * Created by YongGyu Lee on 2021/05/24.
-#  */
-#
-#ifndef PREVIEW_OPTIONAL_INTERNAL_MOVE_ASSIGNMENT_H_
-#define PREVIEW_OPTIONAL_INTERNAL_MOVE_ASSIGNMENT_H_
-#
-# include <type_traits>
-#
-# include "preview/__optional/internal/copy_assignment.h"
-
-namespace preview {
-namespace internal {
-namespace optional {
-
-template<typename T, bool v =
-  std::is_trivially_move_constructible<T>::value &&
-  std::is_trivially_move_assignable<T>::value &&
-  std::is_trivially_destructible<T>::value>
-struct move_assign : copy_assign<T> {
-  using base = copy_assign<T>;
-  using base::base;
-};
-
-template<typename T>
-struct move_assign<T, false> : copy_assign<T> {
-  using base = copy_assign<T>;
-  using base::base;
-
-  move_assign() = default;
-  move_assign(move_assign const&) = default;
-  move_assign(move_assign &&) = default;
-  move_assign& operator=(move_assign const&) = default;
-  move_assign& operator=(move_assign && other)
-    noexcept(std::is_nothrow_move_assignable<T>::value && std::is_nothrow_move_constructible<T>::value)
-  {
-    if (!other.valid) {
-      this->reset();
-    } else {
-      if (this->valid)
-        this->val = std::move(other.val);
-      else
-        this->construct(std::move(other.val));
-    }
-    return *this;
-  }
-};
-
-} // namespace optional
-} // namespace internal
-} // namespace preview
-
-# endif // PREVIEW_OPTIONAL_INTERNAL_MOVE_ASSIGNMENT_H_
diff --git a/include/preview/__optional/internal/move_ctor.h b/include/preview/__optional/internal/move_ctor.h
deleted file mode 100644
index 6e947a28..00000000
--- a/include/preview/__optional/internal/move_ctor.h
+++ /dev/null
@@ -1,43 +0,0 @@
-# /*
-#  * Created by YongGyu Lee on 2021/05/24.
-#  */
-#
-# ifndef PREVIEW_OPTIONAL_INTERNAL_MOVE_CTOR_H_
-# define PREVIEW_OPTIONAL_INTERNAL_MOVE_CTOR_H_
-#
-# include <type_traits>
-#
-# include "preview/__optional/internal/copy_ctor.h"
-
-namespace preview {
-namespace internal {
-namespace optional {
-
-template<typename T, bool v = std::is_trivially_move_constructible<T>::value>
-struct move_ctor : copy_ctor<T> {
-  using base = copy_ctor<T>;
-  using base::base;
-};
-
-template<typename T>
-struct move_ctor<T, false> : copy_ctor<T> {
-  using base = copy_ctor<T>;
-  using base::base;
-
-  move_ctor() = default;
-  move_ctor(move_ctor const&) = default;
-  move_ctor(move_ctor && other) noexcept(std::is_nothrow_move_constructible<T>::value) {
-    if (other.valid) {
-      this->construct(std::move(other.val));
-    }
-  }
-  move_ctor& operator=(move_ctor const&) = default;
-  move_ctor& operator=(move_ctor &&) = default;
-};
-
-} // namespace optional
-} // namespace internal
-} // namespace preview
-
-
-# endif // PREVIEW_OPTIONAL_INTERNAL_MOVE_CTOR_H_
diff --git a/include/preview/__optional/internal/traits.h b/include/preview/__optional/internal/traits.h
deleted file mode 100644
index 56e3f64e..00000000
--- a/include/preview/__optional/internal/traits.h
+++ /dev/null
@@ -1,54 +0,0 @@
-# /*
-#  * Created by YongGyu Lee on 2021/05/24.
-#  */
-#
-# ifndef PREVIEW_OPTIONAL_INTERNAL_TRAITS_H_
-# define PREVIEW_OPTIONAL_INTERNAL_TRAITS_H_
-#
-# include <type_traits>
-
-namespace preview {
-namespace internal {
-namespace optional {
-
-template<bool v>
-struct conditional_tf : std::conditional_t<v, std::true_type, std::false_type> {};
-
-template<bool v>
-using conditional_tf_t = typename conditional_tf<v>::type;
-
-template<typename Original, typename Other>
-struct check_constructible :
-  conditional_tf_t<
-    !std::is_constructible<Original, Other & >::value && !std::is_constructible<Original, Other const& >::value &&
-    !std::is_constructible<Original, Other &&>::value && !std::is_constructible<Original, Other const&&>::value> {};
-
-template<typename Original, typename Other>
-struct check_convertible :
-  conditional_tf_t<
-    !std::is_convertible<Other & , Original>::value && !std::is_convertible<Other const& , Original>::value &&
-    !std::is_convertible<Other &&, Original>::value && !std::is_convertible<Other const&&, Original>::value> {};
-
-template<typename Original, typename Other>
-struct check_assignable :
-  conditional_tf_t<
-    !std::is_assignable<Original&, Other & >::value && !std::is_assignable<Original&, Other const& >::value &&
-    !std::is_assignable<Original&, Other &&>::value && !std::is_assignable<Original&, Other const&&>::value> {};
-
-template<typename T>
-struct strip {
-#if __cplusplus <= 201703
-  using type = std::decay_t<T>;
-#else
-  using type = std::remove_cvref_t<T>;
-# endif
-};
-
-template<typename T>
-using strip_t = typename strip<T>::type;
-
-} // namespace optional
-} // namespace internal
-} // namespace preview
-
-# endif // PREVIEW_OPTIONAL_INTERNAL_TRAITS_H_
diff --git a/include/preview/__optional/optional.h b/include/preview/__optional/optional.h
index ff11602e..62da5777 100644
--- a/include/preview/__optional/optional.h
+++ b/include/preview/__optional/optional.h
@@ -9,31 +9,240 @@
 # include <new>
 # include <utility>
 #
+# include "preview/core.h"
 # include "preview/__concepts/copy_constructible.h"
 # include "preview/__concepts/invocable.h"
 # include "preview/__concepts/move_constructible.h"
 # include "preview/__functional/invoke.h"
-# include "preview/__optional/internal/check_overload.h"
-# include "preview/__optional/internal/move_assignment.h"
-# include "preview/__optional/internal/traits.h"
+# include "preview/__memory/construct_at.h"
+# include "preview/__memory/destroy_at.h"
 # include "preview/__optional/bad_optional_access.h"
 # include "preview/__optional/nullopt_t.h"
 # include "preview/__optional/swap.h"
+# include "preview/__type_traits/detail/control_special.h"
 # include "preview/__type_traits/is_swappable.h"
 # include "preview/__type_traits/is_invocable.h"
+# include "preview/__type_traits/is_specialization.h"
 # include "preview/__type_traits/remove_cvref.h"
 # include "preview/__utility/in_place.h"
 
 namespace preview {
+namespace detail {
+
+template<typename T, bool = std::is_trivially_destructible<T>::value /* true */>
+struct optional_storage {
+  using value_type = T;
+
+  constexpr optional_storage() noexcept
+      : null{}
+      , has_value(false) {}
+
+  template<typename... Args>
+  constexpr optional_storage(in_place_t, Args&&... args)
+      : value(std::forward<Args>(args)...)
+      , has_value(true) {}
+
+  union {
+    char null;
+    T value;
+  };
+  bool has_value;
+};
+
+template<typename T>
+struct optional_storage<T, false> {
+  using value_type = T;
+
+  constexpr optional_storage() noexcept
+      : null{}
+      , has_value(false) {}
+
+  template<typename... Args>
+  constexpr optional_storage(in_place_t, Args&&... args)
+      : value(std::forward<Args>(args)...)
+      , has_value(true) {}
+
+  PREVIEW_CONSTEXPR_AFTER_CXX20 ~optional_storage() {
+    if (has_value)
+      preview::destroy_at(std::addressof(value));
+  }
+
+  union {
+    char null;
+    T value;
+  };
+  bool has_value;
+};
+
+template<typename T>
+struct optional_base {
+ public:
+  using value_type = T;
+
+  constexpr optional_base() noexcept = default;
+
+  template<typename... Args>
+  constexpr explicit optional_base(in_place_t, Args&&... args)
+      : storage_(in_place_t{}, std::forward<Args>(args)...) {}
+
+  void reset() {
+    if (storage_.has_value) {
+      preview::destroy_at(std::addressof(storage_.value));
+      storage_.has_value = false;
+    }
+  }
+
+  PREVIEW_CONSTEXPR_AFTER_CXX17 const value_type* operator->() const noexcept { std::addressof(storage_.value); }
+  PREVIEW_CONSTEXPR_AFTER_CXX17       value_type* operator->()       noexcept { std::addressof(storage_.value); }
+
+  constexpr const value_type&  operator*() const&  noexcept { return storage_.value;             }
+  constexpr       value_type&  operator*()      &  noexcept { return storage_.value;             }
+  constexpr const value_type&& operator*() const&& noexcept { return std::move(storage_.value);  }
+  constexpr       value_type&& operator*()      && noexcept { return std::move(storage_.value);  }
+
+  constexpr explicit operator bool() const noexcept {
+    return storage_.has_value;
+  }
+
+  constexpr bool has_value() const noexcept {
+    return storage_.has_value;
+  }
+
+  constexpr value_type& value() & {
+    throw_if_empty();
+    return storage_.value;
+  }
+
+  constexpr const value_type& value() const& {
+    throw_if_empty();
+    return storage_.value;
+  }
+
+  constexpr value_type&& value() && {
+    throw_if_empty();
+    return std::move(storage_.value);
+  }
+
+  constexpr const value_type&& value() const&& {
+    throw_if_empty();
+    return std::move(storage_.value);
+  }
+
+  // control-special
+  constexpr void construct_from(const optional_base& other) {
+    if (other.has_value())
+      construct_with(*other);
+  }
+
+  // control-special
+  constexpr void construct_from(optional_base&& other) {
+    if (other.has_value())
+      construct_with(std::move(*other));
+  }
+
+  // control-special
+  constexpr void assign_from(const optional_base& other) {
+    if (!other.has_value()) {
+      reset();
+    } else {
+      if (has_value())
+        storage_.value = other.value();
+      else
+        construct_with(other.value());
+    }
+  }
+
+  // control-special
+  constexpr void assign_from(optional_base&& other) {
+    if (!other.has_value()) {
+      reset();
+    } else {
+      if (has_value())
+        storage_.value = std::move(other.value());
+      else
+        construct_with(std::move(other.value()));
+    }
+  }
+
+  template<typename ...Args>
+  void construct_with(Args&&... args) {
+    preview::construct_at(std::addressof(storage_.value), std::forward<Args>(args)...);
+    storage_.has_value = true;
+  }
+
+  void destruct() {
+    if (has_value())
+      preview::destroy_at(std::addressof(storage_.value));
+  }
+
+ private:
+  void throw_if_empty() const {
+    if (!has_value())
+      throw bad_optional_access{};
+  }
+
+  optional_storage<T> storage_;
+};
+
+template<typename T>
+struct optional_nontrivial_dtor : optional_base<T> {
+  using base = optional_base<T>;
+  using base::base;
+
+  PREVIEW_CONSTEXPR_AFTER_CXX20 ~optional_nontrivial_dtor() {
+    base::destruct();
+  }
+
+  optional_nontrivial_dtor() = default;
+  constexpr optional_nontrivial_dtor(const optional_nontrivial_dtor&) = default;
+  constexpr optional_nontrivial_dtor(optional_nontrivial_dtor&&) = default;
+  constexpr optional_nontrivial_dtor& operator=(const optional_nontrivial_dtor&) = default;
+  constexpr optional_nontrivial_dtor& operator=(optional_nontrivial_dtor&&) = default;
+};
+
+template<typename T>
+using optional_control_smf =
+    std::conditional_t<
+        std::is_trivially_destructible<T>::value,
+        control_special<optional_base<T>, T>,
+        control_special<optional_nontrivial_dtor<T>, T>
+    >;
+
+template<typename To, typename From>
+using never_constructible_from = conjunction<
+    negation<std::is_constructible<To, From &       >>,
+    negation<std::is_constructible<To, From const&  >>,
+    negation<std::is_constructible<To, From &&      >>,
+    negation<std::is_constructible<To, From const&& >>
+>;
+
+template<typename To, typename From>
+using never_convertible_from = conjunction<
+    negation<std::is_convertible<From &      , To>>,
+    negation<std::is_convertible<From const& , To>>,
+    negation<std::is_convertible<From &&     , To>>,
+    negation<std::is_convertible<From const&&, To>>
+>;
+
+template<typename To, typename From>
+using never_constructible_or_convertible_from = conjunction<
+    never_constructible_from<To, From>,
+    never_convertible_from<To, From>
+>;
+
+template<typename To, typename From>
+using never_assignable_from = conjunction<
+    negation<std::is_assignable<To&, From &      >>,
+    negation<std::is_assignable<To&, From const& >>,
+    negation<std::is_assignable<To&, From &&     >>,
+    negation<std::is_assignable<To&, From const&&>>
+>;
+
+} // namespace detail
 
 template<typename T>
-class optional :
-  private internal::optional::move_assign<T>,
-  private internal::optional::check_copy_constructible<T>,
-  private internal::optional::check_move_constructible<T>,
-  private internal::optional::check_copy_assignable<T>,
-  private internal::optional::check_move_assignable<T> {
-  using base = internal::optional::move_assign<T>;
+class optional : private detail::optional_control_smf<T> {
+  using base = detail::optional_control_smf<T>;
   using base::base;
 
  public:
@@ -56,88 +265,97 @@ class optional :
   constexpr optional(const optional& other) = default;
   constexpr optional(optional&& other) = default;
 
-  template<typename U,
-    std::enable_if_t<
-      std::is_constructible<value_type, const U&>::value &&
-      internal::optional::check_constructible<value_type, optional<U>>::value &&
-      internal::optional::check_convertible  <value_type, optional<U>>::value,
-    int> = 0>
+  template<typename U, std::enable_if_t<conjunction<
+      std::is_constructible<value_type, const U&>,
+      disjunction<
+          std::is_same<std::remove_cv_t<T>, bool>,
+          detail::never_constructible_or_convertible_from<value_type, optional<U>> >,
+      std::is_convertible<const U&, T> // explicit(false)
+  >::value, int> = 0>
   constexpr optional(const optional<U>& other) {
-    this->construct_if(other);
+    if (other.has_value())
+      this->construct_with(*other);
   }
 
-  template<typename U,
-    std::enable_if_t<
-      std::is_constructible<value_type, const U&>::value &&
-      internal::optional::check_constructible<value_type, optional<U>>::value &&
-      internal::optional::check_convertible  <value_type, optional<U>>::value &&
-      !std::is_convertible<const U&, value_type>::value,
-    int> = 0>
-  explicit constexpr optional(const optional<U>& other) {
-    this->construct_if(other);
+  template<typename U, std::enable_if_t<conjunction<
+      std::is_constructible<value_type, const U&>,
+      disjunction<
+          std::is_same<std::remove_cv_t<T>, bool>,
+          detail::never_constructible_or_convertible_from<value_type, optional<U>> >,
+      negation<std::is_convertible<const U&, T>> // explicit(true)
+  >::value, int> = 0>
+  constexpr explicit optional(const optional<U>& other) {
+    if (other.has_value())
+      this->construct_with(*other);
   }
 
-  template<typename U,
-    std::enable_if_t<
-      std::is_constructible<value_type, U&&>::value &&
-      internal::optional::check_constructible<value_type, optional<U>>::value &&
-      internal::optional::check_convertible  <value_type, optional<U>>::value,
-    int> = 0>
+  template<typename U, std::enable_if_t<conjunction<
+      std::is_constructible<value_type, U&&>,
+      disjunction<
+          std::is_same<std::remove_cv_t<T>, bool>,
+          detail::never_constructible_or_convertible_from<value_type, optional<U>> >,
+      std::is_convertible<U&&, T> // explicit(false)
+  >::value, int> = 0>
   constexpr optional(optional<U>&& other) {
-    this->construct_if(std::move(other));
+    if (other.has_value())
+      this->construct_with(std::move(*other));
   }
 
-  template<typename U,
-    std::enable_if_t<
-      std::is_constructible<value_type, U&&>::value &&
-      internal::optional::check_constructible<value_type, optional<U>>::value &&
-      internal::optional::check_convertible  <value_type, optional<U>>::value &&
-      !std::is_convertible<U&&, value_type>::value,
-    int> = 0>
-  explicit constexpr optional(optional<U>&& other) {
-    this->construct_if(std::move(other));
+  template<typename U, std::enable_if_t<conjunction<
+      std::is_constructible<value_type, U&&>,
+      disjunction<
+          std::is_same<std::remove_cv_t<T>, bool>,
+          detail::never_constructible_or_convertible_from<value_type, optional<U>> >,
+      negation<std::is_convertible<U&&, T>> // explicit(true)
+  >::value, int> = 0>
+  constexpr explicit optional(optional<U>&& other) {
+    if (other.has_value())
+      this->construct_with(std::move(*other));
   }
 
   // Split into 2 overloads to prevent MSVC from making an ambiguous call in C++14
-  template<typename InPlaceT,
-    std::enable_if_t<
-      std::is_same<InPlaceT, in_place_t>::value &&
-      std::is_constructible<value_type>::value,
-    int> = 0>
+  template<typename InPlaceT, std::enable_if_t<conjunction<
+      std::is_same<InPlaceT, in_place_t>,
+      std::is_constructible<value_type>
+  >::value, int> = 0>
   constexpr explicit optional(InPlaceT)
     : base(in_place) {}
 
-  template<typename Arg, typename ...Args,
-    std::enable_if_t<
+  template<typename Arg, typename ...Args, std::enable_if_t<
       std::is_constructible<value_type, Arg, Args...>::value,
-    int> = 0>
+  int> = 0>
   constexpr explicit optional(in_place_t, Arg&& arg, Args&&... args)
     : base(in_place, std::forward<Arg>(arg), std::forward<Args>(args)...) {}
 
-  template<typename U, typename ...Args,
-    std::enable_if_t<
+  template<typename U, typename ...Args, std::enable_if_t<
       std::is_constructible<value_type, std::initializer_list<U>&, Args&&...>::value,
-    int> = 0>
+  int> = 0>
   constexpr explicit optional(in_place_t, std::initializer_list<U> ilist, Args&&... args)
     : base(in_place, ilist, std::forward<Args>(args)...) {}
 
-  template<typename U = value_type,
-    std::enable_if_t<
-      std::is_constructible<value_type,U&&>::value &&
-      std::is_convertible<U&&, value_type>::value &&
-      !std::is_same<internal::optional::strip_t<U>, in_place_t>::value &&
-      !std::is_same<internal::optional::strip_t<U>, optional<value_type>>::value,
-    int> = 0>
+  template<typename U = value_type, std::enable_if_t<conjunction<
+      std::is_constructible<value_type,U&&>,
+      negation<std::is_same<remove_cvref_t<U>, in_place_t>>,
+      negation<std::is_same<remove_cvref_t<U>, optional<T>>>,
+      disjunction<
+          negation< std::is_same<std::remove_cv_t<T>, bool> >,
+          negation< is_specialization<remove_cvref_t<U>, optional> >
+      >,
+      std::is_convertible<U&&, value_type> // explicit(false)
+  >::value, int> = 0>
   constexpr optional(U&& value)
     : base(in_place, std::forward<U>(value)) {}
 
-  template<typename U = value_type,
-    std::enable_if_t<
-      std::is_constructible<value_type,U&&>::value &&
-      !std::is_convertible<U&&, value_type>::value &&
-      !std::is_same<internal::optional::strip_t<U>, in_place_t>::value &&
-      !std::is_same<internal::optional::strip_t<U>, optional<value_type>>::value,
-    int> = 0>
+  template<typename U = value_type, std::enable_if_t<conjunction<
+      std::is_constructible<value_type,U&&>,
+      negation<std::is_same<remove_cvref_t<U>, in_place_t>>,
+      negation<std::is_same<remove_cvref_t<U>, optional<T>>>,
+      disjunction<
+          negation< std::is_same<std::remove_cv_t<T>, bool> >,
+          negation< is_specialization<remove_cvref_t<U>, optional> >
+      >,
+      negation<std::is_convertible<U&&, value_type>> // explicit(true)
+  >::value, int> = 0>
   constexpr explicit optional(U&& value)
     : base(in_place, std::forward<U>(value)) {}
 
@@ -151,37 +369,38 @@ class optional :
   constexpr optional& operator=(optional const&) = default;
   constexpr optional& operator=(optional &&) = default;
 
-  template<typename U,
-    std::enable_if_t<
-      (std::is_constructible<value_type, U>::value &&
-       std::is_assignable<value_type&, U>::value &&
-       !std::is_same<internal::optional::strip_t<U>, optional>::value) &&
-      (!std::is_scalar<value_type>::value ||
-       !std::is_same<std::decay_t<U>, value_type>::value),
-    int> = 0>
+  template<typename U = T, std::enable_if_t<conjunction<
+      conjunction<
+          negation< std::is_same<remove_cvref_t<U>, optional<T>> >,
+          std::is_constructible<T, U>,
+          std::is_assignable<T&, U>
+      >,
+      disjunction<
+          negation< std::is_scalar<T> >,
+          negation< std::is_same<std::decay_t<U>, T> >
+      >
+  >::value, int> = 0>
   optional& operator=(U&& value) {
     if (has_value()) {
       this->val = std::forward<U>(value);
     } else {
-      this->construct(std::forward<U>(value));
+      this->construct_with(std::forward<U>(value));
     }
     return *this;
   }
 
-  template<typename U,
-    std::enable_if_t<
-      internal::optional::check_constructible<value_type, optional<U>>::value &&
-      internal::optional::check_convertible  <value_type, optional<U>>::value &&
-      internal::optional::check_assignable   <value_type, optional<U>>::value &&
-      std::is_constructible<value_type , const U&>::value &&
-      std::is_assignable   <value_type&, const U&>::value,
-    int> = 0>
+  template<typename U, std::enable_if_t<conjunction<
+      detail::never_constructible_or_convertible_from<T, optional<U>>,
+      detail::never_assignable_from<T, optional<U>>,
+      std::is_constructible<T , const U&>,
+      std::is_assignable<T&, const U&>
+  >::value, int> = 0>
   optional& operator=(const optional<U>& other) {
     if (other.has_value()) {
       if (this->has_value())
         this->val = *other;
       else
-        this->construct(*other);
+        this->construct_with(*other);
     } else { // !other.has_value()
       if (this->has_value())
         this->reset();
@@ -189,20 +408,18 @@ class optional :
     return *this;
   }
 
-  template<typename U,
-    std::enable_if_t<
-      internal::optional::check_constructible<value_type, optional<U>>::value &&
-      internal::optional::check_convertible  <value_type, optional<U>>::value &&
-      internal::optional::check_assignable   <value_type, optional<U>>::value &&
-      std::is_constructible<value_type , U>::value &&
-      std::is_assignable   <value_type&, U>::value,
-    int> = 0>
+  template<typename U, std::enable_if_t<conjunction<
+      detail::never_constructible_or_convertible_from<T, optional<U>>,
+      detail::never_assignable_from<T, optional<U>>,
+      std::is_constructible<T , U>,
+      std::is_assignable<T&, U>
+  >::value, int> = 0>
   optional& operator=(optional<U>&& other) {
     if (other.has_value()) {
       if (this->has_value())
         this->val = std::move(*other);
       else
-        this->construct(std::move(*other));
+        this->construct_with(std::move(*other));
     } else { // !other.has_value()
       if (this->has_value())
         this->reset();
@@ -210,124 +427,111 @@ class optional :
     return *this;
   }
 
-  constexpr inline const value_type*  operator->() const noexcept { return this->pointer(); }
-  constexpr inline       value_type*  operator->()       noexcept { return this->pointer(); }
-
-  constexpr inline const value_type&  operator*() const&  noexcept { return this->ref(); }
-  constexpr inline       value_type&  operator*()      &  noexcept { return this->ref(); }
-  constexpr inline const value_type&& operator*() const&& noexcept { return std::move(this->ref()); }
-  constexpr inline       value_type&& operator*()      && noexcept { return std::move(this->ref()); }
-
-  constexpr explicit inline operator bool() const noexcept {
-    return this->valid;
-  }
-  constexpr inline bool has_value() const noexcept {
-    return this->valid;
-  }
-
-  constexpr inline value_type& value() & {
-    if (!this->has_value())
-      throw bad_optional_access{};
-    return this->ref();
-  }
-  constexpr inline const value_type& value() const& {
-    if (!this->has_value())
-      throw bad_optional_access{};
-    return this->ref();
-  }
-  constexpr inline value_type&& value() && {
-    if (!this->has_value())
-      throw bad_optional_access{};
-    return std::move(this->ref());
-  }
-  constexpr inline const value_type&& value() const && {
-    if (!this->has_value())
-      throw bad_optional_access{};
-    return std::move(this->ref());
-  }
-
-  template<typename U>
-  constexpr value_type value_or(U&& default_value) const & {
-    static_assert(std::is_copy_constructible<value_type>::value,
-                  "preview::optional<T>::value_or : T must be copy constructible");
-    static_assert(std::is_convertible<U&&, value_type>::value,
-                  "preview::optional<T>::value_or : U&& must be convertible to T");
+  using base::operator->;
+  using base::operator*;
+  using base::operator bool;
+  using base::has_value;
+  using base::value;
+  using base::reset;
 
-    return this->has_value() ? **this : static_cast<value_type>(std::forward<U>(default_value));
+  template<typename U, std::enable_if_t<conjunction<
+      std::is_copy_constructible<T>,
+      std::is_convertible<U&&, T>
+  >::value, int> = 0>
+  constexpr T value_or(U&& default_value) const & {
+    return bool(*this) ? **this : static_cast<T>(std::forward<U>(default_value));
   }
 
-  template<typename U>
-  constexpr value_type value_or(U&& default_value) && {
-    static_assert(std::is_move_constructible<value_type>::value,
-                  "preview::optional<T>::value_or : T must be move constructible");
-    static_assert(std::is_convertible<U&&, value_type>::value,
-                  "preview::optional<T>::value_or : U&& must be convertible to T");
-
-    return this->has_value() ? std::move(**this) : static_cast<value_type>(std::forward<U>(default_value));
+  template<typename U, std::enable_if_t<conjunction<
+      std::is_move_constructible<T>,
+      std::is_convertible<U&&, T>
+  >::value, int> = 0>
+  constexpr T value_or(U&& default_value) && {
+    return bool(*this) ? std::move(**this) : static_cast<T>(std::forward<U>(default_value));
   }
 
   template<typename F, std::enable_if_t<
-      is_specialization<invoke_result_t<F, value_type&>, optional>::value, int> = 0>
+      is_specialization<invoke_result_t<F, T&>, optional>
+  ::value, int> = 0>
   constexpr auto and_then(F&& f) & {
     if (*this)
       return preview::invoke(std::forward<F>(f), **this);
-    return remove_cvref_t<invoke_result_t<F, value_type&>>{};
+    else
+      return remove_cvref_t<invoke_result_t<F, T&>>{};
   }
 
   template<typename F, std::enable_if_t<
-      is_specialization<invoke_result_t<F, const value_type&>, optional>::value, int> = 0>
+      is_specialization<invoke_result_t<F, const T&>, optional>
+  ::value, int> = 0>
   constexpr auto and_then(F&& f) const & {
     if (*this)
       return preview::invoke(std::forward<F>(f), **this);
-    return remove_cvref_t<invoke_result_t<F, const value_type&>>{};
+    else
+      return remove_cvref_t<invoke_result_t<F, const T&>>{};
   }
 
   template<typename F, std::enable_if_t<
-      is_specialization<invoke_result_t<F, value_type&&>, optional>::value, int> = 0>
+      is_specialization<invoke_result_t<F, T>, optional>
+  ::value, int> = 0>
   constexpr auto and_then(F&& f) && {
     if (*this)
       return preview::invoke(std::forward<F>(f), std::move(**this));
-    return remove_cvref_t<invoke_result_t<F, value_type>>{};
+    else
+      return remove_cvref_t<invoke_result_t<F, T>>{};
   }
 
   template<typename F, std::enable_if_t<
-      is_specialization<invoke_result_t<F, const value_type&&>, optional>::value, int> = 0>
+      is_specialization<invoke_result_t<F, const T>, optional>
+  ::value, int> = 0>
   constexpr auto and_then(F&& f) const && {
     if (*this)
       return preview::invoke(std::forward<F>(f), std::move(**this));
-    return remove_cvref_t<invoke_result_t<F, const value_type>>{};
+    else
+      return remove_cvref_t<invoke_result_t<F, const T>>{};
   }
 
-  template<typename F, std::enable_if_t<is_invocable<F, value_type&>::value, int> = 0>
+  template<typename F, std::enable_if_t<conjunction<
+      is_invocable<F, T&>
+  >::value, int> = 0>
   constexpr auto transform(F&& f) & {
     using U = std::remove_cv_t<invoke_result_t<F, T&>>;
     if (*this)
       return optional<U>(preview::invoke(std::forward<F>(f), **this));
-    return optional<U>{};
+    else
+      return optional<U>{};
   }
 
-  template<typename F, std::enable_if_t<is_invocable<F, const value_type&>::value, int> = 0>
+  template<typename F, std::enable_if_t<
+      is_invocable<F, const T&>
+  ::value, int> = 0>
   constexpr auto transform(F&& f) const & {
     using U = std::remove_cv_t<invoke_result_t<F, const T&>>;
     if (*this)
       return optional<U>(preview::invoke(std::forward<F>(f), **this));
-    return optional<U>{};
+    else
+      return optional<U>{};
   }
 
-  template<typename F, std::enable_if_t<is_invocable<F, value_type&>::value, int> = 0>
+  template<typename F, std::enable_if_t<
+      is_invocable<F, T>
+  ::value, int> = 0>
   constexpr auto transform(F&& f) && {
     using U = std::remove_cv_t<invoke_result_t<F, T>>;
     if (*this)
       return optional<U>(preview::invoke(std::forward<F>(f), std::move(**this)));
-    return optional<U>{};
+    else
+      return optional<U>{};
   }
 
-  template<typename F, std::enable_if_t<is_invocable<F, value_type&>::value, int> = 0>
+  template<typename F, std::enable_if_t<
+      is_invocable<F, const T>
+  ::value, int> = 0>
   constexpr auto transform(F&& f) const && {
     using U = std::remove_cv_t<invoke_result_t<F, const T>>;
     if (*this)
       return optional<U>(preview::invoke(std::forward<F>(f), std::move(**this)));
-    return optional<U>{};
+    else
+      return optional<U>{};
   }
 
   template<typename F, std::enable_if_t<conjunction<
@@ -347,45 +551,48 @@ class optional :
     return *this ? std::move(*this) : std::forward<F>(f)();
   }
 
+  template<typename Dummy = void, std::enable_if_t<conjunction<
+      std::is_void<Dummy>,
+      is_swappable<T&>,
+      std::is_move_constructible<T>
+  >::value, int> = 0>
   void swap(optional& other)
-  noexcept(std::is_nothrow_move_constructible<value_type>::value && preview::is_nothrow_swappable<value_type>::value)
+      noexcept(std::is_nothrow_move_constructible<T>::value &&
+               preview::is_nothrow_swappable<T>::value)
   {
-    static_assert(std::is_move_constructible<value_type>::value,
-                  "preview::optional<T>::swap : T must be move constructible");
-
+    // TODO: Investigate exception safety guarantees
     if (other.has_value()) {
       if (this->has_value()) {
-        std::swap(**this, *other);
+        using std::swap;
+        swap(**this, *other);
       } else { // !this->has_value()
-        this->construct(std::move(*other));
+        this->construct_with(std::move(*other));
         other.reset();
       }
     } else {
       if (this->has_value()) {
-        other.construct(**this);
+        other.construct_with(std::move(**this));
         this->reset();
       }
     }
   }
 
-  template<typename Dummy = void,
-    std::enable_if_t<
-      std::is_same<Dummy, void>::value &&
-      std::is_constructible<value_type>::value,
-    int> = 0>
+  template<typename Dummy = void, std::enable_if_t<conjunction<
+      std::is_void<Dummy>,
+      std::is_constructible<value_type>
+  >::value, int> = 0>
   value_type& emplace() {
     this->reset();
-    this->construct();
+    this->construct_with();
     return **this;
   }
 
-  template<typename Arg, typename ...Args,
-    std::enable_if_t<
-      std::is_constructible<value_type, Arg, Args...>::value,
-    int> = 0>
+  template<typename Arg, typename ...Args, std::enable_if_t<
+      std::is_constructible<value_type, Arg, Args...>
+  ::value, int> = 0>
   value_type& emplace(Arg&& arg, Args&&... args) {
-    this->reset();
-    this->construct(std::forward<Arg>(arg), std::forward<Args>(args)...);
+    this->destruct();
+    this->construct_with(std::forward<Arg>(arg), std::forward<Args>(args)...);
     return **this;
   }
 
@@ -394,15 +601,13 @@ class optional :
       std::is_constructible<value_type, std::initializer_list<U>&, Args&&...>::value,
     int> = 0>
   value_type& emplace(std::initializer_list<U> ilist, Args&&... args) {
-    this->reset();
-    this->construct(ilist, std::forward<Args>(args)...);
+    this->destruct();
+    this->construct_with(ilist, std::forward<Args>(args)...);
     return **this;
   }
-
-  using base::reset;
 };
 
-# if __cplusplus >= 201703
+# if PREVIEW_CXX_VERSION >= 17
 template<class T> optional(T) -> optional<T>;
 # endif
 
@@ -422,8 +627,8 @@ constexpr inline optional<T> make_optional(Arg&& arg, Args&&... args) {
 }
 
 template<typename T, typename U, typename ...Args>
-constexpr inline optional<T> make_optional(std::initializer_list<U> ilist, Args&&... args) {
-  return optional<T>(in_place, ilist, std::forward<Args>(args)...);
+constexpr inline optional<T> make_optional(std::initializer_list<U> il, Args&&... args) {
+  return optional<T>(in_place, il, std::forward<Args>(args)...);
 }
 
 // compare two optional objects
@@ -560,52 +765,52 @@ constexpr inline bool operator==(const T& value, const optional<U>& opt) {
 
 template<typename T, typename U>
 constexpr inline bool operator!=(const optional<T>& opt, const U& value) {
-  return bool(opt) ? opt != value : true;
+  return bool(opt) ? *opt != value : true;
 }
 
 template<typename T, typename U>
 constexpr inline bool operator!=(const T& value, const optional<U>& opt) {
-  return bool(opt) ? value != opt : true;
+  return bool(opt) ? value != *opt : true;
 }
 
 template<typename T, typename U>
 constexpr inline bool operator<(const optional<T>& opt, const U& value) {
-  return bool(opt) ? opt < value : true;
+  return bool(opt) ? *opt < value : true;
 }
 
 template<typename T, typename U>
 constexpr inline bool operator<(const T& value, const optional<U>& opt) {
-  return bool(opt) ? value < opt : false;
+  return bool(opt) ? value < *opt : false;
 }
 
 template<typename T, typename U>
 constexpr inline bool operator<=(const optional<T>& opt, const U& value) {
-  return bool(opt) ? opt <= value : true;
+  return bool(opt) ? *opt <= value : true;
 }
 
 template<typename T, typename U>
 constexpr inline bool operator<=(const T& value, const optional<U>& opt) {
-  return bool(opt) ? value <= opt : false;
+  return bool(opt) ? value <= *opt : false;
 }
 
 template<typename T, typename U>
 constexpr inline bool operator>(const optional<T>& opt, const U& value) {
-  return bool(opt) ? opt > value : false;
+  return bool(opt) ? *opt > value : false;
 }
 
 template<typename T, typename U>
 constexpr inline bool operator>(const T& value, const optional<U>& opt) {
-  return bool(opt) ? value > opt : true;
+  return bool(opt) ? value > *opt : true;
 }
 
 template<typename T, typename U>
 constexpr inline bool operator>=(const optional<T>& opt, const U& value) {
-  return bool(opt) ? opt >= value : false;
+  return bool(opt) ? *opt >= value : false;
 }
 
 template<typename T, typename U>
 constexpr inline bool operator>=(const T& value, const optional<U>& opt) {
-  return bool(opt) ? value >= opt : true;
+  return bool(opt) ? value >= *opt : true;
 }
 
 } // namespace preview
diff --git a/include/preview/__optional/swap.h b/include/preview/__optional/swap.h
index d5216cb2..3bbb9e2a 100644
--- a/include/preview/__optional/swap.h
+++ b/include/preview/__optional/swap.h
@@ -13,16 +13,16 @@
 # include "preview/__type_traits/conjunction.h"
 # include "preview/__type_traits/is_swappable.h"
 
-namespace std {
+namespace preview {
 
-template<typename T,
-  ::std::enable_if_t<
-    ::std::is_move_constructible<T>::value && ::preview::is_swappable<T>::value,
-  int> = 0>
-void swap(::preview::optional<T>& lhs, ::preview::optional<T>& rhs) noexcept(noexcept(lhs.swap(rhs))) {
+template<typename T, std::enable_if_t<conjunction<
+    std::is_move_constructible<T>,
+    is_swappable<T>
+>::value, int> = 0>
+void swap(optional<T>& lhs, optional<T>& rhs) noexcept(noexcept(lhs.swap(rhs))) {
   lhs.swap(rhs);
 }
 
-} // namespace std
+} // namespace preview
 
 # endif // PREVIEW_OPTIONAL_SWAP_H_