diff --git a/optional.hpp b/optional.hpp
index 023d09b..3830f9a 100644
--- a/optional.hpp
+++ b/optional.hpp
@@ -32,7 +32,12 @@
 #define TL_OPTIONAL_NO_CONSTRR
 #endif
 
-#if __cplusplus == 201103L || defined(TL_OPTIONAL_MSVC2015) || defined(TL_OPTIONAL_GCC49)
+#if __cplusplus > 201103L
+#define TL_OPTIONAL_CXX14
+#endif
+
+#if __cplusplus == 201103L || defined(TL_OPTIONAL_MSVC2015) ||                 \
+    defined(TL_OPTIONAL_GCC49)
 /// \exclude
 #define TL_OPTIONAL_11_CONSTEXPR
 #else
@@ -40,7 +45,6 @@
 #define TL_OPTIONAL_11_CONSTEXPR constexpr
 #endif
 
-
 namespace tl {
 /// \brief Used to represent an optional with no data; essentially a bool
 class monostate {};
@@ -118,36 +122,20 @@ using invoke_result = invoke_result_impl<F, void, Us...>;
 template <class F, class... Us>
 using invoke_result_t = typename invoke_result<F, Us...>::type;
 
-
 // Change void to tl::monostate
 template <class U>
 using fixup_void = conditional_t<std::is_void<U>::value, monostate, U>;
 
-template <class F, class... U> struct get_invoke_optional_ret {
-  using type = invoke_result_t<
-      conditional_t<std::is_lvalue_reference<F>::value,
-                    typename remove_reference_t<F>::value_type &,
-                    typename remove_reference_t<F>::value_type &&>,
-      U...>;
-};
-
-template <class F, class... U>
-using get_invoke_ret = typename conditional_t<is_optional<F>::value,
-                                              get_invoke_optional_ret<F, U...>,
-                                              invoke_result<F, U...>>::type;
-
-template <class F, class U>
-using get_map_return = optional<fixup_void<get_invoke_ret<F, U>>>;
+template <class F, class U, class = invoke_result_t<F, U>>
+using get_map_return = optional<fixup_void<invoke_result_t<F, U>>>;
 
 // Check if invoking F for some Us returns void
+template <class F, class = void, class... U> struct returns_void_impl;
 template <class F, class... U>
-using returns_void = std::is_void<get_invoke_ret<F, U...>>;
-
-template <class T>
-using disable_if_optional = enable_if_t<!is_optional<T>::value>;
-
-template <class T>
-using enable_if_optional = enable_if_t<is_optional<T>::value>;
+struct returns_void_impl<F, void_t<invoke_result_t<F, U...>>, U...>
+    : std::is_void<invoke_result_t<F, U...>> {};
+template <class F, class... U>
+using returns_void = returns_void_impl<F, void, U...>;
 
 template <class T, class... U>
 using enable_if_ret_void = enable_if_t<returns_void<T &&, U...>::value>;
@@ -270,10 +258,10 @@ struct is_nothrow_swappable
 };
 #endif
 
-
 template <class T, bool = ::std::is_trivially_destructible<T>::value>
 struct optional_storage_base {
-    TL_OPTIONAL_11_CONSTEXPR optional_storage_base() noexcept : m_dummy(), m_has_value(false) {}
+  TL_OPTIONAL_11_CONSTEXPR optional_storage_base() noexcept
+      : m_dummy(), m_has_value(false) {}
 
   template <class... U>
   TL_OPTIONAL_11_CONSTEXPR optional_storage_base(in_place_t, U &&... u) noexcept
@@ -296,12 +284,11 @@ struct optional_storage_base {
 };
 
 template <class T> struct optional_storage_base<T, true> {
-    TL_OPTIONAL_11_CONSTEXPR optional_storage_base() noexcept
+  TL_OPTIONAL_11_CONSTEXPR optional_storage_base() noexcept
       : m_dummy(), m_has_value(false) {}
 
   template <class... U>
-  TL_OPTIONAL_11_CONSTEXPR optional_storage_base(in_place_t,
-                                                        U &&... u) noexcept
+  TL_OPTIONAL_11_CONSTEXPR optional_storage_base(in_place_t, U &&... u) noexcept
       : m_value(std::forward<U>(u)...), m_has_value(true) {}
 
   ~optional_storage_base() = default;
@@ -314,6 +301,7 @@ template <class T> struct optional_storage_base<T, true> {
 
   bool m_has_value = false;
 };
+
 } // namespace detail
 
 /// \brief A tag type to represent an empty optional
@@ -339,18 +327,25 @@ public:
   const char *what() const noexcept { return "Optional has no value"; }
 };
 
-/// An optional object is an object that contains the storage for another object and manages the lifetime of this contained object, if any. The contained object may be initialized after the optional object has been initialized, and may be destroyed before the optional object has been destroyed. The initialization state of the contained object is tracked by the optional object.
+/// An optional object is an object that contains the storage for another object
+/// and manages the lifetime of this contained object, if any. The contained
+/// object may be initialized after the optional object has been initialized,
+/// and may be destroyed before the optional object has been destroyed. The
+/// initialization state of the contained object is tracked by the optional
+/// object.
 template <class T> class optional : private detail::optional_storage_base<T> {
   using base = detail::optional_storage_base<T>;
 
 public:
-
   /// \group and_then
-  /// Carries out some operation which returns an optional on the stored object if there is one.
-  /// \requires `std::invoke(std::forward<F>(f), value())` returns a `std::optional<U>` for some `U`.
-  /// \returns Let `U` be the result of `std::invoke(std::forward<F>(f), value())`. Returns a `std::optional<U>`. The return value is empty if `*this` is empty, otherwise the return value of `std::invoke(std::forward<F>(f), value())` is returned.
-  /// \group and_then
-  /// \synopsis template <class F>\nconstexpr auto and_then(F &&f) &;
+  /// Carries out some operation which returns an optional on the stored object
+  /// if there is one. \requires `std::invoke(std::forward<F>(f), value())`
+  /// returns a `std::optional<U>` for some `U`. \returns Let `U` be the result
+  /// of `std::invoke(std::forward<F>(f), value())`. Returns a
+  /// `std::optional<U>`. The return value is empty if `*this` is empty,
+  /// otherwise the return value of `std::invoke(std::forward<F>(f), value())`
+  /// is returned. \group and_then \synopsis template <class F>\nconstexpr auto
+  /// and_then(F &&f) &;
   template <class F>
   TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T> and_then(F &&f) & {
     using result = detail::invoke_result_t<F, T>;
@@ -385,7 +380,7 @@ public:
                        : result(nullopt);
   }
 
-  #ifndef TL_OPTIONAL_NO_CONSTRR
+#ifndef TL_OPTIONAL_NO_CONSTRR
   /// \group and_then
   /// \synopsis template <class F>\nconstexpr auto and_then(F &&f) const &&;
   template <class F>
@@ -397,187 +392,71 @@ public:
     return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this))
                        : result(nullopt);
   }
-  #endif
+#endif
 
+#ifdef TL_OPTIONAL_CXX14
   /// \brief Carries out some operation on the stored object if there is one.
