diff --git a/include/tl/expected.hpp b/include/tl/expected.hpp
index 31b130a..b52a501 100644
--- a/include/tl/expected.hpp
+++ b/include/tl/expected.hpp
@@ -1203,6 +1203,237 @@ template <class E> class bad_expected_access : public std::exception {
   E m_val;
 };
 
+namespace detail {
+template <class Exp> using exp_t = typename detail::decay_t<Exp>::value_type;
+template <class Exp> using err_t = typename detail::decay_t<Exp>::error_type;
+
+template <class Exp, class F,
+          detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr,
+          class Ret = detail::decay_t<decltype(detail::invoke(std::declval<F>(),
+                                                              *std::declval<Exp>()))>,
+          detail::enable_if_t<detail::is_expected<Ret>::value &&
+                              std::is_convertible<decltype(std::declval<Exp>().error()),
+                                                  err_t<Ret>>::value> * = nullptr>
+constexpr Ret and_then_impl(Exp &&exp, F &&f) {
+  return exp.has_value()
+             ? detail::invoke(std::forward<F>(f), *std::forward<Exp>(exp))
+             : Ret(unexpect, std::forward<Exp>(exp).error());
+}
+
+template <class Exp, class F,
+          detail::enable_if_t<std::is_void<exp_t<Exp>>::value> * = nullptr,
+          class Ret = detail::decay_t<decltype(detail::invoke(std::declval<F>()))>,
+          detail::enable_if_t<detail::is_expected<Ret>::value &&
+                              std::is_convertible<decltype(std::declval<Exp>().error()),
+                                                  err_t<Ret>>::value> * = nullptr>
+constexpr Ret and_then_impl(Exp &&exp, F &&f) {
+  return exp.has_value() ? detail::invoke(std::forward<F>(f))
+                         : Ret(unexpect, std::forward<Exp>(exp).error());
+}
+
+template <class Exp, class F,
+          detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr,
+          class Ret = detail::decay_t<decltype(detail::invoke(std::declval<F>(), *std::declval<Exp>()))>,
+          detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr,
+          class Result = expected<Ret, err_t<Exp>>>
+constexpr Result map_impl(Exp &&exp, F &&f) {
+  return exp.has_value() ? Result(detail::invoke(std::forward<F>(f), *std::forward<Exp>(exp)))
+                         : Result(unexpect, std::forward<Exp>(exp).error());
+}
+
+template <class Exp, class F,
+          detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr,
+          class Ret = detail::decay_t<decltype(detail::invoke(std::declval<F>(), *std::declval<Exp>()))>,
+          detail::enable_if_t<std::is_void<Ret>::value> * = nullptr,
+          class Result = expected<Ret, err_t<Exp>>>
+constexpr Result map_impl(Exp &&exp, F &&f) {
+  return exp.has_value() ? (detail::invoke(std::forward<F>(f), *std::forward<Exp>(exp)), Result())
+                         : Result(unexpect, std::forward<Exp>(exp).error());
+}
+
+template <class Exp, class F,
+          detail::enable_if_t<std::is_void<exp_t<Exp>>::value> * = nullptr,
+          class Ret = detail::decay_t<decltype(detail::invoke(std::declval<F>()))>,
+          detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr,
+          class Result = expected<Ret, err_t<Exp>>>
+constexpr Result map_impl(Exp &&exp, F &&f) {
+  return exp.has_value() ? Result(detail::invoke(std::forward<F>(f)))
+                         : Result(unexpect, std::forward<Exp>(exp).error());
+}
+
+template <class Exp, class F,
+          detail::enable_if_t<std::is_void<exp_t<Exp>>::value> * = nullptr,
+          class Ret = detail::decay_t<decltype(detail::invoke(std::declval<F>()))>,
+          detail::enable_if_t<std::is_void<Ret>::value> * = nullptr,
+          class Result = expected<Ret, err_t<Exp>>>
+constexpr Result map_impl(Exp &&exp, F &&f) {
+  return exp.has_value() ? (detail::invoke(std::forward<F>(f)), Result())
+                         : Result(unexpect, std::forward<Exp>(exp).error());
+}
+
+#if defined(TL_EXPECTED_CXX14) && !defined(TL_EXPECTED_GCC49) &&               \
+    !defined(TL_EXPECTED_GCC54) && !defined(TL_EXPECTED_GCC55)
+template <class Exp, class F,
+          detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr,
+          class Ret = decltype(detail::invoke(std::declval<F>(),
+                                              std::declval<Exp>().error())),
+          detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
+constexpr auto map_error_impl(Exp &&exp, F &&f) {
+  using result = expected<exp_t<Exp>, detail::decay_t<Ret>>;
+  return exp.has_value()
+             ? result(*std::forward<Exp>(exp))
+             : result(unexpect, detail::invoke(std::forward<F>(f),
+                                               std::forward<Exp>(exp).error()));
+}
+template <class Exp, class F,
+          detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr,
+          class Ret = decltype(detail::invoke(std::declval<F>(),
+                                              std::declval<Exp>().error())),
+          detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
+auto map_error_impl(Exp &&exp, F &&f) {
+  using result = expected<exp_t<Exp>, monostate>;
+  if (exp.has_value()) {
+    return result(*std::forward<Exp>(exp));
+  }
+
+  detail::invoke(std::forward<F>(f), std::forward<Exp>(exp).error());
+  return result(unexpect, monostate{});
+}
+template <class Exp, class F,
+          detail::enable_if_t<std::is_void<exp_t<Exp>>::value> * = nullptr,
+          class Ret = decltype(detail::invoke(std::declval<F>(),
+                                              std::declval<Exp>().error())),
+          detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
+constexpr auto map_error_impl(Exp &&exp, F &&f) {
+  using result = expected<exp_t<Exp>, detail::decay_t<Ret>>;
+  return exp.has_value()
+             ? result()
+             : result(unexpect, detail::invoke(std::forward<F>(f),
+                                               std::forward<Exp>(exp).error()));
+}
+template <class Exp, class F,
+          detail::enable_if_t<std::is_void<exp_t<Exp>>::value> * = nullptr,
+          class Ret = decltype(detail::invoke(std::declval<F>(),
+                                              std::declval<Exp>().error())),
+          detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
+auto map_error_impl(Exp &&exp, F &&f) {
+  using result = expected<exp_t<Exp>, monostate>;
+  if (exp.has_value()) {
+    return result();
+  }
+
+  detail::invoke(std::forward<F>(f), std::forward<Exp>(exp).error());
+  return result(unexpect, monostate{});
+}    
+#else
+template <class Exp, class F,
+          detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr,
+          class Ret = decltype(detail::invoke(std::declval<F>(),
+                                              std::declval<Exp>().error())),
+          detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
+constexpr auto map_error_impl(Exp &&exp, F &&f)
+    -> expected<exp_t<Exp>, detail::decay_t<Ret>> {
+  using result = expected<exp_t<Exp>, detail::decay_t<Ret>>;
+
+  return exp.has_value()
+             ? result(*std::forward<Exp>(exp))
+             : result(unexpect, detail::invoke(std::forward<F>(f),
+                                               std::forward<Exp>(exp).error()));
+}
+
+template <class Exp, class F,
+          detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr,
+          class Ret = decltype(detail::invoke(std::declval<F>(),
+                                              std::declval<Exp>().error())),
+          detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
+auto map_error_impl(Exp &&exp, F &&f) -> expected<exp_t<Exp>, monostate> {
+  using result = expected<exp_t<Exp>, monostate>;
+  if (exp.has_value()) {
+    return result(*std::forward<Exp>(exp));
+  }
+
+  detail::invoke(std::forward<F>(f), std::forward<Exp>(exp).error());
+  return result(unexpect, monostate{});
+}
+
+template <class Exp, class F,
+          detail::enable_if_t<std::is_void<exp_t<Exp>>::value> * = nullptr,
+          class Ret = decltype(detail::invoke(std::declval<F>(),
+                                              std::declval<Exp>().error())),
+          detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
+constexpr auto map_error_impl(Exp &&exp, F &&f)
+    -> expected<exp_t<Exp>, detail::decay_t<Ret>> {
+  using result = expected<exp_t<Exp>, detail::decay_t<Ret>>;
+
+  return exp.has_value()
+             ? result()
+             : result(unexpect, detail::invoke(std::forward<F>(f),
+                                               std::forward<Exp>(exp).error()));
+}
+
+template <class Exp, class F,
+          detail::enable_if_t<std::is_void<exp_t<Exp>>::value> * = nullptr,
+          class Ret = decltype(detail::invoke(std::declval<F>(),
+                                              std::declval<Exp>().error())),
+          detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
+auto map_error_impl(Exp &&exp, F &&f) -> expected<exp_t<Exp>, monostate> {
+  using result = expected<exp_t<Exp>, monostate>;
+  if (exp.has_value()) {
+    return result();
+  }
+
+  detail::invoke(std::forward<F>(f), std::forward<Exp>(exp).error());
+  return result(unexpect, monostate{});
+}    
+#endif
+
+#ifdef TL_EXPECTED_CXX14
+template <class Exp, class F,
+          class Ret = decltype(detail::invoke(std::declval<F>(),
+                                              std::declval<Exp>().error())),
+          detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
+constexpr auto or_else_impl(Exp &&exp, F &&f) {
+  static_assert(detail::is_expected<Ret>::value, "F must return an expected");
+  return exp.has_value()
+  ? std::forward<Exp>(exp)
+  : detail::invoke(std::forward<F>(f), std::forward<Exp>(exp).error());
+}
+
+template <class Exp, class F,
+          class Ret = decltype(detail::invoke(std::declval<F>(),
+                                              std::declval<Exp>().error())),
+          detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
+detail::decay_t<Exp> or_else_impl(Exp &&exp, F &&f) {
+  return exp.has_value()
+  ? std::forward<Exp>(exp)
+  : (detail::invoke(std::forward<F>(f), std::forward<Exp>(exp).error()),
+    std::forward<Exp>(exp));
+}
+#else
+template <class Exp, class F,
+          class Ret = decltype(detail::invoke(std::declval<F>(),
+                                              std::declval<Exp>().error())),
+  detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
+auto or_else_impl(Exp &&exp, F &&f) -> Ret {
+  static_assert(detail::is_expected<Ret>::value, "F must return an expected");
+  return exp.has_value()
+         ? std::forward<Exp>(exp)
+         : detail::invoke(std::forward<F>(f), std::forward<Exp>(exp).error());
+}
+
+template <class Exp, class F,
+          class Ret = decltype(detail::invoke(std::declval<F>(),
+                                              std::declval<Exp>().error())),
+  detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
+detail::decay_t<Exp> or_else_impl(Exp &&exp, F &&f) {
+  return exp.has_value()
+         ? std::forward<Exp>(exp)
+         : (detail::invoke(std::forward<F>(f), std::forward<Exp>(exp).error()),
+            std::forward<Exp>(exp));
+}
+#endif
+} // namespace detail
+
 /// An `expected<T, E>` object is an object that contains the storage for
 /// another object and manages the lifetime of this contained object `T`.
 /// Alternatively it could contain the storage for another unexpected object