-  /// \returns Let `U` be the result of `std::invoke(std::forward<F>(f), value())`. Returns a `std::optional<U>`. The return value is empty if `*this` is empty, otherwise an `optional<U>` is constructed from the return value of `std::invoke(std::forward<F>(f), value())` and is returned.
-  /// \group map
-  /// \synopsis template <class F> auto map(F &&f) &;
-  template <class F, detail::disable_if_optional<F> * = nullptr,
-            detail::disable_if_ret_void<F, T &> * = nullptr>
-      detail::get_map_return<F, T &> map(F &&f) &
-      noexcept(noexcept(detail::invoke(std::forward<F>(f),
-                                       std::declval<T &>()))) {
-    using result = detail::get_map_return<F, T &>;
-    return has_value() ? detail::invoke(std::forward<F>(f), **this)
-                       : result(nullopt);
+  /// \returns Let `U` be the result of `std::invoke(std::forward<F>(f),
+  /// value())`. Returns a `std::optional<U>`. The return value is empty if
+  /// `*this` is empty, otherwise an `optional<U>` is constructed from the
+  /// return value of `std::invoke(std::forward<F>(f), value())` and is
+  /// returned. \group map \synopsis template <class F> auto map(F &&f) &;
+  template <class F> auto map(F &&f) & {
+    return map_impl(*this, std::forward<F>(f));
   }
 
-  /// \exclude
-  template <class F, detail::disable_if_optional<F> * = nullptr,
-            detail::enable_if_ret_void<F, T &> * = nullptr>
-  detail::get_map_return<F, T &> map(F &&f) & {
-    if (!has_value())
-      return nullopt;
-
-    detail::invoke(std::forward<F>(f), **this);
-    return monostate{};
+  template <class F> auto map(F &&f) && {
+    return map_impl(std::move(*this), std::forward<F>(f));
   }
 
-  /// \exclude
-  template <class F, detail::enable_if_optional<F> * = nullptr,
-            detail::disable_if_ret_void<F, T &> * = nullptr>
-  detail::get_map_return<F, T &> map(F &&f) & {
-    using result = detail::get_map_return<F, T &>;
-    return (f.has_value() && has_value())
-               ? detail::invoke(*std::forward<F>(f), **this)
-               : result(nullopt);
+  template <class F> auto map(F &&f) const & {
+    return map_impl(*this, std::forward<F>(f));
   }
 
-  /// \exclude
-  template <class F, detail::enable_if_optional<F> * = nullptr,
-            detail::enable_if_ret_void<F, T &> * = nullptr>
-  detail::get_map_return<F, T &> map(F &&f) & {
-    if (!f.has_value() || !has_value())
-      return nullopt;
-
-    detail::invoke(*std::forward<F>(f), **this);
-    return monostate{};
+#ifndef TL_OPTIONAL_NO_CONSTRR
+  template <class F> auto map(F &&f) const && {
+    return map_impl(std::move(*this), std::forward<F>(f));
+  }
+#endif
+#else
+  /// \brief Carries out some operation on the stored object if there is one.
+  /// \returns Let `U` be the result of `std::invoke(std::forward<F>(f),
+  /// value())`. Returns a `std::optional<U>`. The return value is empty if
+  /// `*this` is empty, otherwise an `optional<U>` is constructed from the
+  /// return value of `std::invoke(std::forward<F>(f), value())` and is
+  /// returned. \group map \synopsis template <class F> auto map(F &&f) &;
+  template <class F>
+  decltype(map_impl(std::declval<optional &>(), std::declval<F &&>()))
+  map(F &&f) & {
+    return map_impl(*this, std::forward<F>(f));
   }
 
-  /// \group map
-  /// \synopsis template <class F> auto map(F &&f) &&;
-  template <class F, detail::disable_if_optional<F> * = nullptr,
-            detail::disable_if_ret_void<F, T &&> * = nullptr>
-  detail::get_map_return<F, T &&> map(F &&f) && {
-    using result = detail::get_map_return<F, T &&>;
-    return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this))
-                       : result(nullopt);
+  template <class F>
+  decltype(map_impl(std::declval<optional &&>(), std::declval<F &&>()))
+  map(F &&f) && {
+    return map_impl(std::move(*this), std::forward<F>(f));
   }
 
-  /// \exclude
-  template <class F, detail::disable_if_optional<F> * = nullptr,
-            detail::enable_if_ret_void<F, T &&> * = nullptr>
-  detail::get_map_return<F, T &&> map(F &&f) && {
-    if (!has_value())
-      return nullopt;
-
-    detail::invoke(std::forward<F>(f), std::move(**this));
-    return monostate{};
+  template <class F>
+  decltype(map_impl(std::declval<const optional &>(), std::declval<F &&>()))
+  map(F &&f) const & {
+    return map_impl(*this, std::forward<F>(f));
   }
 
-  /// \exclude
-  template <class F, detail::enable_if_optional<F> * = nullptr,
-            detail::disable_if_ret_void<F, T &&> * = nullptr>
-  detail::get_map_return<F, T &&> map(F &&f) && {
-    using result = detail::get_map_return<F, T &&>;
-    return (f.has_value() && has_value())
-               ? detail::invoke(*std::forward<F>(f), std::move(**this))
-               : result(nullopt);
+#ifndef TL_OPTIONAL_NO_CONSTRR
+  template <class F>
+  decltype(map_impl(std::declval<const optional &&>(), std::declval<F &&>()))
+  map(F &&f) const && {
+    return map_impl(std::move(*this), std::forward<F>(f));
   }
-
-  /// \exclude
-  template <class F, detail::enable_if_optional<F> * = nullptr,
-            detail::enable_if_ret_void<F, T &&> * = nullptr>
-  detail::get_map_return<F, T &&> map(F &&f) && {
-    if (!f.has_value() || !has_value())
-      return nullopt;
-
-    detail::invoke(*std::forward<F>(f), std::move(**this));
-    return monostate{};
-  }
-
-  /// \group map
-  /// \synopsis template <class F> auto map(F &&f) const &;
-  template <class F, detail::disable_if_optional<F> * = nullptr,
-            detail::disable_if_ret_void<F, T const &> * = nullptr>
-  constexpr detail::get_map_return<F, T const &> map(F &&f) const & {
-    using result = detail::get_map_return<F, T const &>;
-    return this->has_value()
-               ? result(detail::invoke(std::forward<F>(f), **this))
-               : result(nullopt);
-  }
-
-  /// \exclude
-  template <class F, detail::disable_if_optional<F> * = nullptr,
-            detail::enable_if_ret_void<F, T const &> * = nullptr>
-  detail::get_map_return<F, T const &> map(F &&f) const & {
-    if (!has_value())
-      return nullopt;
-
-    detail::invoke(std::forward<F>(f), **this);
-    return monostate{};
-  }
-
-  /// \exclude
-  template <class F, detail::enable_if_optional<F> * = nullptr,
-            detail::disable_if_ret_void<F, T const &> * = nullptr>
-  constexpr detail::get_map_return<F, T const &> map(F &&f) const & {
-    using result = detail::get_map_return<F, const T &>;
-    return (f.has_value() && has_value())
-               ? detail::invoke(*std::forward<F>(f), **this)
-               : result(nullopt);
-  }
-
-  /// \exclude
-  template <class F, detail::enable_if_optional<F> * = nullptr,
-            detail::enable_if_ret_void<F, T const &> * = nullptr>
-  detail::get_map_return<F, T const &> map(F &&f) const & {
-    if (!f.has_value() || !has_value())
-      return nullopt;
-
-    detail::invoke(*std::forward<F>(f), **this);
-    return monostate{};
-  }
-
-  #ifndef TL_OPTIONAL_NO_CONSTRR
-  /// \group map
-  /// \synopsis template <class F> auto map(F &&f) const &&;
-  template <class F, detail::disable_if_optional<F> * = nullptr,
-            detail::disable_if_ret_void<F, T const &&> * = nullptr>
-  constexpr detail::get_map_return<F, T const &&> map(F &&f) const && {
-    using result = detail::get_map_return<F, const T &&>;
-    return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this))
-                       : result(nullopt);
-  }
-
-  /// \exclude
-  template <class F, detail::disable_if_optional<F> * = nullptr,
-            detail::enable_if_ret_void<F, T const &&> * = nullptr>
-  detail::get_map_return<F, T const &&> map(F &&f) const && {
-    if (!has_value())
-      return nullopt;
-
-    detail::invoke(std::forward<F>(f), std::move(**this));
-    return monostate{};
-  }
-
-  /// \exclude
-  template <class F, detail::enable_if_optional<F> * = nullptr,
-            detail::disable_if_ret_void<F, T const &&> * = nullptr>
-  constexpr detail::get_map_return<F, T const &&> map(F &&f) const && {
-    using result = detail::get_map_return<F, const T &&>;
-    return (f.has_value() && has_value())
-               ? detail::invoke(*std::forward<F>(f), std::move(**this))
-               : result(nullopt);
-  }
-
-  /// \exclude
-  template <class F, detail::enable_if_optional<F> * = nullptr,
-            detail::enable_if_ret_void<F, T const &&> * = nullptr>
-  detail::get_map_return<F, T &> map(F &&f) const && {
-    if (!f.has_value() || !has_value())
-      return nullopt;
-
-    detail::invoke(*std::forward<F>(f), std::move(**this));
-    return monostate{};
-  }
-  #endif
+#endif
+#endif
 
   /// \brief Calls `f` if the optional is empty
-  /// \requires `std::invoke_result_t<F>` must be void or convertible to `optional<T>`.
-  /// \effects If `*this` has a value, returns `*this`. Otherwise, if `f` returns `void`, calls `std::forward<F>(f)` and returns `std::nullopt`. Otherwise, returns `std::forward<F>(f)()`.
-  /// \group or_else
+  /// \requires `std::invoke_result_t<F>` must be void or convertible to
+  /// `optional<T>`. \effects If `*this` has a value, returns `*this`.
+  /// Otherwise, if `f` returns `void`, calls `std::forward<F>(f)` and returns
+  /// `std::nullopt`. Otherwise, returns `std::forward<F>(f)()`. \group or_else
   /// \synopsis template <class F> optional<T> or_else (F &&f) &;
   template <class F, detail::enable_if_ret_void<F> * = nullptr>
   optional<T> TL_OPTIONAL_11_CONSTEXPR or_else(F &&f) & {
@@ -628,7 +507,7 @@ public:
     return has_value() ? *this : std::forward<F>(f)();
   }
 
-  #ifndef TL_OPTIONAL_NO_CONSTRR
+#ifndef TL_OPTIONAL_NO_CONSTRR
   /// \exclude
   template <class F, detail::enable_if_ret_void<F> * = nullptr>
   optional<T> or_else(F &&f) const && {
@@ -644,12 +523,11 @@ public:
   optional<T> or_else(F &&f) const && {
     return has_value() ? std::move(*this) : std::forward<F>(f)();
   }
-  #endif
+#endif
 
-  /// \brief Maps the stored value with `f` if there is one, otherwise returns `u`
-  /// \details If there is a value stored, then `f` is called with `**this` and the value is returned.
-  /// Otherwise `u` is returned.
-  /// \group map_or
+  /// \brief Maps the stored value with `f` if there is one, otherwise returns
+  /// `u` \details If there is a value stored, then `f` is called with `**this`
+  /// and the value is returned. Otherwise `u` is returned. \group map_or
   template <class F, class U> U map_or(F &&f, U &&u) & {
     return has_value() ? detail::invoke(std::forward<F>(f), **this)
                        : std::forward<U>(u);
@@ -667,19 +545,19 @@ public:
                        : std::forward<U>(u);
   }
 
-  #ifndef TL_OPTIONAL_NO_CONSTRR
+#ifndef TL_OPTIONAL_NO_CONSTRR
   /// \group map_or
   template <class F, class U> U map_or(F &&f, U &&u) const && {
     return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this))
                        : std::forward<U>(u);
   }
-  #endif
+#endif
 
-  /// \brief Maps the stored value with `f` if there is one, otherwise calls `u` and returns the result.
-  /// \details If there is a value stored, then `f` is called with `**this` and the value is returned.
-  /// Otherwise `std::forward<U>(u)()` is returned.
-  /// \group map_or_else
-  /// \synopsis template <class F, class U>\nauto map_or_else(F &&f, U &&u) &;
+  /// \brief Maps the stored value with `f` if there is one, otherwise calls `u`
+  /// and returns the result. \details If there is a value stored, then `f` is
+  /// called with `**this` and the value is returned. Otherwise
+  /// `std::forward<U>(u)()` is returned. \group map_or_else \synopsis template
+  /// <class F, class U>\nauto map_or_else(F &&f, U &&u) &;
   template <class F, class U>
   detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
     return has_value() ? detail::invoke(std::forward<F>(f), **this)
@@ -695,74 +573,76 @@ public:
   }
 
   /// \group map_or_else
-  /// \synopsis template <class F, class U>\nauto map_or_else(F &&f, U &&u) const &;
+  /// \synopsis template <class F, class U>\nauto map_or_else(F &&f, U &&u)
+  /// const &;
   template <class F, class U>
   detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
     return has_value() ? detail::invoke(std::forward<F>(f), **this)
                        : std::forward<U>(u)();
   }
 