@@ -1251,198 +1482,121 @@ class expected : private detail::expected_move_assign_base<T, E>,
   typedef E error_type;
   typedef unexpected<E> unexpected_type;
 
-#if defined(TL_EXPECTED_CXX14) && !defined(TL_EXPECTED_GCC49) &&               \
-    !defined(TL_EXPECTED_GCC54) && !defined(TL_EXPECTED_GCC55)
-  template <class F> TL_EXPECTED_11_CONSTEXPR auto and_then(F &&f) & {
-    return and_then_impl(*this, std::forward<F>(f));
+  template <class F>
+  TL_EXPECTED_11_CONSTEXPR auto and_then(F &&f) &
+    -> decltype(detail::and_then_impl(*this, std::forward<F>(f))) {
+    return detail::and_then_impl(*this, std::forward<F>(f));
   }
-  template <class F> TL_EXPECTED_11_CONSTEXPR auto and_then(F &&f) && {
-    return and_then_impl(std::move(*this), std::forward<F>(f));
+  template <class F>
+  TL_EXPECTED_11_CONSTEXPR auto and_then(F &&f) &&
+    -> decltype(detail::and_then_impl(std::move(*this), std::forward<F>(f))) {
+    return detail::and_then_impl(std::move(*this), std::forward<F>(f));
   }
-  template <class F> constexpr auto and_then(F &&f) const & {
-    return and_then_impl(*this, std::forward<F>(f));
+  template <class F>
+  constexpr auto and_then(F &&f) const &
+    -> decltype(detail::and_then_impl(*this, std::forward<F>(f))) {
+    return detail::and_then_impl(*this, std::forward<F>(f));
   }
-
 #ifndef TL_EXPECTED_NO_CONSTRR
-  template <class F> constexpr auto and_then(F &&f) const && {
-    return and_then_impl(std::move(*this), std::forward<F>(f));
+  template <class F>
+  constexpr auto and_then(F &&f) const &&
+    -> decltype(detail::and_then_impl(std::move(*this), std::forward<F>(f))) {
+    return detail::and_then_impl(std::move(*this), std::forward<F>(f));
   }
 #endif
 
-#else
   template <class F>
-  TL_EXPECTED_11_CONSTEXPR auto
-  and_then(F &&f) & -> decltype(and_then_impl(std::declval<expected&>(), std::forward<F>(f))) {
-    return and_then_impl(*this, std::forward<F>(f));
+  TL_EXPECTED_11_CONSTEXPR auto map(F &&f) &
+    -> decltype(detail::map_impl(*this, std::forward<F>(f))) {
+    return detail::map_impl(*this, std::forward<F>(f));
   }
   template <class F>
-  TL_EXPECTED_11_CONSTEXPR auto and_then(F &&f) && -> decltype(
-      and_then_impl(std::declval<expected&&>(), std::forward<F>(f))) {
-    return and_then_impl(std::move(*this), std::forward<F>(f));
+  TL_EXPECTED_11_CONSTEXPR auto map(F &&f) &&
+    -> decltype(detail::map_impl(std::move(*this), std::forward<F>(f))) {
+    return detail::map_impl(std::move(*this), std::forward<F>(f));
   }
   template <class F>
-  constexpr auto and_then(F &&f) const & -> decltype(
-      and_then_impl(std::declval<expected const&>(), std::forward<F>(f))) {
-    return and_then_impl(*this, std::forward<F>(f));
+  constexpr auto map(F &&f) const &
+    -> decltype(detail::map_impl(*this, std::forward<F>(f))) {
+    return detail::map_impl(*this, std::forward<F>(f));
   }
-
 #ifndef TL_EXPECTED_NO_CONSTRR
   template <class F>
-  constexpr auto and_then(F &&f) const && -> decltype(
-      and_then_impl(std::declval<expected const&&>(), std::forward<F>(f))) {
-    return and_then_impl(std::move(*this), std::forward<F>(f));
+  constexpr auto map(F &&f) const &&
+    -> decltype(detail::map_impl(std::move(*this), std::forward<F>(f))) {
+    return detail::map_impl(std::move(*this), std::forward<F>(f));
   }
 #endif
-#endif
 
-#if defined(TL_EXPECTED_CXX14) && !defined(TL_EXPECTED_GCC49) &&               \
-    !defined(TL_EXPECTED_GCC54) && !defined(TL_EXPECTED_GCC55)
-    template <class F> TL_EXPECTED_11_CONSTEXPR auto map(F &&f) & {
-    return expected_map_impl(*this, std::forward<F>(f));
-  }
-  template <class F> TL_EXPECTED_11_CONSTEXPR auto map(F &&f) && {
-    return expected_map_impl(std::move(*this), std::forward<F>(f));
-  }
-  template <class F> constexpr auto map(F &&f) const & {
-    return expected_map_impl(*this, std::forward<F>(f));
-  }
-  template <class F> constexpr auto map(F &&f) const && {
-    return expected_map_impl(std::move(*this), std::forward<F>(f));
-  }
-#else
   template <class F>
-  TL_EXPECTED_11_CONSTEXPR decltype(
-      expected_map_impl(std::declval<expected &>(), std::declval<F &&>()))
-  map(F &&f) & {
-    return expected_map_impl(*this, std::forward<F>(f));
+  TL_EXPECTED_11_CONSTEXPR auto transform(F &&f) &
+    -> decltype(detail::map_impl(*this, std::forward<F>(f))) {
+    return detail::map_impl(*this, std::forward<F>(f));
   }
   template <class F>
-  TL_EXPECTED_11_CONSTEXPR decltype(
-      expected_map_impl(std::declval<expected>(), std::declval<F &&>()))
-  map(F &&f) && {
-    return expected_map_impl(std::move(*this), std::forward<F>(f));
+  TL_EXPECTED_11_CONSTEXPR auto transform(F &&f) &&
+    -> decltype(detail::map_impl(std::move(*this), std::forward<F>(f))) {
+    return detail::map_impl(std::move(*this), std::forward<F>(f));
   }
   template <class F>
-  constexpr decltype(expected_map_impl(std::declval<const expected &>(),
-                                       std::declval<F &&>()))
-  map(F &&f) const & {
-    return expected_map_impl(*this, std::forward<F>(f));
+  constexpr auto transform(F &&f) const &
+    -> decltype(detail::map_impl(*this, std::forward<F>(f))) {
+    return detail::map_impl(*this, std::forward<F>(f));
   }
-
 #ifndef TL_EXPECTED_NO_CONSTRR
   template <class F>
-  constexpr decltype(expected_map_impl(std::declval<const expected &&>(),
-                                       std::declval<F &&>()))
-  map(F &&f) const && {
-    return expected_map_impl(std::move(*this), std::forward<F>(f));
+  constexpr auto transform(F &&f) const &&
+    -> decltype(detail::map_impl(std::move(*this), std::forward<F>(f))) {
+    return detail::map_impl(std::move(*this), std::forward<F>(f));
   }
 #endif
-#endif
 
-#if defined(TL_EXPECTED_CXX14) && !defined(TL_EXPECTED_GCC49) &&               \
-    !defined(TL_EXPECTED_GCC54) && !defined(TL_EXPECTED_GCC55)
-    template <class F> TL_EXPECTED_11_CONSTEXPR auto transform(F &&f) & {
-    return expected_map_impl(*this, std::forward<F>(f));
-  }
-  template <class F> TL_EXPECTED_11_CONSTEXPR auto transform(F &&f) && {
-    return expected_map_impl(std::move(*this), std::forward<F>(f));
-  }
-  template <class F> constexpr auto transform(F &&f) const & {
-    return expected_map_impl(*this, std::forward<F>(f));
-  }
-  template <class F> constexpr auto transform(F &&f) const && {
-    return expected_map_impl(std::move(*this), std::forward<F>(f));
-  }
-#else
-    template <class F>
-  TL_EXPECTED_11_CONSTEXPR decltype(
-      expected_map_impl(std::declval<expected &>(), std::declval<F &&>()))
-  transform(F &&f) & {
-    return expected_map_impl(*this, std::forward<F>(f));
+  template <class F>
+  TL_EXPECTED_11_CONSTEXPR auto map_error(F &&f) &
+    -> decltype(detail::map_error_impl(*this, std::forward<F>(f))) {
+    return detail::map_error_impl(*this, std::forward<F>(f));
   }
   template <class F>
-  TL_EXPECTED_11_CONSTEXPR decltype(
-      expected_map_impl(std::declval<expected>(), std::declval<F &&>()))
-  transform(F &&f) && {
-    return expected_map_impl(std::move(*this), std::forward<F>(f));
+  TL_EXPECTED_11_CONSTEXPR auto map_error(F &&f) &&
+    -> decltype(detail::map_error_impl(std::move(*this), std::forward<F>(f))) {
+    return detail::map_error_impl(std::move(*this), std::forward<F>(f));
   }
   template <class F>
-  constexpr decltype(expected_map_impl(std::declval<const expected &>(),
-                                       std::declval<F &&>()))
-  transform(F &&f) const & {
-    return expected_map_impl(*this, std::forward<F>(f));
+  constexpr auto map_error(F &&f) const &
+    -> decltype(detail::map_error_impl(*this, std::forward<F>(f))) {
+    return detail::map_error_impl(*this, std::forward<F>(f));
   }
-
 #ifndef TL_EXPECTED_NO_CONSTRR
   template <class F>
-  constexpr decltype(expected_map_impl(std::declval<const expected &&>(),
-                                       std::declval<F &&>()))
-  transform(F &&f) const && {
-    return expected_map_impl(std::move(*this), std::forward<F>(f));
+  constexpr auto map_error(F &&f) const &&
+    -> decltype(detail::map_error_impl(std::move(*this), std::forward<F>(f))) {
+    return detail::map_error_impl(std::move(*this), std::forward<F>(f));
   }
 #endif
-#endif
 
-#if defined(TL_EXPECTED_CXX14) && !defined(TL_EXPECTED_GCC49) &&               \
-    !defined(TL_EXPECTED_GCC54) && !defined(TL_EXPECTED_GCC55)
-  template <class F> TL_EXPECTED_11_CONSTEXPR auto map_error(F &&f) & {
-    return map_error_impl(*this, std::forward<F>(f));
-  }
-  template <class F> TL_EXPECTED_11_CONSTEXPR auto map_error(F &&f) && {
-    return map_error_impl(std::move(*this), std::forward<F>(f));
-  }
-  template <class F> constexpr auto map_error(F &&f) const & {
-    return map_error_impl(*this, std::forward<F>(f));
-  }
-  template <class F> constexpr auto map_error(F &&f) const && {
-    return map_error_impl(std::move(*this), std::forward<F>(f));
-  }
-#else
   template <class F>
-  TL_EXPECTED_11_CONSTEXPR decltype(map_error_impl(std::declval<expected &>(),
-                                                   std::declval<F &&>()))
-  map_error(F &&f) & {
-    return map_error_impl(*this, std::forward<F>(f));
+  TL_EXPECTED_11_CONSTEXPR auto or_else(F &&f) &
+    -> decltype(detail::or_else_impl(*this, std::forward<F>(f))) {
+    return detail::or_else_impl(*this, std::forward<F>(f));
   }
   template <class F>
-  TL_EXPECTED_11_CONSTEXPR decltype(map_error_impl(std::declval<expected &&>(),
-                                                   std::declval<F &&>()))
-  map_error(F &&f) && {
-    return map_error_impl(std::move(*this), std::forward<F>(f));
+  TL_EXPECTED_11_CONSTEXPR auto or_else(F &&f) &&
+    -> decltype(detail::or_else_impl(std::move(*this), std::forward<F>(f))) {
+    return detail::or_else_impl(std::move(*this), std::forward<F>(f));
   }
   template <class F>
-  constexpr decltype(map_error_impl(std::declval<const expected &>(),
-                                    std::declval<F &&>()))
-  map_error(F &&f) const & {
-    return map_error_impl(*this, std::forward<F>(f));
+  constexpr auto or_else(F &&f) const &
+    -> decltype(detail::or_else_impl(*this, std::forward<F>(f))) {
+    return detail::or_else_impl(*this, std::forward<F>(f));
   }
-
 #ifndef TL_EXPECTED_NO_CONSTRR
   template <class F>
-  constexpr decltype(map_error_impl(std::declval<const expected &&>(),
-                                    std::declval<F &&>()))
-  map_error(F &&f) const && {
-    return map_error_impl(std::move(*this), std::forward<F>(f));
+  constexpr auto or_else(F &&f) const &&
+    -> decltype(detail::or_else_impl(std::move(*this), std::forward<F>(f))) {
+    return detail::or_else_impl(std::move(*this), std::forward<F>(f));
   }
 #endif
-#endif
-  template <class F> expected TL_EXPECTED_11_CONSTEXPR or_else(F &&f) & {
-    return or_else_impl(*this, std::forward<F>(f));
-  }
-
-  template <class F> expected TL_EXPECTED_11_CONSTEXPR or_else(F &&f) && {
-    return or_else_impl(std::move(*this), std::forward<F>(f));
-  }
 
-  template <class F> expected constexpr or_else(F &&f) const & {
-    return or_else_impl(*this, std::forward<F>(f));
-  }
-
-#ifndef TL_EXPECTED_NO_CONSTRR
-  template <class F> expected constexpr or_else(F &&f) const && {
-    return or_else_impl(std::move(*this), std::forward<F>(f));
-  }
-#endif
   constexpr expected() = default;
   constexpr expected(const expected &rhs) = default;
   constexpr expected(expected &&rhs) = default;
@@ -1937,331 +2091,6 @@ class expected : private detail::expected_move_assign_base<T, E>,
   }
 };
 
-namespace detail {
-template <class Exp> using exp_t = typename detail::decay_t<Exp>::value_type;
-template <class Exp> using err_t = typename detail::decay_t<Exp>::error_type;
-template <class Exp, class Ret> using ret_t = expected<Ret, err_t<Exp>>;
-
-#ifdef TL_EXPECTED_CXX14
-template <class Exp, class F,
-          detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr,
-          class Ret = decltype(detail::invoke(std::declval<F>(),
-                                              *std::declval<Exp>()))>
-constexpr auto and_then_impl(Exp &&exp, F &&f) {
-  static_assert(detail::is_expected<Ret>::value, "F must return an expected");
-
-  return exp.has_value()
-             ? detail::invoke(std::forward<F>(f), *std::forward<Exp>(exp))
-             : Ret(unexpect, std::forward<Exp>(exp).error());
-}
-
-template <class Exp, class F,
-          detail::enable_if_t<std::is_void<exp_t<Exp>>::value> * = nullptr,
-          class Ret = decltype(detail::invoke(std::declval<F>()))>
-constexpr auto and_then_impl(Exp &&exp, F &&f) {
-  static_assert(detail::is_expected<Ret>::value, "F must return an expected");
-
-  return exp.has_value() ? detail::invoke(std::forward<F>(f))
-                         : Ret(unexpect, std::forward<Exp>(exp).error());
-}
-#else
-template <class> struct TC;
-template <class Exp, class F,
-          class Ret = decltype(detail::invoke(std::declval<F>(),
-                                              *std::declval<Exp>())),
-          detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr>
-auto and_then_impl(Exp &&exp, F &&f) -> Ret {
-  static_assert(detail::is_expected<Ret>::value, "F must return an expected");
-
-  return exp.has_value()
-             ? detail::invoke(std::forward<F>(f), *std::forward<Exp>(exp))
-             : Ret(unexpect, std::forward<Exp>(exp).error());
-}
-
-template <class Exp, class F,
-          class Ret = decltype(detail::invoke(std::declval<F>())),
-          detail::enable_if_t<std::is_void<exp_t<Exp>>::value> * = nullptr>
-constexpr auto and_then_impl(Exp &&exp, F &&f) -> Ret {
-  static_assert(detail::is_expected<Ret>::value, "F must return an expected");
-
-  return exp.has_value() ? detail::invoke(std::forward<F>(f))
-                         : Ret(unexpect, std::forward<Exp>(exp).error());
-}
-#endif
-
-#ifdef TL_EXPECTED_CXX14
-template <class Exp, class F,
-          detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr,          
-          class Ret = decltype(detail::invoke(std::declval<F>(),
-                                              *std::declval<Exp>())),
-          detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
-constexpr auto expected_map_impl(Exp &&exp, F &&f) {
-  using result = ret_t<Exp, detail::decay_t<Ret>>;
-  return exp.has_value() ? result(detail::invoke(std::forward<F>(f),
-                                                 *std::forward<Exp>(exp)))
-                         : result(unexpect, std::forward<Exp>(exp).error());
-}
-
-template <class Exp, class F,
-          detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr,          
-          class Ret = decltype(detail::invoke(std::declval<F>(),
-                                              *std::declval<Exp>())),
-          detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
-auto expected_map_impl(Exp &&exp, F &&f) {
-  using result = expected<void, err_t<Exp>>;
-  if (exp.has_value()) {
-    detail::invoke(std::forward<F>(f), *std::forward<Exp>(exp));
-    return result();
-  }
-
-  return result(unexpect, std::forward<Exp>(exp).error());
-}
-
-template <class Exp, class F,
-          detail::enable_if_t<std::is_void<exp_t<Exp>>::value> * = nullptr,
-          class Ret = decltype(detail::invoke(std::declval<F>())),
-          detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
-constexpr auto expected_map_impl(Exp &&exp, F &&f) {
-  using result = ret_t<Exp, detail::decay_t<Ret>>;
-  return exp.has_value() ? result(detail::invoke(std::forward<F>(f)))
-                         : result(unexpect, std::forward<Exp>(exp).error());
-}
-
-template <class Exp, class F,
-          detail::enable_if_t<std::is_void<exp_t<Exp>>::value> * = nullptr,          
-          class Ret = decltype(detail::invoke(std::declval<F>())),
-          detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
-auto expected_map_impl(Exp &&exp, F &&f) {
-  using result = expected<void, err_t<Exp>>;
-  if (exp.has_value()) {
-    detail::invoke(std::forward<F>(f));
-    return result();
-  }
-
-  return result(unexpect, std::forward<Exp>(exp).error());
-}    
-#else
-template <class Exp, class F,
-          detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr,          
-          class Ret = decltype(detail::invoke(std::declval<F>(),
-                                              *std::declval<Exp>())),
-          detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
-
-constexpr auto expected_map_impl(Exp &&exp, F &&f)
-    -> ret_t<Exp, detail::decay_t<Ret>> {
-  using result = ret_t<Exp, detail::decay_t<Ret>>;
-
-  return exp.has_value() ? result(detail::invoke(std::forward<F>(f),
-                                                 *std::forward<Exp>(exp)))
-                         : result(unexpect, std::forward<Exp>(exp).error());
-}
-
-template <class Exp, class F,
-          detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr,                    
-          class Ret = decltype(detail::invoke(std::declval<F>(),
-                                              *std::declval<Exp>())),
-          detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
-
-auto expected_map_impl(Exp &&exp, F &&f) -> expected<void, err_t<Exp>> {
-  if (exp.has_value()) {
-    detail::invoke(std::forward<F>(f), *std::forward<Exp>(exp));
-    return {};
-  }
-
-  return unexpected<err_t<Exp>>(std::forward<Exp>(exp).error());
-}
-
-template <class Exp, class F,
-          detail::enable_if_t<std::is_void<exp_t<Exp>>::value> * = nullptr,                              
-          class Ret = decltype(detail::invoke(std::declval<F>())),
-          detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
-
-constexpr auto expected_map_impl(Exp &&exp, F &&f)
-    -> ret_t<Exp, detail::decay_t<Ret>> {
-  using result = ret_t<Exp, detail::decay_t<Ret>>;
-
-  return exp.has_value() ? result(detail::invoke(std::forward<F>(f)))
-                         : result(unexpect, std::forward<Exp>(exp).error());
-}
-
-template <class Exp, class F,
-          detail::enable_if_t<std::is_void<exp_t<Exp>>::value> * = nullptr,                                        
-          class Ret = decltype(detail::invoke(std::declval<F>())),
-          detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
-
-auto expected_map_impl(Exp &&exp, F &&f) -> expected<void, err_t<Exp>> {
-  if (exp.has_value()) {
-    detail::invoke(std::forward<F>(f));
-    return {};
-  }
-
-  return unexpected<err_t<Exp>>(std::forward<Exp>(exp).error());
-}    
-#endif
-
-#if defined(TL_EXPECTED_CXX14) && !defined(TL_EXPECTED_GCC49) &&               \
-    !defined(TL_EXPECTED_GCC54) && !defined(TL_EXPECTED_GCC55)
-template <class Exp, class F,
-          detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr,          
-          class Ret = decltype(detail::invoke(std::declval<F>(),
-                                              std::declval<Exp>().error())),
-          detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
-constexpr auto map_error_impl(Exp &&exp, F &&f) {
-  using result = expected<exp_t<Exp>, detail::decay_t<Ret>>;
-  return exp.has_value()
-             ? result(*std::forward<Exp>(exp))
-             : result(unexpect, detail::invoke(std::forward<F>(f),
-                                               std::forward<Exp>(exp).error()));
-}
-template <class Exp, class F,
-          detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr,                    
-          class Ret = decltype(detail::invoke(std::declval<F>(),
-                                              std::declval<Exp>().error())),
-          detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
-auto map_error_impl(Exp &&exp, F &&f) {
-  using result = expected<exp_t<Exp>, monostate>;
-  if (exp.has_value()) {
-    return result(*std::forward<Exp>(exp));
-  }
-
-  detail::invoke(std::forward<F>(f), std::forward<Exp>(exp).error());
-  return result(unexpect, monostate{});
-}
-template <class Exp, class F,
-          detail::enable_if_t<std::is_void<exp_t<Exp>>::value> * = nullptr,          
-          class Ret = decltype(detail::invoke(std::declval<F>(),
-                                              std::declval<Exp>().error())),
-          detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
-constexpr auto map_error_impl(Exp &&exp, F &&f) {
-  using result = expected<exp_t<Exp>, detail::decay_t<Ret>>;
-  return exp.has_value()
-             ? result()
-             : result(unexpect, detail::invoke(std::forward<F>(f),
-                                               std::forward<Exp>(exp).error()));
-}
-template <class Exp, class F,
-          detail::enable_if_t<std::is_void<exp_t<Exp>>::value> * = nullptr,                    
-          class Ret = decltype(detail::invoke(std::declval<F>(),
-                                              std::declval<Exp>().error())),
-          detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
-auto map_error_impl(Exp &&exp, F &&f) {
-  using result = expected<exp_t<Exp>, monostate>;
-  if (exp.has_value()) {
-    return result();
-  }
-
-  detail::invoke(std::forward<F>(f), std::forward<Exp>(exp).error());
-  return result(unexpect, monostate{});
-}    
-#else
-template <class Exp, class F,
-          detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr,                              
-          class Ret = decltype(detail::invoke(std::declval<F>(),
-                                              std::declval<Exp>().error())),
-          detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
-constexpr auto map_error_impl(Exp &&exp, F &&f)
-    -> expected<exp_t<Exp>, detail::decay_t<Ret>> {
-  using result = expected<exp_t<Exp>, detail::decay_t<Ret>>;
-
-  return exp.has_value()
-             ? result(*std::forward<Exp>(exp))
-             : result(unexpect, detail::invoke(std::forward<F>(f),
-                                               std::forward<Exp>(exp).error()));
-}
-
-template <class Exp, class F,
-          detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr,                                        
-          class Ret = decltype(detail::invoke(std::declval<F>(),
-                                              std::declval<Exp>().error())),
-          detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
-auto map_error_impl(Exp &&exp, F &&f) -> expected<exp_t<Exp>, monostate> {
-  using result = expected<exp_t<Exp>, monostate>;
-  if (exp.has_value()) {
-    return result(*std::forward<Exp>(exp));
-  }
-
-  detail::invoke(std::forward<F>(f), std::forward<Exp>(exp).error());
-  return result(unexpect, monostate{});
-}
-
-template <class Exp, class F,
-          detail::enable_if_t<std::is_void<exp_t<Exp>>::value> * = nullptr,                              
-          class Ret = decltype(detail::invoke(std::declval<F>(),
-                                              std::declval<Exp>().error())),
-          detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
-constexpr auto map_error_impl(Exp &&exp, F &&f)
-    -> expected<exp_t<Exp>, detail::decay_t<Ret>> {
-  using result = expected<exp_t<Exp>, detail::decay_t<Ret>>;
-
-  return exp.has_value()
-             ? result()
-             : result(unexpect, detail::invoke(std::forward<F>(f),
-                                               std::forward<Exp>(exp).error()));
-}
-
-template <class Exp, class F,
-          detail::enable_if_t<std::is_void<exp_t<Exp>>::value> * = nullptr,                                        
-          class Ret = decltype(detail::invoke(std::declval<F>(),
-                                              std::declval<Exp>().error())),
-          detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
-auto map_error_impl(Exp &&exp, F &&f) -> expected<exp_t<Exp>, monostate> {
-  using result = expected<exp_t<Exp>, monostate>;
-  if (exp.has_value()) {
-    return result();
-  }
-
-  detail::invoke(std::forward<F>(f), std::forward<Exp>(exp).error());
-  return result(unexpect, monostate{});
-}    
-#endif
-
-#ifdef TL_EXPECTED_CXX14
-template <class Exp, class F,
-          class Ret = decltype(detail::invoke(std::declval<F>(),
-                                              std::declval<Exp>().error())),
-          detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
-constexpr auto or_else_impl(Exp &&exp, F &&f) {
-  static_assert(detail::is_expected<Ret>::value, "F must return an expected");
-  return exp.has_value()
-  ? std::forward<Exp>(exp)
-  : detail::invoke(std::forward<F>(f), std::forward<Exp>(exp).error());
-}
-
-template <class Exp, class F,
-          class Ret = decltype(detail::invoke(std::declval<F>(),
-                                              std::declval<Exp>().error())),
-          detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
-detail::decay_t<Exp> or_else_impl(Exp &&exp, F &&f) {
-  return exp.has_value()
-  ? std::forward<Exp>(exp)
-  : (detail::invoke(std::forward<F>(f), std::forward<Exp>(exp).error()),
-    std::forward<Exp>(exp));
-}
-#else
-template <class Exp, class F,
-          class Ret = decltype(detail::invoke(std::declval<F>(),
-                                              std::declval<Exp>().error())),
-  detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
-auto or_else_impl(Exp &&exp, F &&f) -> Ret {
-  static_assert(detail::is_expected<Ret>::value, "F must return an expected");
-  return exp.has_value()
-         ? std::forward<Exp>(exp)
-         : detail::invoke(std::forward<F>(f), std::forward<Exp>(exp).error());
-}
-
-template <class Exp, class F,
-          class Ret = decltype(detail::invoke(std::declval<F>(),
-                                              std::declval<Exp>().error())),
-  detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
-detail::decay_t<Exp> or_else_impl(Exp &&exp, F &&f) {
-  return exp.has_value()
-         ? std::forward<Exp>(exp)
-         : (detail::invoke(std::forward<F>(f), std::forward<Exp>(exp).error()),
-            std::forward<Exp>(exp));
-}
-#endif
-} // namespace detail
-
 template <class T, class E, class U, class F>
 constexpr bool operator==(const expected<T, E> &lhs,
                           const expected<U, F> &rhs) {
diff --git a/tests/extensions.cpp b/tests/extensions.cpp
index 9670f90..527a978 100644
--- a/tests/extensions.cpp
+++ b/tests/extensions.cpp
@@ -7,6 +7,86 @@
   constexpr bool TOKENPASTE2(rqure, __LINE__) = e;                             \
   REQUIRE(e);
 
+template <class Exp, class F>
+constexpr auto hasMap_impl(int, Exp&& e, F&& f)
+  -> decltype(std::forward<Exp>(e).map(std::forward<F>(f)), true) {
+  return true;
+}
+
+template <class Exp, class F>
+constexpr bool hasMap_impl(long, Exp&&, F&&) { return false; }
+
+template <class Exp, class F>
+constexpr bool hasMap(Exp&& e, F&& f) {
+  return hasMap_impl(42, std::forward<Exp>(e), std::forward<F>(f));
+}
+
+TEST_CASE("map is SFINAE-friendly", "[extensions.map.sfinae]") {
+  auto mul2 = [](int a) { return a * 2; };
+  auto ret_void = [](int a) {};
+
+  {
+    tl::expected<int, int> e = 21;
+    STATIC_REQUIRE(hasMap(e, mul2));
+    STATIC_REQUIRE(hasMap(std::move(e), mul2));
+    STATIC_REQUIRE(hasMap(e, std::move(mul2)));
+    STATIC_REQUIRE(hasMap(std::move(e), std::move(mul2)));
+  }
+  {
+    const tl::expected<int, int> ce = 21;
+    STATIC_REQUIRE(hasMap(ce, mul2));
+    STATIC_REQUIRE(hasMap(std::move(ce), mul2));
+    STATIC_REQUIRE(hasMap(ce, std::move(mul2)));
+    STATIC_REQUIRE(hasMap(std::move(ce), std::move(mul2)));
+  }
+  {
+    tl::expected<void, int> ev;
+    tl::expected<int, int> ei = 21;
+
+    STATIC_REQUIRE(!hasMap(ev, 42));
+    STATIC_REQUIRE(!hasMap(ei, 42));
+
+    STATIC_REQUIRE(!hasMap(ev, mul2));
+    STATIC_REQUIRE(hasMap(ei, mul2));
+
+    auto wrongParamType = [](char *) { return 21; };
+    STATIC_REQUIRE(!hasMap(ev, wrongParamType));
+    STATIC_REQUIRE(!hasMap(ei, wrongParamType));
+
+    auto voidParamType = []() { return 21; };
+    STATIC_REQUIRE(hasMap(ev, voidParamType));
+    STATIC_REQUIRE(!hasMap(ei, voidParamType));
+
+    auto voidReturnVoidParam = []() {};
+    STATIC_REQUIRE(hasMap(ev, voidReturnVoidParam));
+    STATIC_REQUIRE(!hasMap(ei, voidReturnVoidParam));
+
+    auto voidReturnIntParam = [](int) {};
+    STATIC_REQUIRE(!hasMap(ev, voidReturnIntParam));
+    STATIC_REQUIRE(hasMap(ei, voidReturnIntParam));
+
+    auto voidReturnWrongParam = [](char *) {};
+    STATIC_REQUIRE(!hasMap(ev, voidReturnWrongParam));
+    STATIC_REQUIRE(!hasMap(ei, voidReturnWrongParam));
+  }
+  {
+    tl::expected<int, int> e = 21;
+    const tl::expected<int, int> ce = 21;
+
+    auto lvalueParam = [](int&) { return 21; };
+    STATIC_REQUIRE(hasMap(e, lvalueParam));
+    STATIC_REQUIRE(!hasMap(std::move(e), lvalueParam));
+    STATIC_REQUIRE(!hasMap(ce, lvalueParam));
+    STATIC_REQUIRE(!hasMap(std::move(ce), lvalueParam));
+
+    auto rvalueParam = [](int&&) { return 21; };
+    STATIC_REQUIRE(!hasMap(e, rvalueParam));
+    STATIC_REQUIRE(hasMap(std::move(e), rvalueParam));
+    STATIC_REQUIRE(!hasMap(ce, rvalueParam));
+    STATIC_REQUIRE(!hasMap(std::move(ce), rvalueParam));
+  }
+}
+
 TEST_CASE("Map extensions", "[extensions.map]") {
   auto mul2 = [](int a) { return a * 2; };
   auto ret_void = [](int a) {};
@@ -141,6 +221,43 @@ TEST_CASE("Map extensions", "[extensions.map]") {
   }
 }
 
+TEST_CASE("Map on expected<void>", "[extensions.map.void]") {
+  {
+    tl::expected<void, int> a;
+    REQUIRE(a.has_value());
+    bool called = false;
+    tl::expected<void, int> b = a.map([&](){ called = true; });
+    REQUIRE(called);
+    REQUIRE(b.has_value());
+  }
+  {
+    tl::expected<void, int> a = tl::make_unexpected(42);
+    REQUIRE(!a.has_value());
+    bool called = false;
+    tl::expected<void, int> b = a.map([&](){ called = true; });
+    REQUIRE(!called);
+    REQUIRE(!b.has_value());
+    REQUIRE(b.error() == 42);
+  }
+  {
+    tl::expected<void, int> a;
+    REQUIRE(a.has_value());
+    bool called = false;
+    tl::expected<int, int> b = a.map([&](){ called = true; return 3; });
+    REQUIRE(called);
+    REQUIRE(b.value() == 3);
+  }
+  {
+    tl::expected<void, int> a = tl::make_unexpected(42);
+    REQUIRE(!a.has_value());
+    bool called = false;
+    tl::expected<int, int> b = a.map([&](){ called = true; return 3; });
+    REQUIRE(!called);
+    REQUIRE(!b.has_value());
+    REQUIRE(b.error() == 42);
+  }
+}
+
 TEST_CASE("Map error extensions", "[extensions.map_error]") {
   auto mul2 = [](int a) { return a * 2; };
   auto ret_void = [](int a) {};
@@ -251,6 +368,77 @@ TEST_CASE("Map error extensions", "[extensions.map_error]") {
 
 }
 
+template <class Exp, class F>
+constexpr auto hasAndThen_impl(int, Exp&& e, F&& f)
+  -> decltype(std::forward<Exp>(e).and_then(std::forward<F>(f)), true) {
+  return true;
+}
+
+template <class Exp, class F>
+constexpr bool hasAndThen_impl(long, Exp&&, F&&) { return false; }
+
+template <class Exp, class F>
+constexpr bool hasAndThen(Exp&& e, F&& f) {
+  return hasAndThen_impl(42, std::forward<Exp>(e), std::forward<F>(f));
+}
+
+TEST_CASE("and_then is SFINAE-friendly", "[extensions.and_then.sfinae]") {
+  auto succeed = [](int) { return tl::expected<int, int>(21 * 2); };
+
+  {
+    tl::expected<int, int> e = 21;
+    STATIC_REQUIRE(hasAndThen(e, succeed));
+    STATIC_REQUIRE(hasAndThen(std::move(e), succeed));
+    STATIC_REQUIRE(hasAndThen(e, std::move(succeed)));
+    STATIC_REQUIRE(hasAndThen(std::move(e), std::move(succeed)));
+  }
+  {
+    const tl::expected<int, int> ce = 21;
+    STATIC_REQUIRE(hasAndThen(ce, succeed));
+    STATIC_REQUIRE(hasAndThen(std::move(ce), succeed));
+    STATIC_REQUIRE(hasAndThen(ce, std::move(succeed)));
+    STATIC_REQUIRE(hasAndThen(std::move(ce), std::move(succeed)));
+  }
+  {
+    tl::expected<int, int> e = 21;
+    STATIC_REQUIRE(!hasAndThen(e, 42));
+
+    auto wrongParamType = [](char *) { return tl::expected<int, int>(); };
+    STATIC_REQUIRE(!hasAndThen(e, wrongParamType));
+
+    auto wrongParamType2 = []() { return tl::expected<int, int>(); };
+    STATIC_REQUIRE(!hasAndThen(e, wrongParamType2));
+
+    auto wrongReturnType = [](int) { return 21; };
+    STATIC_REQUIRE(!hasAndThen(e, wrongReturnType));
+
+    auto wrongReturnType2 = [](int) { return tl::expected<char*, char*>(); };
+    STATIC_REQUIRE(!hasAndThen(e, wrongReturnType2));
+
+    auto voidReturnType = [](int) {};
+    STATIC_REQUIRE(!hasAndThen(e, voidReturnType));
+
+    auto voidReturnWrongParam = [](char *) {};
+    STATIC_REQUIRE(!hasAndThen(e, voidReturnWrongParam));
+  }
+  {
+    tl::expected<int, int> e = 21;
+    const tl::expected<int, int> ce = 21;
+
+    auto lvalueParam = [](int&) { return tl::expected<int, int>(); };
+    STATIC_REQUIRE(hasAndThen(e, lvalueParam));
+    STATIC_REQUIRE(!hasAndThen(std::move(e), lvalueParam));
+    STATIC_REQUIRE(!hasAndThen(ce, lvalueParam));
+    STATIC_REQUIRE(!hasAndThen(std::move(ce), lvalueParam));
+
+    auto rvalueParam = [](int&&) { return tl::expected<int, int>(); };
+    STATIC_REQUIRE(!hasAndThen(e, rvalueParam));
+    STATIC_REQUIRE(hasAndThen(std::move(e), rvalueParam));
+    STATIC_REQUIRE(!hasAndThen(ce, rvalueParam));
+    STATIC_REQUIRE(!hasAndThen(std::move(ce), rvalueParam));
+  }
+}
+
 TEST_CASE("And then extensions", "[extensions.and_then]") {
   auto succeed = [](int a) { return tl::expected<int, int>(21 * 2); };
   auto fail = [](int a) { return tl::expected<int, int>(tl::unexpect, 17); };