-  #ifndef TL_OPTIONAL_NO_CONSTRR
+#ifndef TL_OPTIONAL_NO_CONSTRR
   /// \group map_or_else
-  /// \synopsis template <class F, class U>\nauto map_or_else(F &&f, U &&u) const &&;
+  /// \synopsis template <class F, class U>\nauto map_or_else(F &&f, U &&u)
+  /// const &&;
   template <class F, class U>
   detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
     return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this))
                        : std::forward<U>(u)();
   }
-  #endif
+#endif
 
   /// \returns `u` if `*this` has a value, otherwise an empty optional.
   template <class U>
-  constexpr optional<typename std::decay<U>::type> conjunction (U &&u) const {
+  constexpr optional<typename std::decay<U>::type> conjunction(U &&u) const {
     using result = optional<detail::decay_t<U>>;
     return has_value() ? result{u} : result{nullopt};
   }
 
   /// \returns `rhs` if `*this` is empty, otherwise the current value.
   /// \group disjunction
-  TL_OPTIONAL_11_CONSTEXPR optional disjunction (const optional &rhs) & {
+  TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & {
     return has_value() ? *this : rhs;
   }
 
   /// \group disjunction
-  constexpr optional disjunction (const optional &rhs) const & {
+  constexpr optional disjunction(const optional &rhs) const & {
     return has_value() ? *this : rhs;
   }
 
   /// \group disjunction
-  TL_OPTIONAL_11_CONSTEXPR optional disjunction (const optional &rhs) && {
+  TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && {
     return has_value() ? std::move(*this) : rhs;
   }
 
-  #ifndef TL_OPTIONAL_NO_CONSTRR
+#ifndef TL_OPTIONAL_NO_CONSTRR
   /// \group disjunction
-  constexpr optional disjunction (const optional &rhs) const && {
+  constexpr optional disjunction(const optional &rhs) const && {
     return has_value() ? std::move(*this) : rhs;
   }
-  #endif
+#endif
 
   /// \group disjunction
-  TL_OPTIONAL_11_CONSTEXPR optional disjunction (optional &&rhs) & {
+  TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & {
     return has_value() ? *this : std::move(rhs);
   }
 
   /// \group disjunction
-  constexpr optional disjunction (optional &&rhs) const & {
+  constexpr optional disjunction(optional &&rhs) const & {
     return has_value() ? *this : std::move(rhs);
   }
 
   /// \group disjunction
-  TL_OPTIONAL_11_CONSTEXPR optional disjunction (optional &&rhs) && {
+  TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && {
     return has_value() ? std::move(*this) : std::move(rhs);
   }
 
-  #ifndef TL_OPTIONAL_NO_CONSTRR
+#ifndef TL_OPTIONAL_NO_CONSTRR
   /// \group disjunction
-  constexpr optional disjunction (optional &&rhs) const && {
+  constexpr optional disjunction(optional &&rhs) const && {
     return has_value() ? std::move(*this) : std::move(rhs);
   }
-  #endif
+#endif
 
   /// Takes the value out of the optional, leaving it empty
   /// \group take
@@ -786,14 +666,14 @@ public:
     return ret;
   }
 
-  #ifndef TL_OPTIONAL_NO_CONSTRR
+#ifndef TL_OPTIONAL_NO_CONSTRR
   /// \group take
   optional take() const && {
     optional ret = std::move(*this);
     reset();
     return ret;
   }
-  #endif
+#endif
 
   using value_type = T;
 
@@ -828,10 +708,10 @@ public:
     }
   }
 
-
   /// Constructs the stored value in-place using the given arguments.
   /// \group in_place
-  /// \synopsis template <class... Args> constexpr explicit optional(in_place_t, Args&&... args);
+  /// \synopsis template <class... Args> constexpr explicit optional(in_place_t,
+  /// Args&&... args);
   template <class... Args>
   constexpr explicit optional(
       detail::enable_if_t<std::is_constructible<T, Args...>::value, in_place_t>,
@@ -839,7 +719,8 @@ public:
       : base(in_place, std::forward<Args>(args)...) {}
 
   /// \group in_place
-  /// \synopsis template <class U, class... Args>\nconstexpr explicit optional(in_place_t, std::initializer_list<U>&, Args&&... args);
+  /// \synopsis template <class U, class... Args>\nconstexpr explicit
+  /// optional(in_place_t, std::initializer_list<U>&, Args&&... args);
   template <class U, class... Args>
   TL_OPTIONAL_11_CONSTEXPR explicit optional(
       detail::enable_if_t<std::is_constructible<T, std::initializer_list<U> &,
@@ -921,7 +802,8 @@ public:
   // TODO conditionally delete, check exception guarantee
   /// Copy assignment.
   ///
-  /// Copies the value from `rhs` if there is one. Otherwise resets the stored value in `*this`.
+  /// Copies the value from `rhs` if there is one. Otherwise resets the stored
+  /// value in `*this`.
   optional &operator=(const optional &rhs) {
     if (has_value()) {
       if (rhs.has_value()) {
@@ -943,7 +825,8 @@ public:
   // TODO conditionally delete, check exception guarantee
   /// Move assignment.
   ///
-  /// Moves the value from `rhs` if there is one. Otherwise resets the stored value in `*this`.
+  /// Moves the value from `rhs` if there is one. Otherwise resets the stored
+  /// value in `*this`.
   optional &operator=(optional &&rhs) noexcept(
       std::is_nothrow_move_assignable<T>::value
           &&std::is_nothrow_move_constructible<T>::value) {
@@ -965,8 +848,8 @@ public:
   }
 
   // TODO conditionally delete, check exception guarantee
-  /// Assigns the stored value from `u`, destroying the old value if there was one.
-  /// \synopsis optional &operator=(U &&u);
+  /// Assigns the stored value from `u`, destroying the old value if there was
+  /// one. \synopsis optional &operator=(U &&u);
   template <class U = T, detail::enable_assign_forward<T, U> * = nullptr>
   optional &operator=(U &&u) {
     if (has_value()) {
@@ -982,8 +865,8 @@ public:
   // TODO check exception guarantee
   /// Converting copy assignment operator.
   ///
-  /// Copies the value from `rhs` if there is one. Otherwise resets the stored value in `*this`.
-  /// \synopsis optional &operator=(const optional<U> & rhs);
+  /// Copies the value from `rhs` if there is one. Otherwise resets the stored
+  /// value in `*this`. \synopsis optional &operator=(const optional<U> & rhs);
   template <class U,
             detail::enable_assign_from_other<T, U, const U &> * = nullptr>
   optional &operator=(const optional<U> &rhs) {
@@ -1007,8 +890,8 @@ public:
   // TODO check exception guarantee
   /// Converting move assignment operator.
   ///
-  /// Moves the value from `rhs` if there is one. Otherwise resets the stored value in `*this`.
-  /// \synopsis optional &operator=(optional<U> && rhs);
+  /// Moves the value from `rhs` if there is one. Otherwise resets the stored
+  /// value in `*this`. \synopsis optional &operator=(optional<U> && rhs);
   template <class U, detail::enable_assign_from_other<T, U, U> * = nullptr>
   optional &operator=(optional<U> &&rhs) {
     if (has_value()) {
@@ -1039,7 +922,8 @@ public:
   }
 
   /// \group emplace
-  /// \synopsis template <class U, class... Args>\nT& emplace(std::initializer_list<U> il, Args &&... args);
+  /// \synopsis template <class U, class... Args>\nT&
+  /// emplace(std::initializer_list<U> il, Args &&... args);
   template <class U, class... Args>
   detail::enable_if_t<
       std::is_constructible<T, std::initializer_list<U> &, Args &&...>::value,
@@ -1053,7 +937,8 @@ public:
   ///
   /// If neither optionals have a value, nothing happens.
   /// If both have a value, the values are swapped.
-  /// If one has a value, it is moved to the other and the movee is left valueless.
+  /// If one has a value, it is moved to the other and the movee is left
+  /// valueless.
   void
   swap(optional &rhs) noexcept(std::is_nothrow_move_constructible<T>::value
                                    &&detail::is_nothrow_swappable<T>::value) {
@@ -1100,10 +985,10 @@ public:
     return std::move(this->m_value);
   }
 
-  #ifndef TL_OPTIONAL_NO_CONSTRR
+#ifndef TL_OPTIONAL_NO_CONSTRR
   /// \exclude
   constexpr const T &&operator*() const && { return std::move(this->m_value); }
-  #endif
+#endif
 
   /// \returns whether or not the optional has a value
   /// \group has_value
@@ -1114,9 +999,8 @@ public:
     return this->m_has_value;
   }
 
-  /// \returns the contained value if there is one, otherwise throws [bad_optional_access]
-  /// \group value
-  /// \synopsis constexpr T &value();
+  /// \returns the contained value if there is one, otherwise throws
+  /// [bad_optional_access] \group value \synopsis constexpr T &value();
   TL_OPTIONAL_11_CONSTEXPR T &value() & {
     if (has_value())
       return this->m_value;
@@ -1136,14 +1020,14 @@ public:
     throw bad_optional_access();
   }
 
-  #ifndef TL_OPTIONAL_NO_CONSTRR
+#ifndef TL_OPTIONAL_NO_CONSTRR
   /// \exclude
   constexpr const T &&value() const && {
     if (has_value())
       return std::move(this->m_value);
     throw bad_optional_access();
   }
-  #endif
+#endif
 
   /// \returns the stored value if there is one, otherwise returns `u`
   /// \group value_or
@@ -1169,15 +1053,14 @@ public:
       this->m_has_value = false;
     }
   }
-
-
 };
 
 /// \group relop
 /// \brief Compares two optional objects
-/// \details If both optionals contain a value, they are compared with `T`s relational operators.
-/// Otherwise `lhs` and `rhs` are equal only if they are both empty, and `lhs` is less than `rhs`
-/// only if `rhs` is empty and `lhs` is not.
+/// \details If both optionals contain a value, they are compared with `T`s
+/// relational operators. Otherwise `lhs` and `rhs` are equal only if they are
+/// both empty, and `lhs` is less than `rhs` only if `rhs` is empty and `lhs` is
+/// not.
 template <class T, class U>
 inline constexpr bool operator==(const optional<T> &lhs,
                                  const optional<U> &rhs) {
@@ -1279,11 +1162,11 @@ inline constexpr bool operator>=(nullopt_t, const optional<T> &rhs) noexcept {
   return !rhs.has_value();
 }
 
-
 /// \group relop_t
 /// \brief Compares the optional with a value.
-/// \details If the optional has a value, it is compared with the other value using `T`s relational operators.
-/// Otherwise, the optional is considered less than the value.
+/// \details If the optional has a value, it is compared with the other value
+/// using `T`s relational operators. Otherwise, the optional is considered less
+/// than the value.
 template <class T, class U>
 inline constexpr bool operator==(const optional<T> &lhs, const U &rhs) {
   return lhs.has_value() ? *lhs == rhs : false;
@@ -1371,6 +1254,59 @@ inline constexpr optional<T> make_optional(std::initializer_list<U> il,
 template <class T> optional(T)->optional<T>;
 #endif
 
+/// \exclude
+namespace detail {
+#ifdef TL_OPTIONAL_CX14
+template <class Opt, class F,
+          class Ret = decltype(detail::invoke(std::declval<F>(),
+                                              *std::declval<Opt>())),
+          detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
+auto map_impl(Opt &&opt, F &&f) {
+  return opt.has_value()
+             ? detail::invoke(std::forward<F>(f), *std::forward<Opt>(opt))
+             : optional<Ret>(nullopt);
+}
+
+template <class Opt, class F,
+          class Ret = decltype(detail::invoke(std::declval<F>(),
+                                              *std::declval<Opt>())),
+          detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
+auto map_impl(Opt &&opt, F &&f) {
+  if (opt.has_value()) {
+    detail::invoke(std::forward<F>(f), *std::forward<Opt>(opt));
+    return monostate{};
+  }
+
+  return optional<Ret>(nullopt);
+}
+#else
+template <class Opt, class F,
+          class Ret = decltype(detail::invoke(std::declval<F>(),
+                                              *std::declval<Opt>())),
+          detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
+
+auto map_impl(Opt &&opt, F &&f) -> optional<Ret> {
+  return opt.has_value()
+             ? detail::invoke(std::forward<F>(f), *std::forward<Opt>(opt))
+             : optional<Ret>(nullopt);
+}
+
+template <class Opt, class F,
+          class Ret = decltype(detail::invoke(std::declval<F>(),
+                                              *std::declval<Opt>())),
+          detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
+
+auto map_impl(Opt &&opt, F &&f) -> optional<monostate> {
+  if (opt.has_value()) {
+    detail::invoke(std::forward<F>(f), *std::forward<Opt>(opt));
+    return monostate{};
+  }
+
+  return nullopt;
+}
+#endif
+} // namespace detail
+
 } // namespace tl
 
 namespace std {
diff --git a/tests/extensions.cpp b/tests/extensions.cpp
index 53172d0..2ef9bce 100644
--- a/tests/extensions.cpp
+++ b/tests/extensions.cpp
@@ -12,342 +12,272 @@ constexpr int get_int(int) { return 42; }
 TL_OPTIONAL_11_CONSTEXPR tl::optional<int> get_opt_int(int) { return 42; }
 
 // What is Clang Format up to?!
-TEST_CASE("Monadic operations",
-          "[monadic]"){SECTION("map"){// lhs is empty
-                                      tl::optional<int> o1;
-auto o1r = o1.map([](int i) { return i + 2; });
-STATIC_REQUIRE((std::is_same<decltype(o1r), tl::optional<int>>::value));
-REQUIRE(!o1r);
+TEST_CASE("Monadic operations", "[monadic]") {
+  SECTION("map") { // lhs is empty
+    tl::optional<int> o1;
+    auto o1r = o1.map([](int i) { return i + 2; });
+    STATIC_REQUIRE((std::is_same<decltype(o1r), tl::optional<int>>::value));
+    REQUIRE(!o1r);
 
-// lhs has value
-tl::optional<int> o2 = 40;
-auto o2r = o2.map([](int i) { return i + 2; });
-STATIC_REQUIRE((std::is_same<decltype(o2r), tl::optional<int>>::value));
-REQUIRE(o2r.value() == 42);
+    // lhs has value
+    tl::optional<int> o2 = 40;
+    auto o2r = o2.map([](int i) { return i + 2; });
+    STATIC_REQUIRE((std::is_same<decltype(o2r), tl::optional<int>>::value));
+    REQUIRE(o2r.value() == 42);
 
-struct rval_call_map {
-  double operator()(int) && { return 42.0; };
-};
-
-// ensure that function object is forwarded
-tl::optional<int> o3 = 42;
-auto o3r = o3.map(rval_call_map{});
-STATIC_REQUIRE((std::is_same<decltype(o3r), tl::optional<double>>::value));
-REQUIRE(o3r.value() == 42);
-
-// ensure that lhs is forwarded
-tl::optional<int> o4 = 40;
-auto o4r = std::move(o4).map([](int &&i) { return i + 2; });
-STATIC_REQUIRE((std::is_same<decltype(o4r), tl::optional<int>>::value));
-REQUIRE(o4r.value() == 42);
-
-// ensure that lhs is const-propagated
-const tl::optional<int> o5 = 40;
-auto o5r = o5.map([](const int &i) { return i + 2; });
-STATIC_REQUIRE((std::is_same<decltype(o5r), tl::optional<int>>::value));
-REQUIRE(o5r.value() == 42);
-
-// test applicative functor
-tl::optional<int> o6 = 40;
-auto f6 = tl::make_optional([](const int &i) { return i + 2; });
-auto o6r = o6.map(f6);
-STATIC_REQUIRE((std::is_same<decltype(o6r), tl::optional<int>>::value));
-REQUIRE(o6r.value() == 42);
-
-// test void return
-tl::optional<int> o7 = 40;
-auto f7 = tl::make_optional([](const int &i) { return; });
-auto o7r = o7.map(f7);
-STATIC_REQUIRE(
-    (std::is_same<decltype(o7r), tl::optional<tl::monostate>>::value));
-REQUIRE(o6r.has_value());
-
-// test each overload in turn
-tl::optional<int> o8 = 42;
-auto o8r = o8.map([](int) { return 42; });
-REQUIRE(*o8r == 42);
-
-tl::optional<int> o9 = 42;
-auto o9r = o9.map([](int) { return; });
-REQUIRE(o9r);
-
-tl::optional<int> o10 = 42;
-auto o10r = o10.map(tl::make_optional([](int) { return 42; }));
-REQUIRE(*o10r == 42);
-
-tl::optional<int> o11 = 42;
-auto o11r = o11.map(tl::make_optional([](int) { return; }));
-REQUIRE(o11r);
-
-tl::optional<int> o12 = 42;
-auto o12r = std::move(o12).map([](int) { return 42; });
-REQUIRE(*o12r == 42);
-
-tl::optional<int> o13 = 42;
-auto o13r = std::move(o13).map([](int) { return; });
-REQUIRE(o13r);
-
-tl::optional<int> o14 = 42;
-auto o14r = std::move(o14).map(tl::make_optional([](int) { return 42; }));
-REQUIRE(*o14r == 42);
-
-tl::optional<int> o15 = 42;
-auto o15r = std::move(o15).map(tl::make_optional([](int) { return; }));
-REQUIRE(o15r);
-
-const tl::optional<int> o16 = 42;
-auto o16r = o16.map([](int) { return 42; });
-REQUIRE(*o16r == 42);
-
-const tl::optional<int> o17 = 42;
-auto o17r = o17.map([](int) { return; });
-REQUIRE(o17r);
-
-const tl::optional<int> o18 = 42;
-auto o18r = o18.map(tl::make_optional([](int) { return 42; }));
-REQUIRE(*o18r == 42);
-
-const tl::optional<int> o19 = 42;
-auto o19r = o19.map(tl::make_optional([](int) { return; }));
-REQUIRE(o19r);
-
-const tl::optional<int> o20 = 42;
-auto o20r = std::move(o20).map([](int) { return 42; });
-REQUIRE(*o20r == 42);
-
-const tl::optional<int> o21 = 42;
-auto o21r = std::move(o21).map([](int) { return; });
-REQUIRE(o21r);
-
-const tl::optional<int> o22 = 42;
-auto o22r = std::move(o22).map(tl::make_optional([](int) { return 42; }));
-REQUIRE(*o22r == 42);
-
-const tl::optional<int> o23 = 42;
-auto o23r = std::move(o23).map(tl::make_optional([](int) { return; }));
-REQUIRE(o23r);
-
-tl::optional<int> o24 = tl::nullopt;
-auto o24r = o24.map([](int) { return 42; });
-REQUIRE(!o24r);
-
-tl::optional<int> o25 = tl::nullopt;
-auto o25r = o25.map([](int) { return; });
-REQUIRE(!o25r);
-
-tl::optional<int> o26 = tl::nullopt;
-auto o26r = o26.map(tl::make_optional([](int) { return 42; }));
-REQUIRE(!o26r);
-
-tl::optional<int> o27 = tl::nullopt;
-auto o27r = o27.map(tl::make_optional([](int) { return; }));
-REQUIRE(!o27r);
-
-tl::optional<int> o28 = tl::nullopt;
-auto o28r = std::move(o28).map([](int) { return 42; });
-REQUIRE(!o28r);
-
-tl::optional<int> o29 = tl::nullopt;
-auto o29r = std::move(o29).map([](int) { return; });
-REQUIRE(!o29r);
-
-tl::optional<int> o30 = tl::nullopt;
-auto o30r = std::move(o30).map(tl::make_optional([](int) { return 42; }));
-REQUIRE(!o30r);
-
-tl::optional<int> o31 = tl::nullopt;
-auto o31r = std::move(o31).map(tl::make_optional([](int) { return; }));
-REQUIRE(!o31r);
-
-const tl::optional<int> o32 = tl::nullopt;
-auto o32r = o32.map([](int) { return 42; });
-REQUIRE(!o32r);
-
-const tl::optional<int> o33 = tl::nullopt;
-auto o33r = o33.map([](int) { return; });
-REQUIRE(!o33r);
-
-const tl::optional<int> o34 = tl::nullopt;
-auto o34r = o34.map(tl::make_optional([](int) { return 42; }));
-REQUIRE(!o34r);
-
-const tl::optional<int> o35 = tl::nullopt;
-auto o35r = o35.map(tl::make_optional([](int) { return; }));
-REQUIRE(!o35r);
-
-const tl::optional<int> o36 = tl::nullopt;
-auto o36r = std::move(o36).map([](int) { return 42; });
-REQUIRE(!o36r);
-
-const tl::optional<int> o37 = tl::nullopt;
-auto o37r = std::move(o37).map([](int) { return; });
-REQUIRE(!o37r);
-
-const tl::optional<int> o38 = tl::nullopt;
-auto o38r = std::move(o38).map(tl::make_optional([](int) { return 42; }));
-REQUIRE(!o38r);
-
-const tl::optional<int> o39 = tl::nullopt;
-auto o39r = std::move(o39).map(tl::make_optional([](int) { return; }));
-REQUIRE(!o39r);
-}
-
-SECTION("map constexpr") {
-#if !defined(_MSC_VER) && !defined(TL_OPTIONAL_GCC49)
-  // test each overload in turn
-  constexpr tl::optional<int> o16 = 42;
-  constexpr auto o16r = o16.map(get_int);
-  STATIC_REQUIRE(*o16r == 42);
-
-  constexpr tl::optional<int> o18 = 42;
-  constexpr auto opt_int = tl::make_optional(get_int);
-  constexpr auto o18r = o18.map(opt_int);
-  STATIC_REQUIRE(*o18r == 42);
-
-  constexpr tl::optional<int> o20 = 42;
-  constexpr auto o20r = std::move(o20).map(get_int);
-  STATIC_REQUIRE(*o20r == 42);
-
-  constexpr tl::optional<int> o22 = 42;
-  constexpr auto o22r = std::move(o22).map(opt_int);
-  STATIC_REQUIRE(*o22r == 42);
-
-  constexpr tl::optional<int> o32 = tl::nullopt;
-  constexpr auto o32r = o32.map(get_int);
-  STATIC_REQUIRE(!o32r);
-
-  constexpr tl::optional<int> o34 = tl::nullopt;
-  constexpr auto o34r = o34.map(opt_int);
-  STATIC_REQUIRE(!o34r);
-
-  constexpr tl::optional<int> o36 = tl::nullopt;
-  constexpr auto o36r = std::move(o36).map(get_int);
-  STATIC_REQUIRE(!o36r);
-
-  constexpr tl::optional<int> o38 = tl::nullopt;
-  constexpr auto o38r = std::move(o38).map(opt_int);
-  STATIC_REQUIRE(!o38r);
-#endif
-}
-
-SECTION("and_then") {
-
-  // lhs is empty
-  tl::optional<int> o1;
-  auto o1r = o1.and_then([](int i) { return tl::optional<float>{42}; });
-  STATIC_REQUIRE((std::is_same<decltype(o1r), tl::optional<float>>::value));
-  REQUIRE(!o1r);
-
-  // lhs has value
-  tl::optional<int> o2 = 12;
-  auto o2r = o2.and_then([](int i) { return tl::optional<float>{42}; });
-  STATIC_REQUIRE((std::is_same<decltype(o2r), tl::optional<float>>::value));
-  REQUIRE(o2r.value() == 42.f);
-
-  // lhs is empty, rhs returns empty
-  tl::optional<int> o3;
-  auto o3r = o3.and_then([](int i) { return tl::optional<float>{}; });
-  STATIC_REQUIRE((std::is_same<decltype(o3r), tl::optional<float>>::value));
-  REQUIRE(!o3r);
-
-  // rhs returns empty
-  tl::optional<int> o4 = 12;
-  auto o4r = o4.and_then([](int i) { return tl::optional<float>{}; });
-  STATIC_REQUIRE((std::is_same<decltype(o4r), tl::optional<float>>::value));
-  REQUIRE(!o4r);
-
-  struct rval_call_and_then {
-    tl::optional<double> operator()(int) && {
-      return tl::optional<double>(42.0);
+    struct rval_call_map {
+      double operator()(int) && { return 42.0; };
     };
-  };
 
-  // ensure that function object is forwarded
-  tl::optional<int> o5 = 42;
-  auto o5r = o5.and_then(rval_call_and_then{});
-  STATIC_REQUIRE((std::is_same<decltype(o5r), tl::optional<double>>::value));
-  REQUIRE(o5r.value() == 42);
+    // ensure that function object is forwarded
+    tl::optional<int> o3 = 42;
+    auto o3r = o3.map(rval_call_map{});
+    STATIC_REQUIRE((std::is_same<decltype(o3r), tl::optional<double>>::value));
+    REQUIRE(o3r.value() == 42);
 
-  // ensure that lhs is forwarded
-  tl::optional<int> o6 = 42;
-  auto o6r =
-      std::move(o6).and_then([](int &&i) { return tl::optional<double>(i); });
-  STATIC_REQUIRE((std::is_same<decltype(o6r), tl::optional<double>>::value));
-  REQUIRE(o6r.value() == 42);
+    // ensure that lhs is forwarded
+    tl::optional<int> o4 = 40;
+    auto o4r = std::move(o4).map([](int &&i) { return i + 2; });
+    STATIC_REQUIRE((std::is_same<decltype(o4r), tl::optional<int>>::value));
+    REQUIRE(o4r.value() == 42);
 
-  // ensure that function object is const-propagated
-  const tl::optional<int> o7 = 42;
-  auto o7r = o7.and_then([](const int &i) { return tl::optional<double>(i); });
-  STATIC_REQUIRE((std::is_same<decltype(o7r), tl::optional<double>>::value));
-  REQUIRE(o7r.value() == 42);
+    // ensure that lhs is const-propagated
+    const tl::optional<int> o5 = 40;
+    auto o5r = o5.map([](const int &i) { return i + 2; });
+    STATIC_REQUIRE((std::is_same<decltype(o5r), tl::optional<int>>::value));
+    REQUIRE(o5r.value() == 42);
 
-  // test each overload in turn
-  tl::optional<int> o8 = 42;
-  auto o8r = o8.and_then([](int i) { return tl::make_optional(42); });
-  REQUIRE(*o8r == 42);
+    // test void return
+    tl::optional<int> o7 = 40;
+    auto f7 = [](const int &i) { return; };
+    auto o7r = o7.map(f7);
+    STATIC_REQUIRE(
+        (std::is_same<decltype(o7r), tl::optional<tl::monostate>>::value));
+    REQUIRE(o7r.has_value());
 
-  tl::optional<int> o9 = 42;
-  auto o9r =
-      std::move(o9).and_then([](int i) { return tl::make_optional(42); });
-  REQUIRE(*o9r == 42);
+    // test each overload in turn
+    tl::optional<int> o8 = 42;
+    auto o8r = o8.map([](int) { return 42; });
+    REQUIRE(*o8r == 42);
 
-  const tl::optional<int> o10 = 42;
-  auto o10r = o10.and_then([](int i) { return tl::make_optional(42); });
-  REQUIRE(*o10r == 42);
+    tl::optional<int> o9 = 42;
+    auto o9r = o9.map([](int) { return; });
+    REQUIRE(o9r);
 
-  const tl::optional<int> o11 = 42;
-  auto o11r =
-      std::move(o11).and_then([](int i) { return tl::make_optional(42); });
-  REQUIRE(*o11r == 42);
+    tl::optional<int> o12 = 42;
+    auto o12r = std::move(o12).map([](int) { return 42; });
+    REQUIRE(*o12r == 42);
 
-  tl::optional<int> o16 = tl::nullopt;
-  auto o16r = o16.and_then([](int i) { return tl::make_optional(42); });
-  REQUIRE(!o16r);
+    tl::optional<int> o13 = 42;
+    auto o13r = std::move(o13).map([](int) { return; });
+    REQUIRE(o13r);
 
-  tl::optional<int> o17 = tl::nullopt;
-  auto o17r =
-      std::move(o17).and_then([](int i) { return tl::make_optional(42); });
-  REQUIRE(!o17r);
+    const tl::optional<int> o16 = 42;
+    auto o16r = o16.map([](int) { return 42; });
+    REQUIRE(*o16r == 42);
 
-  const tl::optional<int> o18 = tl::nullopt;
-  auto o18r = o18.and_then([](int i) { return tl::make_optional(42); });
-  REQUIRE(!o18r);
+    const tl::optional<int> o17 = 42;
+    auto o17r = o17.map([](int) { return; });
+    REQUIRE(o17r);
 
-  const tl::optional<int> o19 = tl::nullopt;
-  auto o19r =
-      std::move(o19).and_then([](int i) { return tl::make_optional(42); });
-  REQUIRE(!o19r);
-}
+    const tl::optional<int> o20 = 42;
+    auto o20r = std::move(o20).map([](int) { return 42; });
+    REQUIRE(*o20r == 42);
 
-SECTION("constexpr and_then") {
+    const tl::optional<int> o21 = 42;
+    auto o21r = std::move(o21).map([](int) { return; });
+    REQUIRE(o21r);
+
+    tl::optional<int> o24 = tl::nullopt;
+    auto o24r = o24.map([](int) { return 42; });
+    REQUIRE(!o24r);
+
+    tl::optional<int> o25 = tl::nullopt;
+    auto o25r = o25.map([](int) { return; });
+    REQUIRE(!o25r);
+
+    tl::optional<int> o28 = tl::nullopt;
+    auto o28r = std::move(o28).map([](int) { return 42; });
+    REQUIRE(!o28r);
+
+    tl::optional<int> o29 = tl::nullopt;
+    auto o29r = std::move(o29).map([](int) { return; });
+    REQUIRE(!o29r);
+
+    const tl::optional<int> o32 = tl::nullopt;
+    auto o32r = o32.map([](int) { return 42; });
+    REQUIRE(!o32r);
+
+    const tl::optional<int> o33 = tl::nullopt;
+    auto o33r = o33.map([](int) { return; });
+    REQUIRE(!o33r);
+
+    const tl::optional<int> o36 = tl::nullopt;
+    auto o36r = std::move(o36).map([](int) { return 42; });
+    REQUIRE(!o36r);
+
+    const tl::optional<int> o37 = tl::nullopt;
+    auto o37r = std::move(o37).map([](int) { return; });
+    REQUIRE(!o37r);
+  }
+
+  SECTION("map constexpr") {
 #if !defined(_MSC_VER) && !defined(TL_OPTIONAL_GCC49)
-  constexpr tl::optional<int> o10 = 42;
-  constexpr auto o10r = o10.and_then(get_opt_int);
-  REQUIRE(*o10r == 42);
+    // test each overload in turn
+    constexpr tl::optional<int> o16 = 42;
+    constexpr auto o16r = o16.map(get_int);
+    STATIC_REQUIRE(*o16r == 42);
 
-  constexpr tl::optional<int> o11 = 42;
-  constexpr auto o11r = std::move(o11).and_then(get_opt_int);
-  REQUIRE(*o11r == 42);
+    constexpr tl::optional<int> o18 = 42;
+    constexpr auto opt_int = tl::make_optional(get_int);
+    constexpr auto o18r = o18.map(opt_int);
+    STATIC_REQUIRE(*o18r == 42);
 
-  constexpr tl::optional<int> o18 = tl::nullopt;
-  constexpr auto o18r = o18.and_then(get_opt_int);
-  REQUIRE(!o18r);
+    constexpr tl::optional<int> o20 = 42;
+    constexpr auto o20r = std::move(o20).map(get_int);
+    STATIC_REQUIRE(*o20r == 42);
 
-  constexpr tl::optional<int> o19 = tl::nullopt;
-  constexpr auto o19r = std::move(o19).and_then(get_opt_int);
-  REQUIRE(!o19r);
+    constexpr tl::optional<int> o22 = 42;
+    constexpr auto o22r = std::move(o22).map(opt_int);
+    STATIC_REQUIRE(*o22r == 42);
+
+    constexpr tl::optional<int> o32 = tl::nullopt;
+    constexpr auto o32r = o32.map(get_int);
+    STATIC_REQUIRE(!o32r);
+
+    constexpr tl::optional<int> o34 = tl::nullopt;
+    constexpr auto o34r = o34.map(opt_int);
+    STATIC_REQUIRE(!o34r);
+
+    constexpr tl::optional<int> o36 = tl::nullopt;
+    constexpr auto o36r = std::move(o36).map(get_int);
+    STATIC_REQUIRE(!o36r);
+
+    constexpr tl::optional<int> o38 = tl::nullopt;
+    constexpr auto o38r = std::move(o38).map(opt_int);
+    STATIC_REQUIRE(!o38r);
 #endif
-}
+  }
 
-SECTION("or else") {
+  SECTION("and_then") {
+
+    // lhs is empty
+    tl::optional<int> o1;
+    auto o1r = o1.and_then([](int i) { return tl::optional<float>{42}; });
+    STATIC_REQUIRE((std::is_same<decltype(o1r), tl::optional<float>>::value));
+    REQUIRE(!o1r);
+
+    // lhs has value
+    tl::optional<int> o2 = 12;
+    auto o2r = o2.and_then([](int i) { return tl::optional<float>{42}; });
+    STATIC_REQUIRE((std::is_same<decltype(o2r), tl::optional<float>>::value));
+    REQUIRE(o2r.value() == 42.f);
+
+    // lhs is empty, rhs returns empty
+    tl::optional<int> o3;
+    auto o3r = o3.and_then([](int i) { return tl::optional<float>{}; });
+    STATIC_REQUIRE((std::is_same<decltype(o3r), tl::optional<float>>::value));
+    REQUIRE(!o3r);
+
+    // rhs returns empty
+    tl::optional<int> o4 = 12;
+    auto o4r = o4.and_then([](int i) { return tl::optional<float>{}; });
+    STATIC_REQUIRE((std::is_same<decltype(o4r), tl::optional<float>>::value));
+    REQUIRE(!o4r);
+
+    struct rval_call_and_then {
+      tl::optional<double> operator()(int) && {
+        return tl::optional<double>(42.0);
+      };
+    };
+
+    // ensure that function object is forwarded
+    tl::optional<int> o5 = 42;
+    auto o5r = o5.and_then(rval_call_and_then{});
+    STATIC_REQUIRE((std::is_same<decltype(o5r), tl::optional<double>>::value));
+    REQUIRE(o5r.value() == 42);
+
+    // ensure that lhs is forwarded
+    tl::optional<int> o6 = 42;
+    auto o6r =
+        std::move(o6).and_then([](int &&i) { return tl::optional<double>(i); });
+    STATIC_REQUIRE((std::is_same<decltype(o6r), tl::optional<double>>::value));
+    REQUIRE(o6r.value() == 42);
+
+    // ensure that function object is const-propagated
+    const tl::optional<int> o7 = 42;
+    auto o7r =
+        o7.and_then([](const int &i) { return tl::optional<double>(i); });
+    STATIC_REQUIRE((std::is_same<decltype(o7r), tl::optional<double>>::value));
+    REQUIRE(o7r.value() == 42);
+
+    // test each overload in turn
+    tl::optional<int> o8 = 42;
+    auto o8r = o8.and_then([](int i) { return tl::make_optional(42); });
+    REQUIRE(*o8r == 42);
+
+    tl::optional<int> o9 = 42;
+    auto o9r =
+        std::move(o9).and_then([](int i) { return tl::make_optional(42); });
+    REQUIRE(*o9r == 42);
+
+    const tl::optional<int> o10 = 42;
+    auto o10r = o10.and_then([](int i) { return tl::make_optional(42); });
+    REQUIRE(*o10r == 42);
+
+    const tl::optional<int> o11 = 42;
+    auto o11r =
+        std::move(o11).and_then([](int i) { return tl::make_optional(42); });
+    REQUIRE(*o11r == 42);
+
+    tl::optional<int> o16 = tl::nullopt;
+    auto o16r = o16.and_then([](int i) { return tl::make_optional(42); });
+    REQUIRE(!o16r);
+
+    tl::optional<int> o17 = tl::nullopt;
+    auto o17r =
+        std::move(o17).and_then([](int i) { return tl::make_optional(42); });
+    REQUIRE(!o17r);
+
+    const tl::optional<int> o18 = tl::nullopt;
+    auto o18r = o18.and_then([](int i) { return tl::make_optional(42); });
+    REQUIRE(!o18r);
+
+    const tl::optional<int> o19 = tl::nullopt;
+    auto o19r =
+        std::move(o19).and_then([](int i) { return tl::make_optional(42); });
+    REQUIRE(!o19r);
+  }
+
+  SECTION("constexpr and_then") {
+#if !defined(_MSC_VER) && !defined(TL_OPTIONAL_GCC49)
+    constexpr tl::optional<int> o10 = 42;
+    constexpr auto o10r = o10.and_then(get_opt_int);
+    REQUIRE(*o10r == 42);
+
+    constexpr tl::optional<int> o11 = 42;
+    constexpr auto o11r = std::move(o11).and_then(get_opt_int);
+    REQUIRE(*o11r == 42);
+
+    constexpr tl::optional<int> o18 = tl::nullopt;
+    constexpr auto o18r = o18.and_then(get_opt_int);
+    REQUIRE(!o18r);
+
+    constexpr tl::optional<int> o19 = tl::nullopt;
+    constexpr auto o19r = std::move(o19).and_then(get_opt_int);
+    REQUIRE(!o19r);
+#endif
+  }
+
+  SECTION("or else") {
     tl::optional<int> o1 = 42;
     REQUIRE(*(o1.or_else([] { return tl::make_optional(13); })) == 42);
 
     tl::optional<int> o2;
     REQUIRE(*(o2.or_else([] { return tl::make_optional(13); })) == 13);
-}
+  }
 
-SECTION("disjunction") {
+  SECTION("disjunction") {
     tl::optional<int> o1 = 42;
     tl::optional<int> o2 = 12;
     tl::optional<int> o3;
@@ -358,9 +288,9 @@ SECTION("disjunction") {
     REQUIRE(*o2.disjunction(o3) == 12);
     REQUIRE(*o3.disjunction(o1) == 42);
     REQUIRE(*o3.disjunction(o2) == 12);
-}
+  }
 
-SECTION("conjunction") {
+  SECTION("conjunction") {
     tl::optional<int> o1 = 42;
     REQUIRE(*o1.conjunction(42.0) == 42.0);
     REQUIRE(*o1.conjunction(std::string{"hello"}) == std::string{"hello"});
@@ -370,25 +300,27 @@ SECTION("conjunction") {
     REQUIRE(!o2.conjunction(42.0));
     REQUIRE(!o2.conjunction(std::string{"hello"}));
     REQUIRE(!o2.conjunction(tl::nullopt));
-}
+  }
 
-SECTION("map_or") {
+  SECTION("map_or") {
     tl::optional<int> o1 = 21;
     REQUIRE((o1.map_or([](int x) { return x * 2; }, 13)) == 42);
 
     tl::optional<int> o2;
     REQUIRE((o2.map_or([](int x) { return x * 2; }, 13)) == 13);
-}
+  }
 
-SECTION("map_or_else") {
+  SECTION("map_or_else") {
     tl::optional<int> o1 = 21;
-    REQUIRE((o1.map_or_else([](int x) { return x * 2; }, []{return 13;})) == 42);
+    REQUIRE((o1.map_or_else([](int x) { return x * 2; }, [] { return 13; })) ==
+            42);
 
     tl::optional<int> o2;
-    REQUIRE((o2.map_or_else([](int x) { return x * 2; }, []{return 13;})) == 13);
-}
+    REQUIRE((o2.map_or_else([](int x) { return x * 2; }, [] { return 13; })) ==
+            13);
+  }
 
-SECTION("take") {
+  SECTION("take") {
     tl::optional<int> o1 = 42;
     REQUIRE(*o1.take() == 42);
     REQUIRE(!o1);
@@ -396,6 +328,18 @@ SECTION("take") {
     tl::optional<int> o2;
     REQUIRE(!o2.take());
     REQUIRE(!o2);
-}
-}
-;
+  }
+
+  struct foo {
+    void non_const() {}
+  };
+
+#ifdef TL_OPTIONAL_CXX14
+  // Reported by Mark Papadakis
+  SECTION("map const correctness") {
+    tl::optional<foo> f = foo{};
+    auto l = [](auto &&x) { x.non_const(); };
+    f.map(l);
+  }
+#endif
+};