diff --git a/.github/.licenserc.yaml b/.github/.licenserc.yaml
index a667c903e..dcfcd64f6 100644
--- a/.github/.licenserc.yaml
+++ b/.github/.licenserc.yaml
@@ -29,6 +29,7 @@ header:
     - 'LICENSE'
     - 'NOTICE'
     - 'requirements.txt'
+    - 'src/iceberg/expected.h'
     - 'src/iceberg/util/murmurhash3_internal.*'
     - 'src/iceberg/test/resources/**'
     - 'src/iceberg/catalog/hive/gen-cpp/**'
diff --git a/LICENSE b/LICENSE
index d0429e24b..6d0d88e91 100644
--- a/LICENSE
+++ b/LICENSE
@@ -230,6 +230,34 @@ License: https://www.apache.org/licenses/LICENSE-2.0
 
 --------------------------------------------------------------------------------
 
+This product includes code from zeus-cpp/expected.
+
+* src/iceberg/expected.h is adapted from zeus-cpp/expected.
+
+Copyright: 2024 zeus-cpp.
+Home page: https://github.com/zeus-cpp/expected
+License: MIT
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+--------------------------------------------------------------------------------
+
 This product bundles utf8proc, which is available under the MIT License:
 
 utf8proc is a software package originally developed by Jan Behrens and the rest
diff --git a/example/CMakeLists.txt b/example/CMakeLists.txt
index a9bf73cf0..396109e2d 100644
--- a/example/CMakeLists.txt
+++ b/example/CMakeLists.txt
@@ -20,13 +20,67 @@ cmake_minimum_required(VERSION 3.25)
 
 project(example)
 
-set(CMAKE_CXX_STANDARD 23)
+set(CMAKE_CXX_STANDARD 20)
 
 find_package(iceberg CONFIG REQUIRED COMPONENTS bundle rest)
 
+if(TARGET iceberg::iceberg_bundle_shared)
+  set(ICEBERG_BUNDLE_TARGET iceberg::iceberg_bundle_shared)
+else()
+  set(ICEBERG_BUNDLE_TARGET iceberg::iceberg_bundle_static)
+endif()
+
+if(TARGET iceberg::iceberg_rest_shared)
+  set(ICEBERG_REST_TARGET iceberg::iceberg_rest_shared)
+else()
+  set(ICEBERG_REST_TARGET iceberg::iceberg_rest_static)
+endif()
+
 add_executable(demo_example demo_example.cc)
 
-target_link_libraries(demo_example
-                      PRIVATE "$<IF:$<TARGET_EXISTS:iceberg::iceberg_bundle_shared>,iceberg::iceberg_bundle_shared,iceberg::iceberg_bundle_static>"
-                              "$<IF:$<TARGET_EXISTS:iceberg::iceberg_rest_shared>,iceberg::iceberg_rest_shared,iceberg::iceberg_rest_static>"
-)
+target_link_libraries(demo_example PRIVATE ${ICEBERG_BUNDLE_TARGET}
+                                           ${ICEBERG_REST_TARGET})
+
+# Compile every installed public header as a C++20 consumer. The installed include
+# tree is the public API contract: iceberg_install_all_headers excludes internal
+# headers before packaging them.
+get_target_property(ICEBERG_BUNDLE_INCLUDE_DIRS ${ICEBERG_BUNDLE_TARGET}
+                    INTERFACE_INCLUDE_DIRECTORIES)
+foreach(ICEBERG_INCLUDE_DIR IN LISTS ICEBERG_BUNDLE_INCLUDE_DIRS)
+  if(EXISTS "${ICEBERG_INCLUDE_DIR}/iceberg")
+    set(ICEBERG_PUBLIC_INCLUDE_DIR "${ICEBERG_INCLUDE_DIR}")
+    break()
+  endif()
+endforeach()
+
+if(NOT ICEBERG_PUBLIC_INCLUDE_DIR)
+  message(FATAL_ERROR "Could not locate iceberg's installed public headers")
+endif()
+
+file(GLOB_RECURSE
+     ICEBERG_PUBLIC_HEADERS
+     CONFIGURE_DEPENDS
+     "${ICEBERG_PUBLIC_INCLUDE_DIR}/iceberg/*.h"
+     "${ICEBERG_PUBLIC_INCLUDE_DIR}/iceberg/*.hpp")
+list(SORT ICEBERG_PUBLIC_HEADERS)
+
+set(ICEBERG_PUBLIC_HEADER_CHECK_SOURCE
+    "// Generated from iceberg's installed public headers.\n")
+foreach(ICEBERG_PUBLIC_HEADER IN LISTS ICEBERG_PUBLIC_HEADERS)
+  file(RELATIVE_PATH ICEBERG_PUBLIC_HEADER_RELATIVE_PATH "${ICEBERG_PUBLIC_INCLUDE_DIR}"
+       "${ICEBERG_PUBLIC_HEADER}")
+  string(APPEND ICEBERG_PUBLIC_HEADER_CHECK_SOURCE
+         "#include <${ICEBERG_PUBLIC_HEADER_RELATIVE_PATH}>\n")
+endforeach()
+string(APPEND ICEBERG_PUBLIC_HEADER_CHECK_SOURCE "\nint main() { return 0; }\n")
+
+file(GENERATE
+     OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/public_headers_cxx20.cc"
+     CONTENT "${ICEBERG_PUBLIC_HEADER_CHECK_SOURCE}")
+
+add_executable(public_headers_cxx20 "${CMAKE_CURRENT_BINARY_DIR}/public_headers_cxx20.cc")
+set_target_properties(public_headers_cxx20
+                      PROPERTIES CXX_STANDARD 20 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS
+                                                                          OFF)
+target_link_libraries(public_headers_cxx20 PRIVATE ${ICEBERG_BUNDLE_TARGET}
+                                                   ${ICEBERG_REST_TARGET})
diff --git a/src/iceberg/expected.h b/src/iceberg/expected.h
new file mode 100644
index 000000000..9754ac0ba
--- /dev/null
+++ b/src/iceberg/expected.h
@@ -0,0 +1,2401 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2024 zeus-cpp
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#pragma once
+
+#include <exception>
+#include <functional>
+#include <type_traits>
+#include <utility>
+#include <version>
+#if defined(__cpp_lib_expected) && __cpp_lib_expected >= 202202L
+#  include <expected>
+#endif
+
+#include "iceberg/iceberg_export.h"
+
+// NOLINTBEGIN
+
+namespace iceberg {
+
+namespace expected_detail {
+
+template <class T, template <class...> class Template>
+inline constexpr bool is_specialization_v =
+    false;  // true if and only if T is a specialization of Template
+template <template <class...> class Template, class... Types>
+inline constexpr bool is_specialization_v<Template<Types...>, Template> = true;
+
+template <class T, class U>
+using is_void_or = std::conditional_t<std::is_void_v<T>, std::true_type, U>;
+template <class T, class U>
+inline constexpr bool is_void_or_v = is_void_or<T, U>::value;
+
+template <class T>
+inline constexpr bool is_trivially_destructible_or_void_v =
+    is_void_or_v<T, std::is_trivially_destructible<T>>;
+
+template <class T>
+inline constexpr bool is_trivially_copy_constructible_or_void_v =
+    is_void_or_v<T, std::is_trivially_copy_constructible<T>>;
+
+template <class T>
+inline constexpr bool is_trivially_move_constructible_or_void_v =
+    is_void_or_v<T, std::is_trivially_move_constructible<T>>;
+
+template <class T>
+inline constexpr bool is_trivially_copy_assignable_or_void_v =
+    is_void_or_v<T, std::is_trivially_copy_assignable<T>>;
+
+template <class T>
+inline constexpr bool is_trivially_move_assignable_or_void_v =
+    is_void_or_v<T, std::is_trivially_move_assignable<T>>;
+
+template <class T>
+inline constexpr bool is_nothrow_copy_constructible_or_void_v =
+    is_void_or_v<T, std::is_nothrow_copy_constructible<T>>;
+
+template <class T>
+inline constexpr bool is_nothrow_move_constructible_or_void_v =
+    is_void_or_v<T, std::is_nothrow_move_constructible<T>>;
+
+template <class T>
+inline constexpr bool is_default_constructible_or_void_v =
+    is_void_or_v<T, std::is_default_constructible<T>>;
+
+template <class T>
+inline constexpr bool is_copy_constructible_or_void_v =
+    is_void_or_v<T, std::is_copy_constructible<T>>;
+
+template <class T>
+inline constexpr bool is_move_constructible_or_void_v =
+    is_void_or_v<T, std::is_move_constructible<T>>;
+
+template <class T>
+inline constexpr bool is_copy_assignable_or_void_v =
+    is_void_or_v<T, std::is_copy_assignable<T>>;
+
+template <class T>
+inline constexpr bool is_move_assignable_or_void_v =
+    is_void_or_v<T, std::is_move_assignable<T>>;
+
+template <class From, class To>
+inline constexpr bool is_nothrow_convertible_v =
+    noexcept(static_cast<To>(std::declval<From>()));
+
+}  // namespace expected_detail
+
+template <class E>
+class unexpected;
+
+namespace expected_detail {
+
+template <class E>
+struct is_error_type_valid : std::true_type {
+  static_assert(std::is_object_v<E>, "E must be an object type");
+  static_assert(!std::is_array_v<E>, "E must not be an array");
+  static_assert(!std::is_const_v<E>, "E must not be const");
+  static_assert(!std::is_volatile_v<E>, "E must not be volatile");
+  static_assert(!expected_detail::is_specialization_v<std::remove_cv_t<E>, unexpected>,
+                "E must not be unexpected");
+};
+template <class T>
+inline constexpr bool is_error_type_valid_v = is_error_type_valid<T>::value;
+
+}  // namespace expected_detail
+
+template <class E>
+class ICEBERG_EXPORT [[nodiscard]] unexpected {
+ public:
+  static_assert(expected_detail::is_error_type_valid_v<E>);
+
+  unexpected() = delete;
+  ~unexpected() = default;
+
+  unexpected(const unexpected&) = default;
+  unexpected(unexpected&&) = default;
+
+  template <class... Args,
+            typename std::enable_if_t<std::is_constructible_v<E, Args...>>* = nullptr>
+  constexpr explicit unexpected(std::in_place_t, Args&&... args) noexcept(
+      std::is_nothrow_constructible_v<E, Args...>)
+      : m_val(std::forward<Args>(args)...) {}
+
+  template <class U, class... Args,
+            typename std::enable_if_t<std::is_constructible_v<
+                E, std::initializer_list<U>&, Args...>>* = nullptr>
+  constexpr explicit unexpected(
+      std::in_place_t, std::initializer_list<U> l,
+      Args&&... args) noexcept(std::is_nothrow_constructible_v<E,
+                                                               std::initializer_list<U>&,
+                                                               Args...>)
+      : m_val(l, std::forward<Args>(args)...) {}
+
+  template <class Err = E,
+            typename std::enable_if_t<std::is_constructible_v<E, Err>>* = nullptr>
+  constexpr explicit unexpected(Err&& e) noexcept(std::is_nothrow_constructible_v<E, Err>)
+      : m_val(std::forward<Err>(e)) {}
+
+  unexpected& operator=(const unexpected&) = default;
+  unexpected& operator=(unexpected&&) = default;
+
+  constexpr const E& error() const& noexcept { return m_val; }
+  constexpr E& error() & noexcept { return m_val; }
+  constexpr E&& error() && noexcept { return std::move(m_val); }
+  constexpr const E&& error() const&& noexcept { return std::move(m_val); }
+
+  constexpr void swap(unexpected& other) noexcept(std::is_nothrow_swappable_v<E>) {
+    static_assert(std::is_swappable_v<E>, "E must be swappable");
+    using std::swap;
+    swap(m_val, other.m_val);
+  }
+
+  friend constexpr void swap(unexpected& x, unexpected& y) noexcept(noexcept(x.swap(y))) {
+    x.swap(y);
+  }
+
+  template <class E2>
+  friend constexpr bool operator==(
+      const unexpected& lhs,
+      const unexpected<E2>& rhs) noexcept(noexcept(lhs.error() == rhs.error())) {
+    return lhs.error() == rhs.error();
+  }
+  template <class E2>
+  friend constexpr bool operator!=(
+      const unexpected& lhs,
+      const unexpected<E2>& rhs) noexcept(noexcept(lhs.error() != rhs.error())) {
+    return lhs.error() != rhs.error();
+  }
+
+ private:
+  E m_val;
+};
+
+// deduction guide
+template <class E>
+unexpected(E) -> unexpected<E>;
+
+struct ICEBERG_EXPORT unexpect_t {
+  explicit unexpect_t() = default;
+};
+inline constexpr unexpect_t unexpect{};
+
+template <class E>
+class bad_expected_access;
+
+template <>
+class ICEBERG_EXPORT bad_expected_access<void> : public std::exception {
+ public:
+  const char* what() const noexcept override { return "Bad expected access"; }
+
+ protected:
+  bad_expected_access() = default;
+  bad_expected_access(const bad_expected_access&) = default;
+  bad_expected_access(bad_expected_access&&) = default;
+  bad_expected_access& operator=(const bad_expected_access&) = default;
+  bad_expected_access& operator=(bad_expected_access&&) = default;
+};
+
+template <class E>
+class ICEBERG_EXPORT bad_expected_access : public bad_expected_access<void> {
+ public:
+  explicit bad_expected_access(E e) noexcept(std::is_nothrow_move_constructible_v<E>)
+      : m_val(std::move(e)) {}
+
+  const E& error() const& noexcept { return m_val; }
+  E& error() & noexcept { return m_val; }
+  const E&& error() const&& noexcept { return std::move(m_val); }
+  E&& error() && noexcept { return std::move(m_val); }
+
+ private:
+  E m_val;
+};
+
+template <class T, class E>
+class expected;
+
+namespace expected_detail {
+template <class T>
+
+struct is_value_type_valid : std::true_type {
+  static_assert(!std::is_reference_v<T>, "T must not be a reference");
+  static_assert(!std::is_function_v<T>, "T must not be a function");
+  static_assert(!std::is_array_v<T>,
+                "T must not be an array to meet the requirements of Cpp17Destructible "
+                "when T is not cv-void");
+  static_assert(!std::is_same_v<T, std::remove_cv_t<std::in_place_t>>,
+                "T must not be in_place_t");
+  static_assert(!std::is_same_v<T, std::remove_cv_t<unexpect_t>>,
+                "T must not be unexpect_t");
+  static_assert(!expected_detail::is_specialization_v<std::remove_cv_t<T>, unexpected>,
+                "T must not be unexpected");
+};
+
+template <class T>
+inline constexpr bool is_value_type_valid_v = is_value_type_valid<T>::value;
+
+template <class T, class E, class U>
+using enable_forward_t = std::enable_if_t<
+    std::is_constructible_v<T, U> &&
+    !std::is_same_v<std::remove_cvref_t<U>, std::in_place_t> &&
+    !std::is_same_v<expected<T, E>, std::remove_cvref_t<U>> &&
+    !expected_detail::is_specialization_v<std::remove_cvref_t<U>, unexpected> &&
+    (!std::is_same_v<std::remove_cv_t<T>, bool> ||  // LWG-3836
+     !expected_detail::is_specialization_v<std::remove_cvref_t<U>, expected>)>;
+
+template <class T, class E, class U, class G, class UF, class GF>
+using enable_from_other_expected_t = std::enable_if_t<
+    std::is_constructible_v<T, UF> && std::is_constructible_v<E, GF> &&
+    std::disjunction_v<std::is_same<std::remove_cv_t<T>, bool>,  // LWG-3836
+                       std::negation<std::disjunction<
+                           std::is_constructible<T, expected<U, G>&>,
+                           std::is_constructible<T, expected<U, G>>,
+                           std::is_constructible<T, const expected<U, G>&>,
+                           std::is_constructible<T, const expected<U, G>>,
+                           std::is_convertible<expected<U, G>&, T>,
+                           std::is_convertible<expected<U, G>&&, T>,
+                           std::is_convertible<const expected<U, G>&, T>,
+                           std::is_convertible<const expected<U, G>&&, T>,
+                           std::is_constructible<unexpected<E>, expected<U, G>&>,
+                           std::is_constructible<unexpected<E>, expected<U, G>>,
+                           std::is_constructible<unexpected<E>, const expected<U, G>&>,
+                           std::is_constructible<unexpected<E>, const expected<U, G>>>>>>;
+
+template <class E, class U, class G, class GF>
+using enable_from_other_void_expected_t =
+    std::enable_if_t<std::is_void_v<U> && std::is_constructible_v<E, GF> &&
+                     std::negation_v<std::disjunction<
+                         std::is_constructible<unexpected<E>, expected<U, G>&>,
+                         std::is_constructible<unexpected<E>, expected<U, G>>,
+                         std::is_constructible<unexpected<E>, const expected<U, G>&>,
+                         std::is_constructible<unexpected<E>, const expected<U, G>>>>>;
+
+}  // namespace expected_detail
+
+namespace expected_detail {
+
+struct no_init_t {
+  explicit no_init_t() = default;
+};
+inline constexpr no_init_t no_init{};
+
+struct construct_with_invoke_result_t {
+  explicit construct_with_invoke_result_t() = default;
+};
+inline constexpr construct_with_invoke_result_t construct_with_invoke_result{};
+
+template <class T>
+struct [[nodiscard]] ReinitGuard {
+  static_assert(std::is_nothrow_move_constructible_v<T>);
+
+  ReinitGuard(ReinitGuard const&) = delete;
+  ReinitGuard& operator=(ReinitGuard const&) = delete;
+
+  constexpr ReinitGuard(T* target, T* tmp) noexcept : _target(target), _tmp(tmp) {}
+  constexpr ~ReinitGuard() noexcept {
+    if (_target) {
+      std::construct_at(_target, std::move(*_tmp));
+    }
+  }
+  T* _target;
+  T* _tmp;
+};
+
+template <class First, class Second, class... Args>
+constexpr void reinit_expected(First& new_val, Second& old_val, Args&&... args) noexcept(
+    std::is_nothrow_constructible_v<First, Args...>) {
+  if constexpr (std::is_nothrow_constructible_v<First, Args...>) {
+    if constexpr (!std::is_trivially_destructible_v<Second>) {
+      old_val.~Second();
+    }
+    std::construct_at(std::addressof(new_val), std::forward<Args>(args)...);
+  } else if constexpr (std::is_nothrow_move_constructible_v<First>) {
+    First tmp(std::forward<Args>(args)...);
+    if constexpr (!std::is_trivially_destructible_v<Second>) {
+      old_val.~Second();
+    }
+    std::construct_at(std::addressof(new_val), std::move(tmp));
+  } else {
+    Second tmp(std::move(old_val));
+    if constexpr (!std::is_trivially_destructible_v<Second>) {
+      old_val.~Second();
+    }
+
+    expected_detail::ReinitGuard<Second> guard{std::addressof(old_val),
+                                               std::addressof(tmp)};
+    std::construct_at(std::addressof(new_val), std::forward<Args>(args)...);
+    guard._target = nullptr;
+  }
+}
+
+// Implements the storage of the values, and ensures that the destructor is
+// trivial if it can be.
+//
+// This specialization is for when `T` and `E` are trivially destructible
+template <class T, class E,
+          bool = is_trivially_destructible_or_void_v<T> &&
+                 std::is_trivially_destructible_v<E>>
+struct storage_base {
+  storage_base(storage_base const&) = default;
+  storage_base(storage_base&&) = default;
+  storage_base& operator=(storage_base const&) = default;
+  storage_base& operator=(storage_base&&) = default;
+
+  template <class U = T, std::enable_if_t<std::is_default_constructible_v<U>, int> = 0>
+  constexpr storage_base() noexcept(std::is_nothrow_default_constructible_v<U>)
+      : m_val(), m_has_val(true) {}
+  constexpr storage_base(no_init_t) noexcept : m_no_init(), m_has_val(false) {}
+
+  template <class... Args,
+            std::enable_if_t<std::is_constructible_v<T, Args&&...>>* = nullptr>
+  constexpr explicit storage_base(std::in_place_t, Args&&... args) noexcept(
+      noexcept(T(std::forward<Args>(args)...)))
+      : m_val(std::forward<Args>(args)...), m_has_val(true) {}
+
+  template <class U, class... Args,
+            std::enable_if_t<std::is_constructible_v<T, std::initializer_list<U>&,
+                                                     Args&&...>>* = nullptr>
+  constexpr explicit storage_base(
+      std::in_place_t, std::initializer_list<U> il,
+      Args&&... args) noexcept(noexcept(T(il, std::forward<Args>(args)...)))
+      : m_val(il, std::forward<Args>(args)...), m_has_val(true) {}
+
+  template <class... Args,
+            std::enable_if_t<std::is_constructible_v<E, Args&&...>>* = nullptr>
+  constexpr explicit storage_base(unexpect_t, Args&&... args) noexcept(
+      noexcept(E(std::forward<Args>(args)...)))
+      : m_unexpect(std::forward<Args>(args)...), m_has_val(false) {}
+
+  template <class U, class... Args,
+            std::enable_if_t<std::is_constructible_v<E, std::initializer_list<U>&,
+                                                     Args&&...>>* = nullptr>
+  constexpr explicit storage_base(
+      unexpect_t, std::initializer_list<U> il,
+      Args&&... args) noexcept(noexcept(E(il, std::forward<Args>(args)...)))
+      : m_unexpect(il, std::forward<Args>(args)...), m_has_val(false) {}
+
+  // helper ctor for transform()
+  template <class Fn, class... Args>
+  constexpr explicit storage_base(construct_with_invoke_result_t, Fn&& func,
+                                  Args&&... args)  //
+      noexcept(noexcept(static_cast<T>(std::invoke(std::forward<Fn>(func),
+                                                   std::forward<Args>(args)...))))
+      : m_val(std::invoke(std::forward<Fn>(func), std::forward<Args>(args)...)),
+        m_has_val(true) {}
+
+  // helper ctor for transform_error()
+  template <class Fn, class... Args>
+  constexpr explicit storage_base(construct_with_invoke_result_t, unexpect_t, Fn&& func,
+                                  Args&&... args)  //
+      noexcept(noexcept(static_cast<E>(std::invoke(std::forward<Fn>(func),
+                                                   std::forward<Args>(args)...))))
+      : m_unexpect(std::invoke(std::forward<Fn>(func), std::forward<Args>(args)...)),
+        m_has_val(false) {}
+
+  ~storage_base() = default;
+
+  union {
+    T m_val;
+    E m_unexpect;
+    char m_no_init;
+  };
+  bool m_has_val;
+};
+
+template <class T, class E>
+struct storage_base<T, E, false> {
+  storage_base(storage_base const&) = default;
+  storage_base(storage_base&&) = default;
+  storage_base& operator=(storage_base const&) = default;
+  storage_base& operator=(storage_base&&) = default;
+
+  template <class U = T, std::enable_if_t<std::is_default_constructible_v<U>, int> = 0>
+  constexpr storage_base() noexcept(std::is_nothrow_default_constructible_v<U>)
+      : m_val(), m_has_val(true) {}
+  constexpr storage_base(no_init_t) noexcept : m_no_init(), m_has_val(false) {}
+
+  template <class... Args,
+            std::enable_if_t<std::is_constructible_v<T, Args&&...>>* = nullptr>
+  constexpr explicit storage_base(std::in_place_t, Args&&... args) noexcept(
+      noexcept(T(std::forward<Args>(args)...)))
+      : m_val(std::forward<Args>(args)...), m_has_val(true) {}
+
+  template <class U, class... Args,
+            std::enable_if_t<std::is_constructible_v<T, std::initializer_list<U>&,
+                                                     Args&&...>>* = nullptr>
+  constexpr explicit storage_base(
+      std::in_place_t, std::initializer_list<U> il,
+      Args&&... args) noexcept(noexcept(T(il, std::forward<Args>(args)...)))
+      : m_val(il, std::forward<Args>(args)...), m_has_val(true) {}
+
+  template <class... Args,
+            std::enable_if_t<std::is_constructible_v<E, Args&&...>>* = nullptr>
+  constexpr explicit storage_base(unexpect_t, Args&&... args) noexcept(
+      noexcept(E(std::forward<Args>(args)...)))
+      : m_unexpect(std::forward<Args>(args)...), m_has_val(false) {}
+
+  template <class U, class... Args,
+            std::enable_if_t<std::is_constructible_v<E, std::initializer_list<U>&,
+                                                     Args&&...>>* = nullptr>
+  constexpr explicit storage_base(
+      unexpect_t, std::initializer_list<U> il,
+      Args&&... args) noexcept(noexcept(E(il, std::forward<Args>(args)...)))
+      : m_unexpect(il, std::forward<Args>(args)...), m_has_val(false) {}
+
+  // helper ctor for transform()
+  template <class Fn, class... Args>
+  constexpr explicit storage_base(construct_with_invoke_result_t, Fn&& func,
+                                  Args&&... args)  //
+      noexcept(noexcept(static_cast<T>(std::invoke(std::forward<Fn>(func),
+                                                   std::forward<Args>(args)...))))
+      : m_val(std::invoke(std::forward<Fn>(func), std::forward<Args>(args)...)),
+        m_has_val(true) {}
+
+  // helper ctor for transform_error()
+  template <class Fn, class... Args>
+  constexpr explicit storage_base(construct_with_invoke_result_t, unexpect_t, Fn&& func,
+                                  Args&&... args)  //
+      noexcept(noexcept(static_cast<E>(std::invoke(std::forward<Fn>(func),
+                                                   std::forward<Args>(args)...))))
+      : m_unexpect(std::invoke(std::forward<Fn>(func), std::forward<Args>(args)...)),
+        m_has_val(false) {}
+
+  constexpr ~storage_base() noexcept {
+    if (m_has_val) {
+      if constexpr (!std::is_trivially_destructible_v<T>) {
+        m_val.~T();
+      }
+    } else {
+      if constexpr (!std::is_trivially_destructible_v<E>) {
+        m_unexpect.~E();
+      }
+    }
+  }
+
+  union {
+    T m_val;
+    E m_unexpect;
+    char m_no_init;
+  };
+  bool m_has_val;
+};
+
+// `T` is `void`, `E` is trivially-destructible
+template <class E>
+struct storage_base<void, E, true> {
+  storage_base(storage_base const&) = default;
+  storage_base(storage_base&&) = default;
+  storage_base& operator=(storage_base const&) = default;
+  storage_base& operator=(storage_base&&) = default;
+
+  constexpr storage_base() noexcept : m_has_val(true) {}
+
+  constexpr storage_base(no_init_t) noexcept : m_val(), m_has_val(false) {}
+
+  constexpr explicit storage_base(std::in_place_t) noexcept : m_has_val(true) {}
+
+  template <class... Args,
+            std::enable_if_t<std::is_constructible_v<E, Args&&...>>* = nullptr>
+  constexpr explicit storage_base(unexpect_t, Args&&... args)
+      : m_unexpect(std::forward<Args>(args)...), m_has_val(false) {}
+
+  template <class U, class... Args,
+            std::enable_if_t<std::is_constructible_v<E, std::initializer_list<U>&,
+                                                     Args&&...>>* = nullptr>
+  constexpr explicit storage_base(unexpect_t, std::initializer_list<U> il, Args&&... args)
+      : m_unexpect(il, std::forward<Args>(args)...), m_has_val(false) {}
+
+  // helper ctor for transform_error()
+  template <class Fn, class... Args>
+  constexpr explicit storage_base(construct_with_invoke_result_t, unexpect_t, Fn&& func,
+                                  Args&&... args)  //
+      noexcept(noexcept(static_cast<E>(std::invoke(std::forward<Fn>(func),
+                                                   std::forward<Args>(args)...))))
+      : m_unexpect(std::invoke(std::forward<Fn>(func), std::forward<Args>(args)...)),
+        m_has_val(false) {}
+
+  ~storage_base() = default;
+
+  struct dummy {};
+
+  union {
+    E m_unexpect;
+    dummy m_val;
+  };
+
+  bool m_has_val;
+};
+
+// `T` is `void`, `E` is not trivially-destructible
+template <class E>
+struct storage_base<void, E, false> {
+  storage_base(storage_base const&) = default;
+  storage_base(storage_base&&) = default;
+  storage_base& operator=(storage_base const&) = default;
+  storage_base& operator=(storage_base&&) = default;
+
+  constexpr storage_base() noexcept : m_has_val(true) {}
+
+  constexpr storage_base(no_init_t) noexcept : m_val(), m_has_val(false) {}
+
+  constexpr explicit storage_base(std::in_place_t) noexcept : m_has_val(true) {}
+
+  template <class... Args,
+            std::enable_if_t<std::is_constructible_v<E, Args&&...>>* = nullptr>
+  constexpr explicit storage_base(unexpect_t, Args&&... args)
+      : m_unexpect(std::forward<Args>(args)...), m_has_val(false) {}
+
+  template <class U, class... Args,
+            std::enable_if_t<std::is_constructible_v<E, std::initializer_list<U>&,
+                                                     Args&&...>>* = nullptr>
+  constexpr explicit storage_base(unexpect_t, std::initializer_list<U> il, Args&&... args)
+      : m_unexpect(il, std::forward<Args>(args)...), m_has_val(false) {}
+
+  // helper ctor for transform_error()
+  template <class Fn, class... Args>
+  constexpr explicit storage_base(construct_with_invoke_result_t, unexpect_t, Fn&& func,
+                                  Args&&... args)  //
+      noexcept(noexcept(static_cast<E>(std::invoke(std::forward<Fn>(func),
+                                                   std::forward<Args>(args)...))))
+      : m_unexpect(std::invoke(std::forward<Fn>(func), std::forward<Args>(args)...)),
+        m_has_val(false) {}
+
+  constexpr ~storage_base() noexcept {
+    if (!m_has_val) {
+      m_unexpect.~E();
+    }
+  }
+
+  struct dummy {};
+
+  union {
+    E m_unexpect;
+    dummy m_val;
+  };
+
+  bool m_has_val;
+};
+
+// This base class provides some handy member functions which can be used in
+// further derived classes
+template <class T, class E>
+struct operations_base : storage_base<T, E> {
+  using storage_base<T, E>::storage_base;
+
+  template <class... Args>
+  constexpr void construct(Args&&... args) noexcept(
+      std::is_nothrow_constructible_v<T, Args...>) {
+    std::construct_at(&this->m_val, std::forward<Args>(args)...);
+    this->m_has_val = true;
+  }
+
+  template <class Rhs>
+  constexpr void construct_with(Rhs&& rhs) noexcept(
+      std::is_nothrow_constructible_v<T, Rhs>) {
+    std::construct_at(&this->m_val, std::forward<Rhs>(rhs).get());
+    this->m_has_val = true;
+  }
+
+  template <class... Args>
+  constexpr void construct_error(Args&&... args) noexcept(
+      std::is_nothrow_constructible_v<E, Args...>) {
+    std::construct_at(&this->m_unexpect, std::forward<Args>(args)...);
+    this->m_has_val = false;
+  }
+
+  constexpr T& get() & noexcept { return this->m_val; }
+  constexpr const T& get() const& noexcept { return this->m_val; }
+  constexpr T&& get() && noexcept(std::is_nothrow_move_constructible_v<T>) {
+    return std::move(this->m_val);
+  }
+  constexpr const T&& get() const&& noexcept(std::is_nothrow_move_constructible_v<T>) {
+    return std::move(this->m_val);
+  }
+
+  constexpr E& geterr() & noexcept { return this->m_unexpect; }
+  constexpr const E& geterr() const& noexcept { return this->m_unexpect; }
+  constexpr E&& geterr() && noexcept(std::is_nothrow_move_constructible_v<E>) {
+    return std::move(this->m_unexpect);
+  }
+  constexpr const E&& geterr() const&& noexcept(std::is_nothrow_move_constructible_v<E>) {
+    return std::move(this->m_unexpect);
+  }
+};
+
+// This base class provides some handy member functions which can be used in
+// further derived classes
+template <class E>
+struct operations_base<void, E> : storage_base<void, E> {
+  using storage_base<void, E>::storage_base;
+
+  constexpr void construct() noexcept { this->m_has_val = true; }
+
+  // This function doesn't use its argument, but needs it so that code in
+  // levels above this can work independently of whether T is void
+  template <class Rhs>
+  constexpr void construct_with(Rhs&&) noexcept {
+    this->m_has_val = true;
+  }
+
+  template <class... Args>
+  constexpr void construct_error(Args&&... args)  //
+      noexcept(std::is_nothrow_constructible_v<E, Args...>) {
+    std::construct_at(&this->m_unexpect, std::forward<Args>(args)...);
+    this->m_has_val = false;
+  }
+
+  constexpr E& geterr() & noexcept { return this->m_unexpect; }
+  constexpr const E& geterr() const& noexcept { return this->m_unexpect; }
+  constexpr E&& geterr() && noexcept(std::is_nothrow_move_constructible_v<E>) {
+    return std::move(this->m_unexpect);
+  }
+  constexpr const E&& geterr() const&& noexcept(std::is_nothrow_move_constructible_v<E>) {
+    return std::move(this->m_unexpect);
+  }
+};
+
+// This class manages conditionally having a trivial copy constructor
+// This specialization is for when T and E are trivially copy constructible
+template <class T, class E,
+          bool Enabled =
+              is_copy_constructible_or_void_v<T> && std::is_copy_constructible_v<E>,
+          bool Trivially = is_trivially_copy_constructible_or_void_v<T> &&
+                           std::is_trivially_copy_constructible_v<E>>
+struct copy_ctor_base : operations_base<T, E> {
+  using operations_base<T, E>::operations_base;
+};
+
+// This specialization is for when T or E are not copy constructible
+template <class T, class E>
+struct copy_ctor_base<T, E, false, false> : operations_base<T, E> {
+  using operations_base<T, E>::operations_base;
+
+  ~copy_ctor_base() = default;
+  copy_ctor_base() = default;
+  copy_ctor_base(const copy_ctor_base& rhs) = delete;
+  copy_ctor_base(copy_ctor_base&& rhs) = default;
+  copy_ctor_base& operator=(const copy_ctor_base& rhs) = default;
+  copy_ctor_base& operator=(copy_ctor_base&& rhs) = default;
+};
+
+// This specialization is for when T or E are not trivially copy constructible
+template <class T, class E>
+struct copy_ctor_base<T, E, true, false> : operations_base<T, E> {
+  using operations_base<T, E>::operations_base;
+
+  ~copy_ctor_base() = default;
+  copy_ctor_base() = default;
+
+  constexpr copy_ctor_base(const copy_ctor_base& rhs)  //
+      noexcept(is_nothrow_copy_constructible_or_void_v<T> &&
+               std::is_nothrow_copy_constructible_v<E>)
+      : operations_base<T, E>(no_init) {
+    if (rhs.m_has_val) {
+      this->construct_with(rhs);
+    } else {
+      this->construct_error(rhs.geterr());
+    }
+  }
+
+  copy_ctor_base(copy_ctor_base&& rhs) = default;
+  copy_ctor_base& operator=(const copy_ctor_base& rhs) = default;
+  copy_ctor_base& operator=(copy_ctor_base&& rhs) = default;
+};
+
+// This class manages conditionally having a trivial move constructor
+template <class T, class E,
+          bool Enabled =
+              is_move_constructible_or_void_v<T> && std::is_move_constructible_v<E>,
+          bool Trivially = is_trivially_move_constructible_or_void_v<T> &&
+                           std::is_trivially_move_constructible_v<E>>
+struct move_ctor_base : copy_ctor_base<T, E> {
+  using copy_ctor_base<T, E>::copy_ctor_base;
+};
+
+// This specialization is for when T or E are not move constructible
+template <class T, class E>
+struct move_ctor_base<T, E, false, false> : copy_ctor_base<T, E> {
+  using copy_ctor_base<T, E>::copy_ctor_base;
+
+  ~move_ctor_base() = default;
+  move_ctor_base() = default;
+  move_ctor_base(const move_ctor_base& rhs) = default;
+  move_ctor_base(move_ctor_base&& rhs) = delete;
+  move_ctor_base& operator=(const move_ctor_base& rhs) = default;
+  move_ctor_base& operator=(move_ctor_base&& rhs) = default;
+};
+
+// This specialization is for when T or E are not trivially move constructible
+template <class T, class E>
+struct move_ctor_base<T, E, true, false> : copy_ctor_base<T, E> {
+  using copy_ctor_base<T, E>::copy_ctor_base;
+
+  ~move_ctor_base() = default;
+  move_ctor_base() = default;
+  move_ctor_base(const move_ctor_base& rhs) = default;
+
+  constexpr move_ctor_base(move_ctor_base&& rhs)  //
+      noexcept(is_nothrow_move_constructible_or_void_v<T> &&
+               std::is_nothrow_move_constructible_v<E>)
+      : copy_ctor_base<T, E>(no_init) {
+    if (rhs.m_has_val) {
+      this->construct_with(std::move(rhs));
+    } else {
+      this->construct_error(std::move(rhs.geterr()));
+    }
+  }
+
+  move_ctor_base& operator=(const move_ctor_base& rhs) = default;
+  move_ctor_base& operator=(move_ctor_base&& rhs) = default;
+};
+
+template <class T, class E>
+inline constexpr bool is_expected_copy_assignable_v =
+    is_copy_assignable_or_void_v<T> && is_copy_constructible_or_void_v<T> &&
+    std::is_copy_assignable_v<E> && std::is_copy_constructible_v<E> &&
+    (is_nothrow_move_constructible_or_void_v<T> ||
+     std::is_nothrow_move_constructible_v<E>);
+
+// LWG-4026
+template <class T, class E>
+inline constexpr bool is_expected_trivially_copy_assignable_v =
+    is_trivially_copy_constructible_or_void_v<T> &&
+    is_trivially_copy_assignable_or_void_v<T> && is_trivially_destructible_or_void_v<T> &&
+    std::is_trivially_copy_constructible_v<E> && std::is_trivially_copy_assignable_v<E> &&
+    std::is_trivially_destructible_v<E>;
+
+// This class manages conditionally having a (possibly trivial) copy assignment operator
+template <class T, class E, bool Enabled = is_expected_copy_assignable_v<T, E>,
+          bool Trivially = is_expected_trivially_copy_assignable_v<T, E>>
+struct copy_assign_base : move_ctor_base<T, E> {
+  using move_ctor_base<T, E>::move_ctor_base;
+
+  ~copy_assign_base() = default;
+  copy_assign_base() = default;
+  copy_assign_base(const copy_assign_base& rhs) = default;
+  copy_assign_base(copy_assign_base&& rhs) = default;
+  copy_assign_base& operator=(const copy_assign_base& rhs) = default;
+  copy_assign_base& operator=(copy_assign_base&& rhs) = default;
+};
+
+template <class T, class E>
+struct copy_assign_base<T, E, false, false> : move_ctor_base<T, E> {
+  using move_ctor_base<T, E>::move_ctor_base;
+
+  ~copy_assign_base() = default;
+  copy_assign_base() = default;
+  copy_assign_base(const copy_assign_base& rhs) = default;
+  copy_assign_base(copy_assign_base&& rhs) = default;
+  copy_assign_base& operator=(const copy_assign_base& rhs) = delete;
+  copy_assign_base& operator=(copy_assign_base&& rhs) = default;
+};
+
+template <class T, class E>
+struct copy_assign_base<T, E, true, false> : move_ctor_base<T, E> {
+  using move_ctor_base<T, E>::move_ctor_base;
+
+  ~copy_assign_base() = default;
+  copy_assign_base() = default;
+  copy_assign_base(const copy_assign_base& rhs) = default;
+  copy_assign_base(copy_assign_base&& rhs) = default;
+
+  constexpr copy_assign_base& operator=(const copy_assign_base& rhs)  //
+      noexcept(std::is_nothrow_copy_constructible_v<T> &&
+               std::is_nothrow_copy_assignable_v<T> &&
+               std::is_nothrow_copy_constructible_v<E> &&
+               std::is_nothrow_copy_assignable_v<E>) {
+    if (this->m_has_val && rhs.m_has_val) {
+      this->m_val = rhs.m_val;
+    } else if (this->m_has_val) {
+      expected_detail::reinit_expected(this->m_unexpect, this->m_val, rhs.m_unexpect);
+    } else if (rhs.m_has_val) {
+      expected_detail::reinit_expected(this->m_val, this->m_unexpect, rhs.m_val);
+    } else {
+      this->m_unexpect = rhs.m_unexpect;
+    }
+    this->m_has_val = rhs.m_has_val;
+    return *this;
+  }
+
+  copy_assign_base& operator=(copy_assign_base&& rhs) = default;
+};
+
+template <class E>
+struct copy_assign_base<void, E, true, false> : move_ctor_base<void, E> {
+  using move_ctor_base<void, E>::move_ctor_base;
+
+  ~copy_assign_base() = default;
+  copy_assign_base() = default;
+  copy_assign_base(const copy_assign_base& rhs) = default;
+  copy_assign_base(copy_assign_base&& rhs) = default;
+
+  constexpr copy_assign_base& operator=(const copy_assign_base& rhs) noexcept(
+      std::is_nothrow_copy_constructible_v<E> && std::is_nothrow_copy_assignable_v<E>) {
+    if (this->m_has_val && rhs.m_has_val) {
+      // no-op
+    } else if (this->m_has_val) {
+      std::construct_at(std::addressof(this->m_unexpect), rhs.m_unexpect);
+      this->m_has_val = false;
+    } else if (rhs.m_has_val) {
+      this->m_unexpect.~E();
+      this->m_has_val = true;
+    } else {
+      this->m_unexpect = rhs.m_unexpect;
+    }
+    return *this;
+  }
+
+  copy_assign_base& operator=(copy_assign_base&& rhs) = default;
+};
+
+template <class T, class E>
+inline constexpr bool is_expected_move_assignable_v =
+    is_move_assignable_or_void_v<T> && is_move_constructible_or_void_v<T> &&
+    std::is_move_assignable_v<E> && std::is_move_constructible_v<E> &&
+    (is_nothrow_move_constructible_or_void_v<T> ||
+     std::is_nothrow_move_constructible_v<E>);
+
+// LWG-4026
+template <class T, class E>
+inline constexpr bool is_expected_trivially_move_assignable_v =
+    is_trivially_move_constructible_or_void_v<T> &&
+    is_trivially_move_assignable_or_void_v<T> && is_trivially_destructible_or_void_v<T> &&
+    std::is_trivially_move_constructible_v<E> && std::is_trivially_move_assignable_v<E> &&
+    std::is_trivially_destructible_v<E>;
+
+// This class manages conditionally having a (possibly trivial) move assignment operator
+template <class T, class E, bool Enabled = is_expected_move_assignable_v<T, E>,
+          bool Trivially = is_expected_trivially_move_assignable_v<T, E>>
+struct move_assign_base : copy_assign_base<T, E> {
+  using copy_assign_base<T, E>::copy_assign_base;
+
+  ~move_assign_base() = default;
+  move_assign_base() = default;
+  move_assign_base(const move_assign_base& rhs) = default;
+  move_assign_base(move_assign_base&& rhs) = default;
+  move_assign_base& operator=(const move_assign_base& rhs) = default;
+  move_assign_base& operator=(move_assign_base&& rhs) = default;
+};
+
+template <class T, class E>
+struct move_assign_base<T, E, false, false> : copy_assign_base<T, E> {
+  using copy_assign_base<T, E>::copy_assign_base;
+
+  ~move_assign_base() = default;
+  move_assign_base() = default;
+  move_assign_base(const move_assign_base& rhs) = default;
+  move_assign_base(move_assign_base&& rhs) = default;
+  move_assign_base& operator=(const move_assign_base& rhs) = default;
+  move_assign_base& operator=(move_assign_base&& rhs) = delete;
+};
+
+template <class T, class E>
+struct move_assign_base<T, E, true, false> : copy_assign_base<T, E> {
+  using copy_assign_base<T, E>::copy_assign_base;
+
+  ~move_assign_base() = default;
+  move_assign_base() = default;
+  move_assign_base(const move_assign_base& rhs) = default;
+  move_assign_base(move_assign_base&& rhs) = default;
+  move_assign_base& operator=(const move_assign_base& rhs) = default;
+
+  constexpr move_assign_base& operator=(move_assign_base&& rhs)  //
+      noexcept(std::is_nothrow_move_constructible_v<T> &&
+               std::is_nothrow_move_assignable_v<T> &&
+               std::is_nothrow_move_constructible_v<E> &&
+               std::is_nothrow_move_assignable_v<E>) {
+    if (this->m_has_val && rhs.m_has_val) {
+      this->m_val = std::move(rhs.m_val);
+    } else if (this->m_has_val) {
+      expected_detail::reinit_expected(this->m_unexpect, this->m_val,
+                                       std::move(rhs.m_unexpect));
+    } else if (rhs.m_has_val) {
+      expected_detail::reinit_expected(this->m_val, this->m_unexpect,
+                                       std::move(rhs.m_val));
+    } else {
+      this->m_unexpect = std::move(rhs.m_unexpect);
+    }
+    this->m_has_val = rhs.m_has_val;
+    return *this;
+  }
+};
+
+template <class E>
+struct move_assign_base<void, E, true, false> : copy_assign_base<void, E> {
+  using copy_assign_base<void, E>::copy_assign_base;
+
+  ~move_assign_base() = default;
+  move_assign_base() = default;
+  move_assign_base(const move_assign_base& rhs) = default;
+  move_assign_base(move_assign_base&& rhs) = default;
+  move_assign_base& operator=(const move_assign_base& rhs) = default;
+
+  constexpr move_assign_base& operator=(move_assign_base&& rhs)  //
+      noexcept(std::is_nothrow_move_constructible_v<E> &&
+               std::is_nothrow_move_assignable_v<E>) {
+    if (this->m_has_val && rhs.m_has_val) {
+      // no-op
+    } else if (this->m_has_val) {
+      std::construct_at(std::addressof(this->m_unexpect), std::move(rhs.m_unexpect));
+      this->m_has_val = false;
+    } else if (rhs.m_has_val) {
+      this->m_unexpect.~E();
+      this->m_has_val = true;
+    } else {
+      this->m_unexpect = std::move(rhs.m_unexpect);
+    }
+    return *this;
+  }
+};
+
+// This is needed to be able to construct the default_ctor_base which
+// follows, while still conditionally deleting the default constructor.
+struct default_constructor_tag {
+  explicit default_constructor_tag() = default;
+};
+
+// default_ctor_base will ensure that expected has a deleted default
+// consturctor if T is not default constructible.
+// This specialization is for when T is default constructible
+template <class T, class E, bool Enable = is_default_constructible_or_void_v<T>>
+struct default_ctor_base {
+  ~default_ctor_base() = default;
+  default_ctor_base() = default;
+  default_ctor_base(default_ctor_base const&) = default;
+  default_ctor_base(default_ctor_base&&) = default;
+  default_ctor_base& operator=(default_ctor_base const&) = default;
+  default_ctor_base& operator=(default_ctor_base&&) = default;
+
+  constexpr explicit default_ctor_base(default_constructor_tag) {}
+};
+
+// This specialization is for when T is not default constructible
+template <class T, class E>
+struct default_ctor_base<T, E, false> {
+  ~default_ctor_base() = default;
+  default_ctor_base() = delete;
+  default_ctor_base(default_ctor_base const&) = default;
+  default_ctor_base(default_ctor_base&&) = default;
+  default_ctor_base& operator=(default_ctor_base const&) = default;
+  default_ctor_base& operator=(default_ctor_base&&) = default;
+
+  constexpr explicit default_ctor_base(default_constructor_tag) {}
+};
+
+}  // namespace expected_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
+/// `E`. The contained object may not be initialized after the expected object
+/// has been initialized, and may not be destroyed before the expected object
+/// has been destroyed. The initialization state of the contained object is
+/// tracked by the expected object.
+
+template <class T, class E>
+class ICEBERG_EXPORT [[nodiscard]] expected
+    : private expected_detail::move_assign_base<T, E>,
+      private expected_detail::default_ctor_base<T, E> {
+  static_assert(expected_detail::is_value_type_valid_v<T>);
+  static_assert(expected_detail::is_error_type_valid_v<E>);
+
+  constexpr T* valptr() noexcept { return std::addressof(this->m_val); }
+  constexpr const T* valptr() const noexcept { return std::addressof(this->m_val); }
+  constexpr E* errptr() noexcept { return std::addressof(this->m_unexpect); }
+  constexpr const E* errptr() const noexcept { return std::addressof(this->m_unexpect); }
+
+  constexpr T& val() noexcept { return this->m_val; }
+  constexpr E& err() noexcept { return this->m_unexpect; }
+
+  constexpr const T& val() const noexcept { return this->m_val; }
+  constexpr const E& err() const noexcept { return this->m_unexpect; }
+
+  using impl_base = expected_detail::move_assign_base<T, E>;
+  using ctor_base = expected_detail::default_ctor_base<T, E>;
+
+ public:
+  using value_type = T;
+  using error_type = E;
+  using unexpected_type = unexpected<E>;
+
+  // default constructors
+
+  constexpr expected() = default;
+  constexpr expected(const expected& rhs) = default;
+  constexpr expected(expected&& rhs) = default;
+
+  // constructors for expected<U, G>
+
+  // implicit const reference
+  template <class U, class G,
+            std::enable_if_t<std::is_convertible_v<const U&, T> &&
+                             std::is_convertible_v<const G&, E>>* = nullptr,
+            expected_detail::enable_from_other_expected_t<T, E, U, G, const U&,
+                                                          const G&>* = nullptr>
+  constexpr expected(const expected<U, G>& rhs)  //
+      noexcept(std::is_nothrow_constructible_v<T, const U&> &&
+               std::is_nothrow_constructible_v<E, const G&>)
+      : impl_base(expected_detail::no_init),
+        ctor_base(expected_detail::default_constructor_tag{}) {
+    if (rhs.has_value()) {
+      this->construct(*rhs);
+    } else {
+      this->construct_error(rhs.error());
+    }
+  }
+
+  // explicit const reference
+  template <class U, class G,
+            std::enable_if_t<!(std::is_convertible_v<const U&, T> &&
+                               std::is_convertible_v<const G&, E>)>* = nullptr,
+            expected_detail::enable_from_other_expected_t<T, E, U, G, const U&,
+                                                          const G&>* = nullptr>
+  constexpr explicit expected(const expected<U, G>& rhs)  //
+      noexcept(std::is_nothrow_constructible_v<T, const U&> &&
+               std::is_nothrow_constructible_v<E, const G&>)
+      : impl_base(expected_detail::no_init),
+        ctor_base(expected_detail::default_constructor_tag{}) {
+    if (rhs.has_value()) {
+      this->construct(*rhs);
+    } else {
+      this->construct_error(rhs.error());
+    }
+  }
+
+  // implicit rvalue
+  template <class U, class G,
+            std::enable_if_t<std::is_convertible_v<U, T> &&
+                             std::is_convertible_v<G, E>>* = nullptr,
+            expected_detail::enable_from_other_expected_t<T, E, U, G, U, G>* = nullptr>
+  constexpr expected(expected<U, G>&& rhs)  //
+      noexcept(std::is_nothrow_constructible_v<T, U> &&
+               std::is_nothrow_constructible_v<E, G>)
+      : impl_base(expected_detail::no_init),
+        ctor_base(expected_detail::default_constructor_tag{}) {
+    if (rhs.has_value()) {
+      this->construct(std::move(*rhs));
+    } else {
+      this->construct_error(std::move(rhs.error()));
+    }
+  }
+
+  // explicit rvalue
+  template <class U,  //
+            class G,  //
+            std::enable_if_t<!(std::is_convertible_v<U, T> &&
+                               std::is_convertible_v<G, E>)>* = nullptr,  //
+            expected_detail::enable_from_other_expected_t<T, E, U, G, U, G>* = nullptr>
+  constexpr explicit expected(expected<U, G>&& rhs)  //
+      noexcept(std::is_nothrow_constructible_v<T, U> &&
+               std::is_nothrow_constructible_v<E, G>)
+      : impl_base(expected_detail::no_init),
+        ctor_base(expected_detail::default_constructor_tag{}) {
+    if (rhs.has_value()) {
+      this->construct(std::move(*rhs));
+    } else {
+      this->construct_error(std::move(rhs.error()));
+    }
+  }
+
+  // template <class U = T>
+  //     expected(U &&)
+
+  // implicit
+  template <class U = T, std::enable_if_t<std::is_convertible_v<U, T>>* = nullptr,
+            expected_detail::enable_forward_t<T, E, U>* = nullptr>
+  constexpr expected(U&& v) noexcept(std::is_nothrow_constructible_v<T, U>)
+      : expected(std::in_place, std::forward<U>(v)) {}
+
+  // explicit
+  template <class U = T, std::enable_if_t<!std::is_convertible_v<U, T>>* = nullptr,
+            expected_detail::enable_forward_t<T, E, U>* = nullptr>
+  constexpr explicit expected(U&& v) noexcept(std::is_nothrow_constructible_v<T, U>)
+      : expected(std::in_place, std::forward<U>(v)) {}
+
+  // constructors for unexpected<G>
+
+  // explicit const unexpected<G> &
+  template <class G,                                                           //
+            std::enable_if_t<!std::is_convertible_v<const G&, E>>* = nullptr,  //
+            std::enable_if_t<std::is_constructible_v<E, const G&>>* = nullptr>
+  explicit constexpr expected(const unexpected<G>& e) noexcept(
+      std::is_nothrow_constructible_v<E, const G&>)
+      : impl_base(unexpect, e.error()),
+        ctor_base(expected_detail::default_constructor_tag{}) {}
+
+  // implicit const unexpected<G> &
+  template <class G,                                                          //
+            std::enable_if_t<std::is_convertible_v<const G&, E>>* = nullptr,  //
+            std::enable_if_t<std::is_constructible_v<E, const G&>>* = nullptr>
+  constexpr expected(unexpected<G> const& e) noexcept(
+      std::is_nothrow_constructible_v<E, const G&>)
+      : impl_base(unexpect, e.error()),
+        ctor_base(expected_detail::default_constructor_tag{}) {}
+
+  // explicit unexpected<G> &&
+  template <class G,                                                    //
+            std::enable_if_t<!std::is_convertible_v<G, E>>* = nullptr,  //
+            std::enable_if_t<std::is_constructible_v<E, G>>* = nullptr>
+  explicit constexpr expected(unexpected<G>&& e) noexcept(
+      std::is_nothrow_constructible_v<E, G>)
+      : impl_base(unexpect, std::move(e.error())),
+        ctor_base(expected_detail::default_constructor_tag{}) {}
+
+  // implicit unexpected<G> &&
+  template <class G,                                                   //
+            std::enable_if_t<std::is_convertible_v<G, E>>* = nullptr,  //
+            std::enable_if_t<std::is_constructible_v<E, G>>* = nullptr>
+  constexpr expected(unexpected<G>&& e) noexcept(std::is_nothrow_constructible_v<E, G>)
+      : impl_base(unexpect, std::move(e.error())),
+        ctor_base(expected_detail::default_constructor_tag{}) {}
+
+#if defined(__cpp_lib_expected) && __cpp_lib_expected >= 202202L
+  // Library code built as C++23 still spells some errors std::unexpected.
+  template <class G, std::enable_if_t<std::is_constructible_v<E, const G&>>* = nullptr>
+  constexpr explicit(!std::is_convertible_v<const G&, E>) expected(
+      const std::unexpected<G>& e) noexcept(std::is_nothrow_constructible_v<E, const G&>)
+      : expected(unexpect, e.error()) {}
+
+  template <class G, std::enable_if_t<std::is_constructible_v<E, G>>* = nullptr>
+  constexpr explicit(!std::is_convertible_v<G, E>)
+      expected(std::unexpected<G>&& e) noexcept(std::is_nothrow_constructible_v<E, G>)
+      : expected(unexpect, std::move(e.error())) {}
+#endif
+
+  // template<class... Args>
+  //     expected(std::in_place_t, Args &&...)
+
+  template <class... Args,
+            std::enable_if_t<std::is_constructible_v<T, Args...>>* = nullptr>
+  constexpr explicit expected(std::in_place_t, Args&&... args)  //
+      noexcept(std::is_nothrow_constructible_v<T, Args...>)
+      : impl_base(std::in_place, std::forward<Args>(args)...),
+        ctor_base(expected_detail::default_constructor_tag{}) {}
+
+  // template<class U, class... Args>
+  //     expected(std::in_place_t, std::initializer_list<U>, Args &&...)
+
+  template <class U, class... Args,
+            std::enable_if_t<std::is_constructible_v<T, std::initializer_list<U>&,
+                                                     Args...>>* = nullptr>
+  constexpr explicit expected(std::in_place_t, std::initializer_list<U> il,
+                              Args&&... args)  //
+      noexcept(std::is_nothrow_constructible_v<T, std::initializer_list<U>&, Args...>)
+      : impl_base(std::in_place, il, std::forward<Args>(args)...),
+        ctor_base(expected_detail::default_constructor_tag{}) {}
+
+  // helper ctor for transform()
+  template <class Fn, class... Args>
+  constexpr explicit expected(expected_detail::construct_with_invoke_result_t tag,
+                              Fn&& func, Args&&... args)  //
+      noexcept(noexcept(static_cast<T>(std::invoke(std::forward<Fn>(func),
+                                                   std::forward<Args>(args)...))))
+      : impl_base(tag, std::forward<Fn>(func), std::forward<Args>(args)...),
+        ctor_base(expected_detail::default_constructor_tag{}) {}
+
+  // template<class... Args>
+  //     expected(unexpect_t, Args &&...)
+
+  template <class... Args,
+            std::enable_if_t<std::is_constructible_v<E, Args...>>* = nullptr>
+  constexpr explicit expected(unexpect_t, Args&&... args)  //
+      noexcept(std::is_nothrow_constructible_v<E, Args...>)
+      : impl_base(unexpect, std::forward<Args>(args)...),
+        ctor_base(expected_detail::default_constructor_tag{}) {}
+
+  // template<class U, class... Args>
+  //     expected(unexpect_t, std::initializer_list<U>, Args &&...)
+
+  template <class U, class... Args,
+            std::enable_if_t<std::is_constructible_v<E, std::initializer_list<U>&,
+                                                     Args...>>* = nullptr>
+  constexpr explicit expected(
+      unexpect_t, std::initializer_list<U> il,
+      Args&&... args) noexcept(std::is_nothrow_constructible_v<E,
+                                                               std::initializer_list<U>&,
+                                                               Args...>)
+      : impl_base(unexpect, il, std::forward<Args>(args)...),
+        ctor_base(expected_detail::default_constructor_tag{}) {}
+
+  // helper ctor for transform_error()
+  template <class Fn, class... Args>
+  constexpr explicit expected(expected_detail::construct_with_invoke_result_t tag1,
+                              unexpect_t tag2, Fn&& func, Args&&... args)  //
+      noexcept(noexcept(static_cast<E>(std::invoke(std::forward<Fn>(func),
+                                                   std::forward<Args>(args)...))))
+      : impl_base(tag1, tag2, std::forward<Fn>(func), std::forward<Args>(args)...),
+        ctor_base(expected_detail::default_constructor_tag{}) {}
+
+  // default assignment operators
+
+  constexpr expected& operator=(const expected& rhs) = default;
+  constexpr expected& operator=(expected&& rhs) = default;
+
+  // assignments
+
+  template <
+      class U = T,                                                                      //
+      std::enable_if_t<                                                                 //
+          !std::is_same_v<expected, std::remove_cvref_t<U>> &&                          //
+          !expected_detail::is_specialization_v<std::remove_cvref_t<U>, unexpected> &&  //
+          std::is_constructible_v<T, U> &&                                              //
+          std::is_assignable_v<T&, U> &&                                                //
+          (std::is_nothrow_constructible_v<T, U> ||                                     //
+           std::is_nothrow_move_constructible_v<T> ||                                   //
+           std::is_nothrow_move_constructible_v<E>)                                     //
+          >* = nullptr>
+  constexpr expected& operator=(U&& v)  //
+      noexcept(std::is_nothrow_constructible_v<T, U> &&
+               std::is_nothrow_assignable_v<T&, U>) {
+    if (has_value()) {
+      val() = std::forward<U>(v);
+    } else {
+      expected_detail::reinit_expected(val(), err(), std::forward<U>(v));
+      this->m_has_val = true;
+    }
+
+    return *this;
+  }
+
+  template <class G,                                         //
+            class GF = const G&,                             //
+            std::enable_if_t<                                //
+                std::is_constructible_v<E, GF> &&            //
+                std::is_assignable_v<E&, GF> &&              //
+                (std::is_nothrow_constructible_v<E, GF> ||   //
+                 std::is_nothrow_move_constructible_v<T> ||  //
+                 std::is_nothrow_move_constructible_v<E>)    //
+                >* = nullptr>
+  constexpr expected& operator=(const unexpected<G>& rhs) noexcept(
+      std::is_nothrow_constructible_v<E, GF> && std::is_nothrow_assignable_v<E&, GF>) {
+    if (!has_value()) {
+      err() = std::forward<GF>(rhs.error());
+    } else {
+      expected_detail::reinit_expected(err(), val(), std::forward<GF>(rhs.error()));
+      this->m_has_val = false;
+    }
+
+    return *this;
+  }
+
+  template <class G,                                         //
+            class GF = G,                                    //
+            std::enable_if_t<                                //
+                std::is_constructible_v<E, GF> &&            //
+                std::is_assignable_v<E&, GF> &&              //
+                (std::is_nothrow_constructible_v<E, GF> ||   //
+                 std::is_nothrow_move_constructible_v<T> ||  //
+                 std::is_nothrow_move_constructible_v<E>)    //
+                >* = nullptr>
+  constexpr expected& operator=(unexpected<G>&& rhs) noexcept(
+      std::is_nothrow_constructible_v<E, GF> && std::is_nothrow_assignable_v<E&, GF>) {
+    if (!has_value()) {
+      err() = std::forward<GF>(rhs.error());
+    } else {
+      expected_detail::reinit_expected(err(), val(), std::forward<GF>(rhs.error()));
+      this->m_has_val = false;
+    }
+
+    return *this;
+  }
+
+  template <class... Args,
+            typename std::enable_if_t<std::is_nothrow_constructible_v<T, Args&&...>,
+                                      bool> = false>
+  constexpr T& emplace(Args&&... args) {
+    if (has_value()) {
+      if constexpr (!std::is_trivially_destructible_v<T>) {
+        val().~T();
+      }
+    } else {
+      if constexpr (!std::is_trivially_destructible_v<E>) {
+        err().~E();
+      }
+      this->m_has_val = true;
+    }
+
+    return *std::construct_at(valptr(), std::forward<Args>(args)...);
+  }
+
+  template <class U, class... Args,
+            std::enable_if_t<std::is_nothrow_constructible_v<T, std::initializer_list<U>&,
+                                                             Args&&...>>* = nullptr>
+  constexpr T& emplace(std::initializer_list<U> il, Args&&... args) {
+    if (has_value()) {
+      if constexpr (!std::is_trivially_destructible_v<T>) {
+        val().~T();
+      }
+    } else {
+      if constexpr (!std::is_trivially_destructible_v<E>) {
+        err().~E();
+      }
+      this->m_has_val = true;
+    }
+
+    return *std::construct_at(valptr(), il, std::forward<Args>(args)...);
+  }
+
+  template <class OT = T, class OE = E>
+  constexpr std::enable_if_t<std::is_swappable_v<OT> && std::is_swappable_v<OE> &&
+                             std::is_move_constructible_v<OT> &&
+                             std::is_move_constructible_v<OE> &&
+                             (std::is_nothrow_move_constructible_v<OT> ||
+                              std::is_nothrow_move_constructible_v<OE>)>
+  swap(expected& rhs) noexcept(std::is_nothrow_move_constructible_v<T> &&
+                               std::is_nothrow_swappable_v<T> &&
+                               std::is_nothrow_move_constructible_v<E> &&
+                               std::is_nothrow_swappable_v<E>) {
+    using std::swap;
+    if (this->m_has_val && rhs.m_has_val) {
+      swap(this->m_val, rhs.m_val);  // ADL
+    } else if (this->m_has_val) {
+      if constexpr (std::is_nothrow_move_constructible_v<E>) {
+        E tmp(std::move(rhs.error()));
+        if constexpr (!std::is_trivially_destructible_v<E>) {
+          rhs.error().~E();
+        }
+
+        if constexpr (std::is_nothrow_move_constructible_v<T>) {
+          std::construct_at(std::addressof(rhs.m_val), std::move(this->m_val));
+        } else {
+          expected_detail::ReinitGuard<E> guard{std::addressof(rhs.error()),
+                                                std::addressof(tmp)};
+          std::construct_at(std::addressof(rhs.m_val), std::move(this->m_val));
+          guard._target = nullptr;
+        }
+
+        if constexpr (!std::is_trivially_destructible_v<T>) {
+          this->m_val.~T();
+        }
+        std::construct_at(std::addressof(this->error()), std::move(tmp));
+      } else {
+        T tmp(std::move(this->m_val));
+        if constexpr (!std::is_trivially_destructible_v<T>) {
+          this->m_val.~T();
+        }
+
+        expected_detail::ReinitGuard<T> guard{std::addressof(this->m_val),
+                                              std::addressof(tmp)};
+        std::construct_at(std::addressof(this->error()), std::move(rhs.error()));
+        guard._target = nullptr;
+
+        if constexpr (!std::is_trivially_destructible_v<E>) {
+          rhs.error().~E();
+        }
+        std::construct_at(std::addressof(rhs.m_val), std::move(tmp));
+      }
+
+      this->m_has_val = false;
+      rhs.m_has_val = true;
+    } else if (rhs.m_has_val) {
+      rhs.swap(*this);
+    } else {
+      swap(this->error(), rhs.error());  // ADL
+    }
+  }
+
+  constexpr const T* operator->() const noexcept { return valptr(); }
+  constexpr T* operator->() noexcept { return valptr(); }
+
+  constexpr const T& operator*() const& noexcept { return val(); }
+  constexpr T& operator*() & noexcept { return val(); }
+  constexpr const T&& operator*() const&& noexcept { return std::move(val()); }
+  constexpr T&& operator*() && noexcept { return std::move(val()); }
+
+  constexpr bool has_value() const noexcept { return this->m_has_val; }
+  constexpr explicit operator bool() const noexcept { return this->m_has_val; }
+
+  constexpr const T& value() const& {
+    static_assert(std::is_copy_constructible_v<E>,
+                  "E must be copy constructible, by LWG-3843");
+    if (!has_value()) throw bad_expected_access(error());
+    return val();
+  }
+  constexpr T& value() & {
+    static_assert(std::is_copy_constructible_v<E>,
+                  "E must be copy constructible, by LWG-3843");
+    if (!has_value()) throw bad_expected_access(std::as_const(error()));
+    return val();
+  }
+  constexpr const T&& value() const&& {
+    static_assert(std::is_copy_constructible_v<E>,
+                  "E must be copy constructible, by LWG-3843");
+    static_assert(std::is_constructible_v<E, decltype(std::move(error()))>,
+                  "E must be constructible from const E&&, by LWG-3843");
+    if (!has_value()) throw bad_expected_access(std::move(error()));
+    return std::move(val());
+  }
+  constexpr T&& value() && {
+    static_assert(std::is_copy_constructible_v<E>,
+                  "E must be copy constructible, by LWG-3843");
+    static_assert(std::is_constructible_v<E, decltype(std::move(error()))>,
+                  "E must be constructible from E&&, by LWG-3843");
+    if (!has_value()) throw bad_expected_access(std::move(error()));
+    return std::move(val());
+  }
+
+  constexpr const E& error() const& noexcept { return err(); }
+  constexpr E& error() & noexcept { return err(); }
+  constexpr const E&& error() const&& noexcept { return std::move(err()); }
+  constexpr E&& error() && noexcept { return std::move(err()); }
+
+  template <class U>
+  constexpr T value_or(U&& v) const& noexcept(
+      std::is_nothrow_copy_constructible_v<T> &&
+      expected_detail::is_nothrow_convertible_v<U, T>) {
+    static_assert(std::is_copy_constructible_v<T>, "T must be copy-constructible");
+    static_assert(std::is_convertible_v<U, T>, "is_convertible_v<U, T> must be true");
+    if (this->m_has_val) {
+      return this->m_val;
+    } else {
+      return static_cast<T>(std::forward<U>(v));
+    }
+  }
+
+  template <class U>
+  constexpr T value_or(U&& v) && noexcept(
+      std::is_nothrow_move_constructible_v<T> &&
+      expected_detail::is_nothrow_convertible_v<U, T>) {
+    static_assert(std::is_move_constructible_v<T>, "T must be move-constructible");
+    static_assert(std::is_convertible_v<U, T>, "is_convertible_v<U, T> must be true");
+    if (this->m_has_val) {
+      return std::move(this->m_val);
+    } else {
+      return static_cast<T>(std::forward<U>(v));
+    }
+  }
+
+  template <class G = E>
+  constexpr E error_or(G&& v) const&  //
+      noexcept(std::is_nothrow_copy_constructible_v<E> &&
+               expected_detail::is_nothrow_convertible_v<G, E>) {
+    static_assert(std::is_copy_constructible_v<E>, "E must be copy-constructible");
+    static_assert(std::is_convertible_v<G, E>, "is_convertible_v<G, E> must be true");
+    if (this->m_has_val) {
+      return static_cast<E>(std::forward<G>(v));
+    } else {
+      return this->m_unexpect;
+    }
+  }
+  template <class G = E>
+  constexpr E error_or(G&& v) &&  //
+      noexcept(std::is_nothrow_move_constructible_v<E> &&
+               expected_detail::is_nothrow_convertible_v<G, E>) {
+    static_assert(std::is_move_constructible_v<E>, "E must be move-constructible");
+    static_assert(std::is_convertible_v<G, E>, "is_convertible_v<G, E> must be true");
+    if (this->m_has_val) {
+      return static_cast<E>(std::forward<G>(v));
+    } else {
+      return std::move(this->m_unexpect);
+    }
+  }
+
+  template <class F, class GE = E,
+            std::enable_if_t<std::is_constructible_v<GE, GE&>>* = nullptr>
+  constexpr auto and_then(F&& f) & {
+    using U = std::remove_cvref_t<std::invoke_result_t<F, decltype((this->m_val))>>;
+    static_assert(expected_detail::is_specialization_v<U, expected>,
+                  "U (return type of F) must be specialization of expected");
+    static_assert(std::is_same_v<typename U::error_type, E>,
+                  "The error type must be the same after calling the F");
+
+    if (has_value()) {
+      return std::invoke(std::forward<F>(f), this->m_val);
+
+    } else {
+      return U(unexpect, error());
+    }
+  }
+  template <class F, class GE = E,
+            std::enable_if_t<std::is_constructible_v<GE, const GE&>>* = nullptr>
+  constexpr auto and_then(F&& f) const& {
+    using U = std::remove_cvref_t<std::invoke_result_t<F, decltype((this->m_val))>>;
+    static_assert(expected_detail::is_specialization_v<U, expected>,
+                  "U (return type of F) must be specialization of expected");
+    static_assert(std::is_same_v<typename U::error_type, E>,
+                  "The error type must be the same after calling the F");
+
+    if (has_value()) {
+      return std::invoke(std::forward<F>(f), this->m_val);
+    } else {
+      return U(unexpect, error());
+    }
+  }
+
+  template <class F, class GE = E,
+            std::enable_if_t<std::is_constructible_v<GE, GE&&>>* = nullptr>
+  constexpr auto and_then(F&& f) && {
+    using U =
+        std::remove_cvref_t<std::invoke_result_t<F, decltype(std::move(this->m_val))>>;
+    static_assert(expected_detail::is_specialization_v<U, expected>,
+                  "U (return type of F) must be specialization of expected");
+    static_assert(std::is_same_v<typename U::error_type, E>,
+                  "The error type must be the same after calling the F");
+
+    if (has_value()) {
+      return std::invoke(std::forward<F>(f), std::move(this->m_val));
+    } else {
+      return U(unexpect, std::move(error()));
+    }
+  }
+  template <class F, class GE = E,
+            std::enable_if_t<std::is_constructible_v<GE, const GE>>* = nullptr>
+  constexpr auto and_then(F&& f) const&& {
+    using U =
+        std::remove_cvref_t<std::invoke_result_t<F, decltype(std::move(this->m_val))>>;
+    static_assert(expected_detail::is_specialization_v<U, expected>,
+                  "U (return type of F) must be specialization of expected");
+    static_assert(std::is_same_v<typename U::error_type, E>,
+                  "The error type must be the same after calling the F");
+
+    if (has_value()) {
+      return std::invoke(std::forward<F>(f), std::move(this->m_val));
+    } else {
+      return U(unexpect, std::move(error()));
+    }
+  }
+
+  template <class F, class UT = T,
+            std::enable_if_t<std::is_constructible_v<UT, UT&>>* = nullptr>
+  constexpr auto or_else(F&& f) & {
+    using G = std::remove_cvref_t<std::invoke_result_t<F, decltype(error())>>;
+    static_assert(expected_detail::is_specialization_v<G, expected>,
+                  "G (return type of F) must be specialization of expected");
+    static_assert(std::is_same_v<typename G::value_type, T>,
+                  "The value type must be the same after calling the F");
+
+    if (has_value()) {
+      return G(std::in_place, this->m_val);
+    } else {
+      return std::invoke(std::forward<F>(f), error());
+    }
+  }
+  template <class F, class UT = T,
+            std::enable_if_t<std::is_constructible_v<UT, const UT&>>* = nullptr>
+  constexpr auto or_else(F&& f) const& {
+    using G = std::remove_cvref_t<std::invoke_result_t<F, decltype(error())>>;
+    static_assert(expected_detail::is_specialization_v<G, expected>,
+                  "G (return type of F) must be specialization of expected");
+    static_assert(std::is_same_v<typename G::value_type, T>,
+                  "The value type must be the same after calling the F");
+
+    if (has_value()) {
+      return G(std::in_place, this->m_val);
+    } else {
+      return std::invoke(std::forward<F>(f), error());
+    }
+  }
+  template <class F, class UT = T,
+            std::enable_if_t<std::is_constructible_v<UT, UT&&>>* = nullptr>
+  constexpr auto or_else(F&& f) && {
+    using G = std::remove_cvref_t<std::invoke_result_t<F, decltype(std::move(error()))>>;
+    static_assert(expected_detail::is_specialization_v<G, expected>,
+                  "G (return type of F) must be specialization of expected");
+    static_assert(std::is_same_v<typename G::value_type, T>,
+                  "The value type must be the same after calling the F");
+
+    if (has_value()) {
+      return G(std::in_place, std::move(this->m_val));
+    } else {
+      return std::invoke(std::forward<F>(f), std::move(error()));
+    }
+  }
+  template <class F, class UT = T,
+            std::enable_if_t<std::is_constructible_v<UT, const UT>>* = nullptr>
+  constexpr auto or_else(F&& f) const&& {
+    using G = std::remove_cvref_t<std::invoke_result_t<F, decltype(std::move(error()))>>;
+    static_assert(expected_detail::is_specialization_v<G, expected>,
+                  "G (return type of F) must be specialization of expected");
+    static_assert(std::is_same_v<typename G::value_type, T>,
+                  "The value type must be the same after calling the F");
+
+    if (has_value()) {
+      return G(std::in_place, std::move(this->m_val));
+    } else {
+      return std::invoke(std::forward<F>(f), std::move(error()));
+    }
+  }
+
+  template <class F, class GE = E,
+            std::enable_if_t<std::is_constructible_v<GE, GE&>>* = nullptr>
+  constexpr auto transform(F&& f) & {
+    using U = std::remove_cvref_t<std::invoke_result_t<F, decltype((this->m_val))>>;
+    static_assert(expected_detail::is_value_type_valid_v<U>,
+                  "U must be a valid type for expected<U, E>");
+    // FIXME another constraint needed here
+    if (!has_value()) {
+      return expected<U, E>(unexpect, error());
+    } else {
+      if constexpr (std::is_void_v<U>) {
+        std::invoke(std::forward<F>(f), this->m_val);
+        return expected<U, E>{};
+      } else {
+        return expected<U, E>(expected_detail::construct_with_invoke_result_t{},
+                              std::forward<F>(f), this->m_val);
+      }
+    }
+  }
+  template <class F, class GE = E,
+            std::enable_if_t<std::is_constructible_v<GE, const GE&>>* = nullptr>
+  constexpr auto transform(F&& f) const& {
+    using U = std::remove_cvref_t<std::invoke_result_t<F, decltype((this->m_val))>>;
+    static_assert(expected_detail::is_value_type_valid_v<U>,
+                  "U must be a valid type for expected<U, E>");
+    // FIXME another constraint needed here
+    if (!has_value()) {
+      return expected<U, E>(unexpect, error());
+    } else {
+      if constexpr (std::is_void_v<U>) {
+        std::invoke(std::forward<F>(f), this->m_val);
+        return expected<U, E>{};
+      } else {
+        return expected<U, E>(expected_detail::construct_with_invoke_result_t{},
+                              std::forward<F>(f), this->m_val);
+      }
+    }
+  }
+  template <class F, class GE = E,
+            std::enable_if_t<std::is_constructible_v<GE, GE&&>>* = nullptr>
+  constexpr auto transform(F&& f) && {
+    using U =
+        std::remove_cvref_t<std::invoke_result_t<F, decltype(std::move(this->m_val))>>;
+    static_assert(expected_detail::is_value_type_valid_v<U>,
+                  "U must be a valid type for expected<U, E>");
+    // FIXME another constraint needed here
+    if (!has_value()) {
+      return expected<U, E>(unexpect, std::move(error()));
+    } else {
+      if constexpr (std::is_void_v<U>) {
+        std::invoke(std::forward<F>(f), std::move(this->m_val));
+        return expected<U, E>{};
+      } else {
+        return expected<U, E>(expected_detail::construct_with_invoke_result_t{},
+                              std::forward<F>(f), std::move(this->m_val));
+      }
+    }
+  }
+  template <class F, class GE = E,
+            std::enable_if_t<std::is_constructible_v<GE, const GE>>* = nullptr>
+  constexpr auto transform(F&& f) const&& {
+    using U =
+        std::remove_cvref_t<std::invoke_result_t<F, decltype(std::move(this->m_val))>>;
+    static_assert(expected_detail::is_value_type_valid_v<U>,
+                  "U must be a valid type for expected<U, E>");
+    // FIXME another constraint needed here
+    if (!has_value()) {
+      return expected<U, E>(unexpect, std::move(error()));
+    } else {
+      if constexpr (std::is_void_v<U>) {
+        std::invoke(std::forward<F>(f), std::move(this->m_val));
+        return expected<U, E>{};
+      } else {
+        return expected<U, E>(expected_detail::construct_with_invoke_result_t{},
+                              std::forward<F>(f), std::move(this->m_val));
+      }
+    }
+  }
+
+  template <class F, class UT = T,
+            std::enable_if_t<std::is_constructible_v<UT, UT&>>* = nullptr>
+  constexpr auto transform_error(F&& f) & {
+    using G = std::remove_cvref_t<std::invoke_result_t<F, decltype(error())>>;
+    static_assert(expected_detail::is_error_type_valid_v<G>,
+                  "G must be a valid type for expected<T, G>");
+    // FIXME another constraint needed here
+    if (has_value()) {
+      return expected<T, G>(std::in_place, this->m_val);
+    } else {
+      return expected<T, G>(expected_detail::construct_with_invoke_result_t{}, unexpect,
+                            std::forward<F>(f), error());
+    }
+  }
+  template <class F, class UT = T,
+            std::enable_if_t<std::is_constructible_v<UT, const UT&>>* = nullptr>
+  constexpr auto transform_error(F&& f) const& {
+    using G = std::remove_cvref_t<std::invoke_result_t<F, decltype(error())>>;
+    static_assert(expected_detail::is_error_type_valid_v<G>,
+                  "G must be a valid type for expected<T, G>");
+    // FIXME another constraint needed here
+    if (has_value()) {
+      return expected<T, G>(std::in_place, this->m_val);
+    } else {
+      return expected<T, G>(expected_detail::construct_with_invoke_result_t{}, unexpect,
+                            std::forward<F>(f), error());
+    }
+  }
+  template <class F, class UT = T,
+            std::enable_if_t<std::is_constructible_v<UT, UT&&>>* = nullptr>
+  constexpr auto transform_error(F&& f) && {
+    using G = std::remove_cvref_t<std::invoke_result_t<F, decltype(std::move(error()))>>;
+    static_assert(expected_detail::is_error_type_valid_v<G>,
+                  "G must be a valid type for expected<T, G>");
+    // FIXME another constraint needed here
+    if (has_value()) {
+      return expected<T, G>(std::in_place, std::move(this->m_val));
+    } else {
+      return expected<T, G>(expected_detail::construct_with_invoke_result_t{}, unexpect,
+                            std::forward<F>(f), std::move(error()));
+    }
+  }
+  template <class F, class UT = T,
+            std::enable_if_t<std::is_constructible_v<UT, const UT>>* = nullptr>
+  constexpr auto transform_error(F&& f) const&& {
+    using G = std::remove_cvref_t<std::invoke_result_t<F, decltype(std::move(error()))>>;
+    static_assert(expected_detail::is_error_type_valid_v<G>,
+                  "G must be a valid type for expected<T, G>");
+    // FIXME another constraint needed here
+    if (has_value()) {
+      return expected<T, G>(std::in_place, std::move(this->m_val));
+    } else {
+      return expected<T, G>(expected_detail::construct_with_invoke_result_t{}, unexpect,
+                            std::forward<F>(f), std::move(error()));
+    }
+  }
+
+  template <class T2, class E2>
+  [[nodiscard]] friend constexpr std::enable_if_t<!std::is_void_v<T2>, bool> operator==(
+      const expected& x,
+      const expected<T2, E2>& y) noexcept(noexcept(*x == *y) &&
+                                          noexcept(x.error() == y.error())) {
+    if (x.has_value() != y.has_value()) {
+      return false;
+    } else if (x.has_value()) {
+      return *x == *y;
+    } else {
+      return x.error() == y.error();
+    }
+  }
+
+  template <class T2>
+  [[nodiscard]] friend constexpr bool operator==(const expected& x, const T2& v)  //
+      noexcept(noexcept(*x == v)) {
+    if (x.has_value()) {
+      return static_cast<bool>(*x == v);
+    } else {
+      return false;
+    }
+  }
+
+  template <class E2>
+  [[nodiscard]] friend constexpr bool operator==(
+      const expected& x,
+      const unexpected<E2>& e) noexcept(noexcept(x.error() == e.error())) {
+    if (x.has_value()) {
+      return false;
+    } else {
+      return static_cast<bool>(x.error() == e.error());
+    }
+  }
+};
+
+// standalone swap for non-void value type
+template <
+    class T, class E,
+    std::enable_if_t<!std::is_void_v<T> &&                                         //
+                     std::is_move_constructible_v<T> && std::is_swappable_v<T> &&  //
+                     std::is_move_constructible_v<E> && std::is_swappable_v<E> &&  //
+                     (std::is_nothrow_move_constructible_v<T> ||
+                      std::is_nothrow_move_constructible_v<E>)>* = nullptr>
+constexpr void swap(expected<T, E>& lhs,
+                    expected<T, E>& rhs) noexcept(noexcept(lhs.swap(rhs))) {
+  lhs.swap(rhs);
+}
+
+template <class E>
+class ICEBERG_EXPORT [[nodiscard]]
+expected<void, E> : private expected_detail::move_assign_base<void, E>,
+                    private expected_detail::default_ctor_base<void, E> {
+  static_assert(expected_detail::is_error_type_valid_v<E>);
+
+  using T = void;
+
+  constexpr E* errptr() noexcept { return std::addressof(this->m_unexpect); }
+  constexpr const E* errptr() const noexcept { return std::addressof(this->m_unexpect); }
+
+  constexpr void val() noexcept {}
+  constexpr E& err() noexcept { return this->m_unexpect; }
+  constexpr void val() const noexcept {}
+  constexpr const E& err() const noexcept { return this->m_unexpect; }
+
+  using impl_base = expected_detail::move_assign_base<T, E>;
+  using ctor_base = expected_detail::default_ctor_base<T, E>;
+
+ public:
+  using value_type = T;
+  using error_type = E;
+  using unexpected_type = unexpected<E>;
+
+  constexpr expected() = default;
+  constexpr expected(const expected& rhs) = default;
+  constexpr expected(expected&& rhs) = default;
+
+  template <
+      class U,                                                          //
+      class G,                                                          //
+      std::enable_if_t<std::is_convertible_v<const G&, E>>* = nullptr,  //
+      expected_detail::enable_from_other_void_expected_t<E, U, G, const G&>* = nullptr>
+  constexpr expected(const expected<U, G>& rhs) noexcept(
+      std::is_nothrow_constructible_v<E, const G&>)
+      : impl_base(expected_detail::no_init),
+        ctor_base(expected_detail::default_constructor_tag{}) {
+    if (rhs.has_value()) {
+      this->construct();
+    } else {
+      this->construct_error(rhs.error());
+    }
+  }
+
+  template <
+      class U,                                                           //
+      class G,                                                           //
+      std::enable_if_t<!std::is_convertible_v<const G&, E>>* = nullptr,  //
+      expected_detail::enable_from_other_void_expected_t<E, U, G, const G&>* = nullptr>
+  constexpr explicit expected(const expected<U, G>& rhs) noexcept(
+      std::is_nothrow_constructible_v<E, const G&>)
+      : impl_base(expected_detail::no_init),
+        ctor_base(expected_detail::default_constructor_tag{}) {
+    if (rhs.has_value()) {
+      this->construct();
+    } else {
+      this->construct_error(rhs.error());
+    }
+  }
+
+  template <class U,                                                   //
+            class G,                                                   //
+            std::enable_if_t<std::is_convertible_v<G, E>>* = nullptr,  //
+            expected_detail::enable_from_other_void_expected_t<E, U, G, G>* = nullptr>
+  constexpr expected(expected<U, G>&& rhs) noexcept(std::is_nothrow_constructible_v<E, G>)
+      : impl_base(expected_detail::no_init),
+        ctor_base(expected_detail::default_constructor_tag{}) {
+    if (rhs.has_value()) {
+      this->construct();
+    } else {
+      this->construct_error(std::move(rhs.error()));
+    }
+  }
+
+  template <class U,                                                    //
+            class G,                                                    //
+            std::enable_if_t<!std::is_convertible_v<G, E>>* = nullptr,  //
+            expected_detail::enable_from_other_void_expected_t<E, U, G, G>* = nullptr>
+  constexpr explicit expected(expected<U, G>&& rhs) noexcept(
+      std::is_nothrow_constructible_v<E, G>)
+      : impl_base(expected_detail::no_init),
+        ctor_base(expected_detail::default_constructor_tag{}) {
+    if (rhs.has_value()) {
+      this->construct();
+    } else {
+      this->construct_error(std::move(rhs.error()));
+    }
+  }
+
+  // constructors for unexpected<G>
+
+  // explicit const unexpected<G> &
+  template <class G,                                                           //
+            std::enable_if_t<!std::is_convertible_v<const G&, E>>* = nullptr,  //
+            std::enable_if_t<std::is_constructible_v<E, const G&>>* = nullptr>
+  explicit constexpr expected(const unexpected<G>& e) noexcept(
+      std::is_nothrow_constructible_v<E, const G&>)
+      : impl_base(unexpect, e.error()),
+        ctor_base(expected_detail::default_constructor_tag{}) {}
+
+  // implicit const unexpected<G> &
+  template <class G,                                                          //
+            std::enable_if_t<std::is_convertible_v<const G&, E>>* = nullptr,  //
+            std::enable_if_t<std::is_constructible_v<E, const G&>>* = nullptr>
+  constexpr expected(unexpected<G> const& e) noexcept(
+      std::is_nothrow_constructible_v<E, const G&>)
+      : impl_base(unexpect, e.error()),
+        ctor_base(expected_detail::default_constructor_tag{}) {}
+
+  // explicit unexpected<G> &&
+  template <class G,                                                    //
+            std::enable_if_t<!std::is_convertible_v<G, E>>* = nullptr,  //
+            std::enable_if_t<std::is_constructible_v<E, G>>* = nullptr>
+  explicit constexpr expected(unexpected<G>&& e) noexcept(
+      std::is_nothrow_constructible_v<E, G>)
+      : impl_base(unexpect, std::move(e.error())),
+        ctor_base(expected_detail::default_constructor_tag{}) {}
+
+  // implicit unexpected<G> &&
+  template <class G,                                                   //
+            std::enable_if_t<std::is_convertible_v<G, E>>* = nullptr,  //
+            std::enable_if_t<std::is_constructible_v<E, G>>* = nullptr>
+  constexpr expected(unexpected<G>&& e) noexcept(std::is_nothrow_constructible_v<E, G>)
+      : impl_base(unexpect, std::move(e.error())),
+        ctor_base(expected_detail::default_constructor_tag{}) {}
+
+#if defined(__cpp_lib_expected) && __cpp_lib_expected >= 202202L
+  // Library code built as C++23 still spells some errors std::unexpected.
+  template <class G, std::enable_if_t<std::is_constructible_v<E, const G&>>* = nullptr>
+  constexpr explicit(!std::is_convertible_v<const G&, E>) expected(
+      const std::unexpected<G>& e) noexcept(std::is_nothrow_constructible_v<E, const G&>)
+      : expected(unexpect, e.error()) {}
+
+  template <class G, std::enable_if_t<std::is_constructible_v<E, G>>* = nullptr>
+  constexpr explicit(!std::is_convertible_v<G, E>)
+      expected(std::unexpected<G>&& e) noexcept(std::is_nothrow_constructible_v<E, G>)
+      : expected(unexpect, std::move(e.error())) {}
+#endif
+
+  // expected(std::in_place_t)
+  constexpr explicit expected(std::in_place_t) noexcept
+      : impl_base(std::in_place), ctor_base(expected_detail::default_constructor_tag{}) {}
+
+  // template<class... Args>
+  //     expected(unexpect_t, Args &&...)
+  template <class... Args,
+            std::enable_if_t<std::is_constructible_v<E, Args...>>* = nullptr>
+  constexpr explicit expected(unexpect_t, Args&&... args)  //
+      noexcept(std::is_nothrow_constructible_v<E, Args...>)
+      : impl_base(unexpect, std::forward<Args>(args)...),
+        ctor_base(expected_detail::default_constructor_tag{}) {}
+
+  // template<class U, class... Args>
+  //     expected(unexpect_t, std::initializer_list<U>, Args &&...)
+  template <class U, class... Args,
+            std::enable_if_t<std::is_constructible_v<E, std::initializer_list<U>&,
+                                                     Args...>>* = nullptr>
+  constexpr explicit expected(unexpect_t, std::initializer_list<U> il, Args&&... args)  //
+      noexcept(std::is_nothrow_constructible_v<E, std::initializer_list<U>&, Args...>)
+      : impl_base(unexpect, il, std::forward<Args>(args)...),
+        ctor_base(expected_detail::default_constructor_tag{}) {}
+
+  // helper ctor for transform_error()
+  template <class Fn, class... Args>
+  constexpr explicit expected(expected_detail::construct_with_invoke_result_t tag1,
+                              unexpect_t tag2, Fn&& func, Args&&... args)  //
+      noexcept(noexcept(static_cast<E>(std::invoke(std::forward<Fn>(func),
+                                                   std::forward<Args>(args)...))))
+      : impl_base(tag1, tag2, std::forward<Fn>(func), std::forward<Args>(args)...),
+        ctor_base(expected_detail::default_constructor_tag{}) {}
+
+  expected& operator=(const expected& rhs) = default;
+  expected& operator=(expected&& rhs) = default;
+
+  template <class G,                               //
+            class GF = const G&,                   //
+            std::enable_if_t<                      //
+                std::is_constructible_v<E, GF> &&  //
+                std::is_assignable_v<E&, GF>       //
+                >* = nullptr>
+  constexpr expected& operator=(const unexpected<G>& rhs)  //
+      noexcept(std::is_nothrow_constructible_v<E, GF> &&
+               std::is_nothrow_assignable_v<E&, GF>) {
+    if (has_value()) {
+      std::construct_at(errptr(), std::forward<GF>(rhs.error()));
+      this->m_has_val = false;
+    } else {
+      error() = std::forward<GF>(rhs.error());
+    }
+
+    return *this;
+  }
+
+  template <class G,                               //
+            class GF = G,                          //
+            std::enable_if_t<                      //
+                std::is_constructible_v<E, GF> &&  //
+                std::is_assignable_v<E&, GF>       //
+                >* = nullptr>
+  constexpr expected& operator=(unexpected<G>&& rhs) noexcept(
+      std::is_nothrow_constructible_v<E, GF> && std::is_nothrow_assignable_v<E&, GF>) {
+    if (has_value()) {
+      std::construct_at(errptr(), std::forward<GF>(rhs.error()));
+      this->m_has_val = false;
+    } else {
+      error() = std::forward<GF>(rhs.error());
+    }
+
+    return *this;
+  }
+
+  constexpr void emplace() {
+    if (!has_value()) {
+      if constexpr (!std::is_trivially_destructible_v<E>) {
+        err().~E();
+      }
+      this->m_has_val = true;
+    }
+  }
+
+  template <class OE = E>
+  constexpr std::enable_if_t<std::is_swappable_v<OE> && std::is_move_constructible_v<OE>>
+  swap(expected& rhs) noexcept(std::is_nothrow_move_constructible_v<E> &&
+                               std::is_nothrow_swappable_v<E>) {
+    using std::swap;
+    if (this->m_has_val && rhs.m_has_val) {
+      // do nothing
+    } else if (this->m_has_val) {
+      std::construct_at(std::addressof(error()), std::move(rhs.error()));
+      if constexpr (!std::is_trivially_destructible_v<E>) {
+        rhs.error().~E();
+      }
+      this->m_has_val = false;
+      rhs.m_has_val = true;
+    } else if (rhs.m_has_val) {
+      std::construct_at(std::addressof(rhs.error()), std::move(error()));
+      if constexpr (!std::is_trivially_destructible_v<E>) {
+        error().~E();
+      }
+      this->m_has_val = true;
+      rhs.m_has_val = false;
+    } else {
+      swap(error(), rhs.error());  // ADL
+    }
+  }
+
+  constexpr void operator*() const noexcept { return val(); }
+
+  constexpr bool has_value() const noexcept { return this->m_has_val; }
+  constexpr explicit operator bool() const noexcept { return this->m_has_val; }
+
+  constexpr void value() const& {
+    static_assert(std::is_copy_constructible_v<E>,
+                  "E must be copy constructible, by LWG-3940");
+    if (!has_value()) throw bad_expected_access(err());
+  }
+
+  constexpr void value() && {
+    static_assert(std::is_copy_constructible_v<E>,
+                  "E must be copy constructible, by LWG-3940");
+    static_assert(std::is_move_constructible_v<E>,
+                  "E must be move constructible, by LWG-3940");
+    if (!has_value()) throw bad_expected_access(std::move(err()));
+  }
+
+  constexpr const E& error() const& noexcept { return err(); }
+  constexpr E& error() & noexcept { return err(); }
+  constexpr const E&& error() const&& noexcept { return std::move(err()); }
+  constexpr E&& error() && noexcept { return std::move(err()); }
+
+  template <class G = E>
+  constexpr E error_or(G&& v) const& noexcept(
+      std::is_nothrow_copy_constructible_v<E> &&
+      expected_detail::is_nothrow_convertible_v<G, E>) {
+    static_assert(std::is_copy_constructible_v<E>, "E must be copy-constructible");
+    static_assert(std::is_convertible_v<G, E>, "is_convertible_v<G, E> must be true");
+    if (this->m_has_val) {
+      return static_cast<E>(std::forward<G>(v));
+    } else {
+      return this->m_unexpect;
+    }
+  }
+  template <class G = E>
+  constexpr E error_or(G&& v) && noexcept(
+      std::is_nothrow_move_constructible_v<E> &&
+      expected_detail::is_nothrow_convertible_v<G, E>) {
+    static_assert(std::is_move_constructible_v<E>, "E must be move-constructible");
+    static_assert(std::is_convertible_v<G, E>, "is_convertible_v<G, E> must be true");
+    if (this->m_has_val) {
+      return static_cast<E>(std::forward<G>(v));
+    } else {
+      return std::move(this->m_unexpect);
+    }
+  }
+
+  template <class F, class GE = E,
+            std::enable_if_t<std::is_constructible_v<GE, GE&>>* = nullptr>
+  constexpr auto and_then(F&& f) & {
+    using U = std::remove_cvref_t<std::invoke_result_t<F>>;
+    static_assert(expected_detail::is_specialization_v<U, iceberg::expected>,
+                  "U (return type of F) must be specialization of expected");
+    static_assert(std::is_same_v<typename U::error_type, E>,
+                  "The error type must be the same after calling the F");
+
+    if (has_value()) {
+      return std::invoke(std::forward<F>(f));
+    } else {
+      return U(unexpect, error());
+    }
+  }
+  template <class F, class GE = E,
+            std::enable_if_t<std::is_constructible_v<GE, const GE&>>* = nullptr>
+  constexpr auto and_then(F&& f) const& {
+    using U = std::remove_cvref_t<std::invoke_result_t<F>>;
+    static_assert(expected_detail::is_specialization_v<U, iceberg::expected>,
+                  "U (return type of F) must be specialization of expected");
+    static_assert(std::is_same_v<typename U::error_type, E>,
+                  "The error type must be the same after calling the F");
+
+    if (has_value()) {
+      return std::invoke(std::forward<F>(f));
+    } else {
+      return U(unexpect, error());
+    }
+  }
+  template <class F, class GE = E,
+            std::enable_if_t<std::is_constructible_v<GE, GE&&>>* = nullptr>
+  constexpr auto and_then(F&& f) && {
+    using U = std::remove_cvref_t<std::invoke_result_t<F>>;
+    static_assert(expected_detail::is_specialization_v<U, iceberg::expected>,
+                  "U (return type of F) must be specialization of expected");
+    static_assert(std::is_same_v<typename U::error_type, E>,
+                  "The error type must be the same after calling the F");
+
+    if (has_value()) {
+      return std::invoke(std::forward<F>(f));
+    } else {
+      return U(unexpect, std::move(error()));
+    }
+  }
+  template <class F, class GE = E,
+            std::enable_if_t<std::is_constructible_v<GE, const GE>>* = nullptr>
+  constexpr auto and_then(F&& f) const&& {
+    using U = std::remove_cvref_t<std::invoke_result_t<F>>;
+    static_assert(expected_detail::is_specialization_v<U, iceberg::expected>,
+                  "U (return type of F) must be specialization of expected");
+    static_assert(std::is_same_v<typename U::error_type, E>,
+                  "The error type must be the same after calling the F");
+
+    if (has_value()) {
+      return std::invoke(std::forward<F>(f));
+    } else {
+      return U(unexpect, std::move(error()));
+    }
+  }
+
+  template <class F>
+  constexpr auto or_else(F&& f) & {
+    using G = std::remove_cvref_t<std::invoke_result_t<F, decltype(error())>>;
+    static_assert(expected_detail::is_specialization_v<G, iceberg::expected>,
+                  "G (return type of F) must be specialization of expected");
+    static_assert(std::is_same_v<typename G::value_type, T>,
+                  "The value type must be the same after calling the F");
+
+    if (has_value()) {
+      return G();
+    } else {
+      return std::invoke(std::forward<F>(f), error());
+    }
+  }
+  template <class F>
+  constexpr auto or_else(F&& f) const& {
+    using G = std::remove_cvref_t<std::invoke_result_t<F, decltype(error())>>;
+    static_assert(expected_detail::is_specialization_v<G, iceberg::expected>,
+                  "G (return type of F) must be specialization of expected");
+    static_assert(std::is_same_v<typename G::value_type, T>,
+                  "The value type must be the same after calling the F");
+
+    if (has_value()) {
+      return G();
+    } else {
+      return std::invoke(std::forward<F>(f), error());
+    }
+  }
+  template <class F>
+  constexpr auto or_else(F&& f) && {
+    using G = std::remove_cvref_t<std::invoke_result_t<F, decltype(std::move(error()))>>;
+    static_assert(expected_detail::is_specialization_v<G, iceberg::expected>,
+                  "G (return type of F) must be specialization of expected");
+    static_assert(std::is_same_v<typename G::value_type, T>,
+                  "The value type must be the same after calling the F");
+
+    if (has_value()) {
+      return G();
+    } else {
+      return std::invoke(std::forward<F>(f), std::move(error()));
+    }
+  }
+  template <class F>
+  constexpr auto or_else(F&& f) const&& {
+    using G = std::remove_cvref_t<std::invoke_result_t<F, decltype(std::move(error()))>>;
+    static_assert(expected_detail::is_specialization_v<G, iceberg::expected>,
+                  "G (return type of F) must be specialization of expected");
+    static_assert(std::is_same_v<typename G::value_type, T>,
+                  "The value type must be the same after calling the F");
+
+    if (has_value()) {
+      return G();
+    } else {
+      return std::invoke(std::forward<F>(f), std::move(error()));
+    }
+  }
+
+  template <class F, class GE = E,
+            std::enable_if_t<std::is_constructible_v<GE, GE&>>* = nullptr>
+  constexpr auto transform(F&& f) & {
+    using U = std::remove_cvref_t<std::invoke_result_t<F>>;
+    static_assert(expected_detail::is_value_type_valid_v<U>,
+                  "U must be a valid type for expected<U, E>");
+    // FIXME another constraint needed here
+    if (!has_value()) {
+      return expected<U, E>(unexpect, error());
+    } else {
+      if constexpr (std::is_void_v<U>) {
+        std::invoke(std::forward<F>(f));
+        return expected<U, E>{};
+      } else {
+        return expected<U, E>(expected_detail::construct_with_invoke_result_t{},
+                              std::forward<F>(f));
+      }
+    }
+  }
+  template <class F, class GE = E,
+            std::enable_if_t<std::is_constructible_v<GE, const GE&>>* = nullptr>
+  constexpr auto transform(F&& f) const& {
+    using U = std::remove_cvref_t<std::invoke_result_t<F>>;
+    static_assert(expected_detail::is_value_type_valid_v<U>,
+                  "U must be a valid type for expected<U, E>");
+    // FIXME another constraint needed here
+    if (!has_value()) {
+      return expected<U, E>(unexpect, error());
+    } else {
+      if constexpr (std::is_void_v<U>) {
+        std::invoke(std::forward<F>(f));
+        return expected<U, E>{};
+      } else {
+        return expected<U, E>(expected_detail::construct_with_invoke_result_t{},
+                              std::forward<F>(f));
+      }
+    }
+  }
+  template <class F, class GE = E,
+            std::enable_if_t<std::is_constructible_v<GE, GE&&>>* = nullptr>
+  constexpr auto transform(F&& f) && {
+    using U = std::remove_cvref_t<std::invoke_result_t<F>>;
+    static_assert(expected_detail::is_value_type_valid_v<U>,
+                  "U must be a valid type for expected<U, E>");
+    // FIXME another constraint needed here
+    if (!has_value()) {
+      return expected<U, E>(unexpect, std::move(error()));
+    } else {
+      if constexpr (std::is_void_v<U>) {
+        std::invoke(std::forward<F>(f));
+        return expected<U, E>{};
+      } else {
+        return expected<U, E>(expected_detail::construct_with_invoke_result_t{},
+                              std::forward<F>(f));
+      }
+    }
+  }
+  template <class F, class GE = E,
+            std::enable_if_t<std::is_constructible_v<GE, const GE>>* = nullptr>
+  constexpr auto transform(F&& f) const&& {
+    using U = std::remove_cvref_t<std::invoke_result_t<F>>;
+    static_assert(expected_detail::is_value_type_valid_v<U>,
+                  "U must be a valid type for expected<U, E>");
+    // FIXME another constraint needed here
+    if (!has_value()) {
+      return expected<U, E>(unexpect, std::move(error()));
+    } else {
+      if constexpr (std::is_void_v<U>) {
+        std::invoke(std::forward<F>(f));
+        return expected<U, E>{};
+      } else {
+        return expected<U, E>(expected_detail::construct_with_invoke_result_t{},
+                              std::forward<F>(f));
+      }
+    }
+  }
+
+  template <class F>
+  constexpr auto transform_error(F&& f) & {
+    using G = std::remove_cvref_t<std::invoke_result_t<F, decltype(error())>>;
+    static_assert(expected_detail::is_error_type_valid_v<G>,
+                  "G must be a valid type for expected<void, G>");
+    // FIXME another constraint needed here
+    if (has_value()) {
+      return expected<T, G>();
+    } else {
+      return expected<T, G>(expected_detail::construct_with_invoke_result_t{}, unexpect,
+                            std::forward<F>(f), error());
+    }
+  }
+  template <class F>
+  constexpr auto transform_error(F&& f) const& {
+    using G = std::remove_cvref_t<std::invoke_result_t<F, decltype(error())>>;
+    static_assert(expected_detail::is_error_type_valid_v<G>,
+                  "G must be a valid type for expected<void, G>");
+    // FIXME another constraint needed here
+    if (has_value()) {
+      return expected<T, G>();
+    } else {
+      return expected<T, G>(expected_detail::construct_with_invoke_result_t{}, unexpect,
+                            std::forward<F>(f), error());
+    }
+  }
+  template <class F>
+  constexpr auto transform_error(F&& f) && {
+    using G = std::remove_cvref_t<std::invoke_result_t<F, decltype(std::move(error()))>>;
+    static_assert(expected_detail::is_error_type_valid_v<G>,
+                  "G must be a valid type for expected<void, G>");
+    // FIXME another constraint needed here
+    if (has_value()) {
+      return expected<T, G>();
+    } else {
+      return expected<T, G>(expected_detail::construct_with_invoke_result_t{}, unexpect,
+                            std::forward<F>(f), std::move(error()));
+    }
+  }
+  template <class F>
+  constexpr auto transform_error(F&& f) const&& {
+    using G = std::remove_cvref_t<std::invoke_result_t<F, decltype(std::move(error()))>>;
+    static_assert(expected_detail::is_error_type_valid_v<G>,
+                  "G must be a valid type for expected<void, G>");
+    // FIXME another constraint needed here
+    if (has_value()) {
+      return expected<T, G>();
+    } else {
+      return expected<T, G>(expected_detail::construct_with_invoke_result_t{}, unexpect,
+                            std::forward<F>(f), std::move(error()));
+    }
+  }
+
+  template <class T2, class E2>
+  [[nodiscard]] friend constexpr std::enable_if_t<std::is_void_v<T2>, bool> operator==(
+      const expected& x,
+      const expected<T2, E2>& y) noexcept(noexcept(x.error() == y.error())) {
+    if (x.has_value() != y.has_value()) {
+      return false;
+    } else {
+      return x.has_value() || static_cast<bool>(x.error() == y.error());
+    }
+  }
+
+  template <class E2>
+  [[nodiscard]] friend constexpr bool operator==(
+      const expected& x,
+      const unexpected<E2>& e) noexcept(noexcept(x.error() == e.error())) {
+    if (x.has_value()) {
+      return false;
+    } else {
+      return static_cast<bool>(x.error() == e.error());
+    }
+  }
+};
+
+// standalone swap for void value type
+template <class E, std::enable_if_t<std::is_move_constructible_v<E> &&
+                                    std::is_swappable_v<E>>* = nullptr>
+ICEBERG_EXPORT constexpr void swap(
+    expected<void, E>& lhs, expected<void, E>& rhs) noexcept(noexcept(lhs.swap(rhs))) {
+  lhs.swap(rhs);
+}
+
+}  // namespace iceberg
+
+// NOLINTEND
diff --git a/src/iceberg/file_format.h b/src/iceberg/file_format.h
index 0919cf0bf..1541b61d3 100644
--- a/src/iceberg/file_format.h
+++ b/src/iceberg/file_format.h
@@ -28,6 +28,7 @@
 #include "iceberg/iceberg_export.h"
 #include "iceberg/result.h"
 #include "iceberg/util/string_util.h"
+#include "iceberg/util/unreachable.h"
 
 namespace iceberg {
 
@@ -51,7 +52,7 @@ ICEBERG_EXPORT inline std::string_view ToString(FileFormatType format_type) {
     case FileFormatType::kPuffin:
       return "puffin";
   }
-  std::unreachable();
+  Unreachable();
 }
 
 /// \brief Convert a string to a FileFormatType
diff --git a/src/iceberg/logging/log_level.h b/src/iceberg/logging/log_level.h
index d06916af0..551cc9216 100644
--- a/src/iceberg/logging/log_level.h
+++ b/src/iceberg/logging/log_level.h
@@ -27,6 +27,7 @@
 
 #include "iceberg/result.h"
 #include "iceberg/util/string_util.h"
+#include "iceberg/util/unreachable.h"
 
 namespace iceberg {
 
@@ -66,7 +67,7 @@ constexpr std::string_view ToString(LogLevel level) noexcept {
     case LogLevel::kOff:
       return "off";
   }
-  std::unreachable();
+  Unreachable();
 }
 
 /// \brief Parse a LogLevel from a string (case-insensitive).
diff --git a/src/iceberg/logging/logger.h b/src/iceberg/logging/logger.h
index 8575158ca..35495cf97 100644
--- a/src/iceberg/logging/logger.h
+++ b/src/iceberg/logging/logger.h
@@ -157,7 +157,7 @@ class ICEBERG_EXPORT Logger {
       const std::unordered_map<std::string, std::string>& properties) {
     if (auto it = properties.find(std::string(kLevelProperty)); it != properties.end()) {
       auto parsed = LogLevelFromString(it->second);
-      if (!parsed) return std::unexpected(parsed.error());
+      if (!parsed) return unexpected(parsed.error());
       SetLevel(*parsed);
     }
     return {};
diff --git a/src/iceberg/manifest/manifest_entry.h b/src/iceberg/manifest/manifest_entry.h
index d3dc2f7a2..e29eded99 100644
--- a/src/iceberg/manifest/manifest_entry.h
+++ b/src/iceberg/manifest/manifest_entry.h
@@ -34,6 +34,7 @@
 #include "iceberg/row/partition_values.h"
 #include "iceberg/schema_field.h"
 #include "iceberg/type.h"
+#include "iceberg/util/unreachable.h"
 
 namespace iceberg {
 
@@ -418,7 +419,7 @@ ICEBERG_EXPORT constexpr std::string_view ToString(DataFile::Content type) noexc
     case DataFile::Content::kEqualityDeletes:
       return "equality_deletes";
   }
-  std::unreachable();
+  Unreachable();
 }
 
 /// \brief Get the relative data file content type from int
diff --git a/src/iceberg/manifest/manifest_list.h b/src/iceberg/manifest/manifest_list.h
index 652713684..91e6567cd 100644
--- a/src/iceberg/manifest/manifest_list.h
+++ b/src/iceberg/manifest/manifest_list.h
@@ -34,6 +34,7 @@
 #include "iceberg/schema_field.h"
 #include "iceberg/table_metadata.h"
 #include "iceberg/type.h"
+#include "iceberg/util/unreachable.h"
 
 namespace iceberg {
 
@@ -262,7 +263,7 @@ ICEBERG_EXPORT inline constexpr std::string_view ToString(ManifestContent type)
     case ManifestContent::kDeletes:
       return "deletes";
   }
-  std::unreachable();
+  Unreachable();
 }
 
 /// \brief Get the relative manifest content type from name
diff --git a/src/iceberg/metrics/counter.h b/src/iceberg/metrics/counter.h
index b44cf844b..96f7de13d 100644
--- a/src/iceberg/metrics/counter.h
+++ b/src/iceberg/metrics/counter.h
@@ -31,6 +31,7 @@
 #include "iceberg/iceberg_export.h"
 #include "iceberg/result.h"
 #include "iceberg/util/string_util.h"
+#include "iceberg/util/unreachable.h"
 
 namespace iceberg {
 
@@ -51,7 +52,7 @@ ICEBERG_EXPORT constexpr std::string_view ToString(CounterUnit unit) noexcept {
     case CounterUnit::kUndefined:
       return "undefined";
   }
-  std::unreachable();
+  Unreachable();
 }
 
 /// \brief Parse a CounterUnit from a string.
diff --git a/src/iceberg/metrics/metrics_reporter.h b/src/iceberg/metrics/metrics_reporter.h
index a45754dc0..b49b86ae8 100644
--- a/src/iceberg/metrics/metrics_reporter.h
+++ b/src/iceberg/metrics/metrics_reporter.h
@@ -32,6 +32,7 @@
 #include "iceberg/metrics/commit_report.h"
 #include "iceberg/metrics/scan_report.h"
 #include "iceberg/result.h"
+#include "iceberg/util/unreachable.h"
 
 namespace iceberg {
 
@@ -49,7 +50,7 @@ ICEBERG_EXPORT constexpr std::string_view ToString(MetricsReportType type) noexc
     case MetricsReportType::kCommitReport:
       return "commit";
   }
-  std::unreachable();
+  Unreachable();
 }
 
 /// \brief A metrics report, which can be either a ScanReport or CommitReport.
diff --git a/src/iceberg/metrics/timer.h b/src/iceberg/metrics/timer.h
index e15c623f3..9303b3bce 100644
--- a/src/iceberg/metrics/timer.h
+++ b/src/iceberg/metrics/timer.h
@@ -32,6 +32,7 @@
 #include <utility>
 
 #include "iceberg/iceberg_export.h"
+#include "iceberg/util/unreachable.h"
 
 namespace iceberg {
 
@@ -64,7 +65,7 @@ ICEBERG_EXPORT constexpr std::string_view ToString(TimerUnit unit) noexcept {
     case TimerUnit::kDays:
       return "days";
   }
-  std::unreachable();
+  Unreachable();
 }
 
 /// \brief Abstract timer for measuring operation durations.
diff --git a/src/iceberg/result.h b/src/iceberg/result.h
index 88b13c51e..ce56b1bb9 100644
--- a/src/iceberg/result.h
+++ b/src/iceberg/result.h
@@ -23,11 +23,11 @@
 /// \brief Define Result, Status, and error helpers.
 
 #include <concepts>
-#include <expected>
 #include <format>
 #include <string>
 #include <type_traits>
 
+#include "iceberg/expected.h"
 #include "iceberg/iceberg_export.h"
 
 namespace iceberg {
@@ -85,7 +85,7 @@ struct DefaultError {
 
 /// \brief Result alias
 template <typename T, typename E = typename DefaultError<T>::type>
-using Result = std::expected<T, E>;
+using Result = expected<T, E>;
 
 using Status = Result<void>;
 
@@ -93,12 +93,12 @@ using Status = Result<void>;
 #define DEFINE_ERROR_FUNCTION(name)                                           \
   template <typename... Args>                                                 \
   inline auto name(const std::format_string<Args...> fmt, Args&&... args)     \
-      -> std::unexpected<Error> {                                             \
-    return std::unexpected<Error>(                                            \
+      -> unexpected<Error> {                                                  \
+    return unexpected<Error>(                                                 \
         {ErrorKind::k##name, std::format(fmt, std::forward<Args>(args)...)}); \
   }                                                                           \
-  inline auto name(std::string message) -> std::unexpected<Error> {           \
-    return std::unexpected<Error>({ErrorKind::k##name, std::move(message)});  \
+  inline auto name(std::string message) -> unexpected<Error> {                \
+    return unexpected<Error>({ErrorKind::k##name, std::move(message)});       \
   }
 
 DEFINE_ERROR_FUNCTION(AlreadyExists)
diff --git a/src/iceberg/snapshot.h b/src/iceberg/snapshot.h
index 9dc162be0..a5e614a24 100644
--- a/src/iceberg/snapshot.h
+++ b/src/iceberg/snapshot.h
@@ -36,6 +36,7 @@
 #include "iceberg/type_fwd.h"
 #include "iceberg/util/lazy.h"
 #include "iceberg/util/timepoint.h"
+#include "iceberg/util/unreachable.h"
 
 namespace iceberg {
 
@@ -57,7 +58,7 @@ ICEBERG_EXPORT constexpr std::string_view ToString(SnapshotRefType type) noexcep
     case SnapshotRefType::kTag:
       return "tag";
   }
-  std::unreachable();
+  Unreachable();
 }
 /// \brief Get the relative snapshot reference type from name
 ICEBERG_EXPORT constexpr Result<SnapshotRefType> SnapshotRefTypeFromString(
diff --git a/src/iceberg/test/CMakeLists.txt b/src/iceberg/test/CMakeLists.txt
index f23bc9181..584706fdc 100644
--- a/src/iceberg/test/CMakeLists.txt
+++ b/src/iceberg/test/CMakeLists.txt
@@ -133,6 +133,7 @@ add_iceberg_test(util_test
                  data_file_set_test.cc
                  decimal_test.cc
                  endian_test.cc
+                 expected_test.cc
                  file_io_test.cc
                  formatter_test.cc
                  stream_test.cc
diff --git a/src/iceberg/test/expected_test.cc b/src/iceberg/test/expected_test.cc
new file mode 100644
index 000000000..984bc0601
--- /dev/null
+++ b/src/iceberg/test/expected_test.cc
@@ -0,0 +1,684 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include "iceberg/expected.h"
+
+#include <functional>
+#include <type_traits>
+
+#include <gtest/gtest.h>
+
+TEST(ExpectedTest, DefaultCons) {
+  iceberg::expected<int, int> e1;
+  iceberg::expected<int, int> e2{};
+  EXPECT_EQ(e1.value(), 0);
+  EXPECT_EQ(e2.value(), 0);
+}
+
+TEST(ExpectedTest, InplaceCons) {
+  iceberg::expected<void, int> e1{iceberg::unexpect};
+  iceberg::expected<void, int> e2{iceberg::unexpect, 42};
+  iceberg::expected<int, int> e3{iceberg::unexpect};
+  iceberg::expected<int, int> e4{iceberg::unexpect, 42};
+
+  EXPECT_EQ(e1.error(), 0);
+  EXPECT_EQ(e2.error(), 42);
+  EXPECT_EQ(e3.error(), 0);
+  EXPECT_EQ(e4.error(), 42);
+}
+
+TEST(ExpectedTest, ImplicitConversion) {
+  iceberg::expected<int, int> e = 42;
+
+  EXPECT_EQ(e.value(), 42);
+}
+
+TEST(ExpectedTest, ExplicitConversion) {
+  iceberg::expected<std::string, int> e1 = iceberg::unexpected<int>(42);
+  iceberg::expected<std::string, int> e2{iceberg::unexpect, 42};
+  EXPECT_EQ(e1.error(), 42);
+  EXPECT_EQ(e2.error(), 42);
+}
+
+TEST(ExpectedTest, ImplicitConversionFrom) {
+  EXPECT_FALSE((std::is_convertible_v<iceberg::expected<std::string, int>, int>));
+}
+
+TEST(ExpectedTest, ConversionToValueWithoutDefaultConstructor) {
+  int value = 42;
+  iceberg::expected<std::reference_wrapper<int>, int> ref = std::ref(value);
+
+  iceberg::expected<std::reference_wrapper<const int>, int> from_value = ref;
+  ASSERT_TRUE(from_value.has_value());
+  EXPECT_EQ(from_value->get(), 42);
+
+  iceberg::expected<std::reference_wrapper<const int>, int> from_error =
+      iceberg::expected<std::reference_wrapper<int>, int>{iceberg::unexpect, 7};
+  ASSERT_FALSE(from_error.has_value());
+  EXPECT_EQ(from_error.error(), 7);
+
+  EXPECT_FALSE((std::is_default_constructible_v<
+                iceberg::expected<std::reference_wrapper<int>, int>>));
+}
+
+namespace {
+
+// Counts live objects, to catch a value constructed without being destroyed.
+struct LiveCount {
+  static inline int live = 0;
+  LiveCount() { ++live; }
+  explicit LiveCount(int) { ++live; }
+  LiveCount(const LiveCount&) { ++live; }
+  LiveCount(LiveCount&&) noexcept { ++live; }
+  LiveCount& operator=(const LiveCount&) = default;
+  LiveCount& operator=(LiveCount&&) noexcept = default;
+  ~LiveCount() { --live; }
+};
+
+}  // namespace
+
+TEST(ExpectedTest, ConversionConstructsValueOnce) {
+  {
+    iceberg::expected<int, int> value = 1;
+    iceberg::expected<LiveCount, int> from_value(value);
+    iceberg::expected<int, int> error = iceberg::unexpected(2);
+    iceberg::expected<LiveCount, int> from_error(error);
+    EXPECT_EQ(LiveCount::live, 1);
+  }
+  EXPECT_EQ(LiveCount::live, 0);
+}
+
+TEST(ExpectedTest, ExplicitVoidE) {
+  iceberg::expected<void, int> e1 = {};
+  iceberg::expected<void, int> e2 = iceberg::unexpected{42};
+
+  EXPECT_TRUE(e1.has_value());
+  EXPECT_TRUE((std::is_same_v<decltype(e1.value()), void>));
+  e1.value();
+  EXPECT_FALSE(e2.has_value());
+  EXPECT_EQ(e2.error(), 42);
+}
+
+TEST(ExpectedTest, Emplace) {
+  struct S {
+    S(int i, double d) noexcept : i(i), d(d) {}
+    int i;
+    double d;
+  };
+  iceberg::expected<S, std::nullopt_t> e{iceberg::unexpect, std::nullopt};
+  e.emplace(42, 3.14);
+  EXPECT_EQ(e.value().i, 42);
+  EXPECT_EQ(e.value().d, 3.14);
+}
+
+TEST(ExpectedTest, Equality) {
+  iceberg::expected<int, int> const v1;
+  iceberg::expected<int, int> const v2{42};
+  iceberg::expected<int, int> const v3 = 42;
+  iceberg::expected<int, int> const e1{iceberg::unexpect, 0};
+  iceberg::expected<int, int> const e2{iceberg::unexpect, 42};
+  iceberg::expected<int, int> const e3 = iceberg::unexpected(42);
+  EXPECT_TRUE(v1 != v2);
+  EXPECT_TRUE(v2 == v3);
+  EXPECT_TRUE(v1 != e1);
+  EXPECT_TRUE(v1 != e2);
+  EXPECT_TRUE(e1 != e2);
+  EXPECT_TRUE(e2 == e3);
+  EXPECT_TRUE(e1 != v1);
+  EXPECT_TRUE(e1 != v2);
+}
+
+TEST(ExpectedTest, UnexpectedError) {
+  auto e = iceberg::unexpected(42);
+  EXPECT_EQ(e.error(), 42);
+}
+
+TEST(ExpectedTest, UnexpectedEquality) {
+  const iceberg::unexpected<std::string> error1("error1");
+  const iceberg::unexpected<std::string> error1_copy("error1");
+  const iceberg::unexpected<std::string> error2("error2");
+
+  EXPECT_EQ(error1, error1_copy);
+  EXPECT_NE(error1, error2);
+}
+
+TEST(ExpectedTest, BadExpectedAccess) {
+  iceberg::expected<void, int> e = iceberg::unexpected(42);
+  EXPECT_THROW(
+      {
+        try {
+          e.value();
+        } catch (const iceberg::bad_expected_access<int>& ex) {
+          // and this tests that it has the correct message
+          EXPECT_EQ(ex.error(), 42);
+          throw;
+        }
+      },
+      iceberg::bad_expected_access<int>);
+}
+
+TEST(ExpectedTest, ExpectedVoidEEmplace) {
+  iceberg::expected<void, int> e1{std::in_place};
+  iceberg::expected<void, int> e2;
+  e2.emplace();
+}
+
+TEST(ExpectedTest, Swap) {
+  iceberg::expected<int, int> e1{42};
+  iceberg::expected<int, int> e2{1'337};
+
+  e1.swap(e2);
+  EXPECT_EQ(e1.value(), 1'337);
+  EXPECT_EQ(e2.value(), 42);
+
+  swap(e1, e2);
+  EXPECT_EQ(e1.value(), 42);
+  EXPECT_EQ(e2.value(), 1'337);
+}
+
+TEST(ExpectedTest, CopyInitialization) {
+  {
+    iceberg::expected<std::string, int> e = {};
+    EXPECT_TRUE(e);
+  }
+}
+
+TEST(ExpectedTest, BraceContructedValue) {
+  {  // non-void
+    iceberg::expected<int, int> e{{}};
+    EXPECT_TRUE(e);
+  }
+#if !defined(__GNUC__)
+  {  // std::string
+    iceberg::expected<std::string, int> e{{}};
+    EXPECT_TRUE(e);
+  }
+#endif
+}
+
+TEST(ExpectedTest, LWG3836) {
+  struct BaseError {};
+  struct DerivedError : BaseError {};
+
+  iceberg::expected<bool, DerivedError> e1(false);
+  iceberg::expected<bool, BaseError> e2(e1);
+  EXPECT_TRUE(!e2.value());
+
+  iceberg::expected<void, DerivedError> e3{};
+  iceberg::expected<void, BaseError> e4(e3);
+  EXPECT_TRUE(e4.has_value());
+}
+
+TEST(ExpectedTest, Assignment) {
+  // non-void
+  {
+    iceberg::expected<int, int> e1{iceberg::unexpect, 1'337};
+    iceberg::expected<int, int> e2{42};
+
+    e1 = e2;
+    EXPECT_TRUE(e1);
+  }
+
+  // void
+  {
+    iceberg::expected<void, int> e1{iceberg::unexpect, 1'337};
+    iceberg::expected<void, int> e2{};
+
+    e1 = e2;
+    EXPECT_TRUE(e1);
+  }
+}
+
+TEST(ExpectedTest, Move) {
+  {
+    struct user_provided_move {
+      user_provided_move() = default;
+      user_provided_move(user_provided_move&&) noexcept {}
+    };
+
+    struct defaulted_move {
+      defaulted_move() = default;
+      defaulted_move(defaulted_move&&) = default;
+    };
+
+    {
+      using Expected = iceberg::expected<user_provided_move, int>;
+      Expected t1;
+      Expected tm1(std::move(t1));
+      EXPECT_TRUE(tm1);
+    }
+    {
+      using Expected = iceberg::expected<defaulted_move, int>;
+      Expected t2;
+      Expected tm2(std::move(t2));  // should compile
+      EXPECT_TRUE(tm2);
+    }
+  }
+
+  {
+    class MoveOnly {
+     public:
+      MoveOnly() = default;
+
+      // Non-copyable
+      MoveOnly(const MoveOnly&) = delete;
+      MoveOnly& operator=(const MoveOnly&) = delete;
+
+      // Movable trivially
+      MoveOnly(MoveOnly&&) = default;
+      MoveOnly& operator=(MoveOnly&&) = default;
+    };
+
+    {
+      using Expected = iceberg::expected<MoveOnly, int>;
+      Expected a{};
+      Expected b = std::move(a);  // should compile
+    }
+  }
+}
+
+namespace {
+
+template <bool ShouldEqual, typename T, typename U>
+constexpr bool EqualityTester(T const& lhs, U const& rhs) {
+  return (lhs == rhs) == ShouldEqual && (lhs != rhs) != ShouldEqual &&
+         (rhs == lhs) == ShouldEqual && (rhs != lhs) != ShouldEqual;
+}
+
+struct Type1 {
+  std::string value;
+
+  explicit Type1(std::string v) : value(std::move(v)) {}
+  explicit Type1(const char* v) : value(v) {}
+  Type1(Type1 const&) = delete;
+  Type1& operator=(Type1 const&) = delete;
+  Type1(Type1&& other) = default;
+  Type1& operator=(Type1&&) = default;
+  ~Type1() = default;
+
+  bool operator==(Type1 const& rhs) const { return value == rhs.value; }
+};
+
+struct Type2 {
+  std::string value;
+
+  explicit Type2(std::string v) : value(std::move(v)) {}
+  explicit Type2(const char* v) : value(v) {}
+  Type2(Type2 const&) = delete;
+  Type2& operator=(Type2 const&) = delete;
+  Type2(Type2&& other) = default;
+  Type2& operator=(Type2&&) = default;
+  ~Type2() = default;
+
+  bool operator==(Type2 const& rhs) const { return value == rhs.value; }
+};
+
+inline bool operator==(Type1 const& lhs, Type2 const& rhs) {
+  return lhs.value == rhs.value;
+}
+
+inline bool operator==(Type2 const& lhs, Type1 const& rhs) { return rhs == lhs; }
+
+}  // namespace
+
+TEST(ExpectedTest, EqualityTest) {
+  // expected<T, E> (T is not void)
+  {
+    using T = Type1;
+    using E = Type2;
+    using Expected = iceberg::expected<T, E>;
+
+    // compare with same type expected<T, E>
+    {
+      Expected const value1("value1");
+      Expected const value2("value2");
+      Expected const value1Copy("value1");
+      Expected const error1 = iceberg::unexpected<E>("error1");
+      Expected const error2 = iceberg::unexpected<E>("error2");
+      Expected const error1Copy = iceberg::unexpected<E>("error1");
+
+      EXPECT_TRUE(EqualityTester<true>(value1, value1Copy));
+      EXPECT_TRUE(EqualityTester<false>(value1, value2));
+      EXPECT_TRUE(EqualityTester<true>(error1, error1Copy));
+      EXPECT_TRUE(EqualityTester<false>(error1, error2));
+      EXPECT_TRUE(EqualityTester<false>(value1, error1));
+    }
+
+    // compare with different type expected<T2, E2>
+    {
+      using T2 = Type2;
+      using E2 = Type1;
+      ASSERT_FALSE((std::is_same_v<T, T2>));
+      ASSERT_FALSE((std::is_same_v<E, E2>));
+      using Expected2 = iceberg::expected<T2, E2>;
+
+      Expected const value1("value1");
+      Expected2 const value2("value2");
+      Expected2 const value1Same("value1");
+      Expected const error1 = iceberg::unexpected<E>("error1");
+      Expected2 const error2 = iceberg::unexpected<E2>("error2");
+      Expected2 const error1Same = iceberg::unexpected<E2>("error1");
+
+      EXPECT_TRUE(EqualityTester<true>(value1, value1Same));
+      EXPECT_TRUE(EqualityTester<false>(value1, value2));
+      EXPECT_TRUE(EqualityTester<true>(error1, error1Same));
+      EXPECT_TRUE(EqualityTester<false>(error1, error2));
+      EXPECT_TRUE(EqualityTester<false>(value1, error1));
+    }
+
+    // compare with same value type T
+    {
+      Expected const value1("value1");
+      Expected const error1 = iceberg::unexpected<E>("error1");
+      T const value2("value2");
+      T const value1Same("value1");
+
+      EXPECT_TRUE(EqualityTester<true>(value1, value1Same));
+      EXPECT_TRUE(EqualityTester<false>(value1, value2));
+      EXPECT_TRUE(EqualityTester<false>(error1, value2));
+    }
+
+    // compare with different value type T2
+    {
+      using T2 = Type2;
+      ASSERT_FALSE((std::is_same_v<T, T2>));
+
+      Expected const value1("value1");
+      Expected const error1 = iceberg::unexpected<E>("error1");
+      T2 const value2("value2");
+      T2 const value1Same("value1");
+
+      EXPECT_TRUE(EqualityTester<true>(value1, value1Same));
+      EXPECT_TRUE(EqualityTester<false>(value1, value2));
+      EXPECT_TRUE(EqualityTester<false>(error1, value2));
+    }
+
+    // compare with same error type unexpected<E>
+    {
+      Expected const value1("value1");
+      Expected const error1 = iceberg::unexpected<E>("error1");
+      auto const error2 = iceberg::unexpected<E>("error2");
+      auto const error1Same = iceberg::unexpected<E>("error1");
+
+      EXPECT_TRUE(EqualityTester<true>(error1, error1Same));
+      EXPECT_TRUE(EqualityTester<false>(error1, error2));
+      EXPECT_TRUE(EqualityTester<false>(value1, error2));
+    }
+
+    // compare with different error type unexpected<E2>
+    {
+      using E2 = Type1;
+      ASSERT_FALSE((std::is_same_v<E, E2>));
+
+      Expected const value1("value1");
+      Expected const error1 = iceberg::unexpected<E>("error1");
+      auto const error2 = iceberg::unexpected<E2>("error2");
+      auto const error1Same = iceberg::unexpected<E2>("error1");
+
+      EXPECT_TRUE(EqualityTester<true>(error1, error1Same));
+      EXPECT_TRUE(EqualityTester<false>(error1, error2));
+      EXPECT_TRUE(EqualityTester<false>(value1, error2));
+    }
+  }
+
+  // expected<void, E>
+  {
+    using E = Type1;
+    using Expected = iceberg::expected<void, E>;
+
+    // compare with same type expected<void, E>
+    {
+      Expected const value1;
+      Expected const value2;
+      Expected const error1 = iceberg::unexpected<E>("error1");
+      Expected const error2 = iceberg::unexpected<E>("error2");
+      Expected const error1Copy = iceberg::unexpected<E>("error1");
+
+      EXPECT_TRUE(EqualityTester<true>(value1, value2));
+      EXPECT_TRUE(EqualityTester<true>(error1, error1Copy));
+      EXPECT_TRUE(EqualityTester<false>(error1, error2));
+      EXPECT_TRUE(EqualityTester<false>(value1, error1));
+    }
+
+    // compare with different type expected<void, E2>
+    {
+      using E2 = Type2;
+      ASSERT_FALSE((std::is_same_v<E, E2>));
+      using Expected2 = iceberg::expected<void, E2>;
+
+      Expected const value1;
+      Expected2 const value2;
+      Expected const error1 = iceberg::unexpected<E>("error1");
+      Expected2 const error2 = iceberg::unexpected<E2>("error2");
+      Expected2 const error1Same = iceberg::unexpected<E2>("error1");
+
+      EXPECT_TRUE(EqualityTester<true>(value1, value2));
+      EXPECT_TRUE(EqualityTester<true>(error1, error1Same));
+      EXPECT_TRUE(EqualityTester<false>(error1, error2));
+      EXPECT_TRUE(EqualityTester<false>(value1, error1));
+    }
+
+    // compare with same error type unexpected<E>
+    {
+      Expected const value1;
+      Expected const error1 = iceberg::unexpected<E>("error1");
+      auto const error2 = iceberg::unexpected<E>("error2");
+      auto const error1Same = iceberg::unexpected<E>("error1");
+
+      EXPECT_TRUE(EqualityTester<true>(error1, error1Same));
+      EXPECT_TRUE(EqualityTester<false>(error1, error2));
+      EXPECT_TRUE(EqualityTester<false>(value1, error2));
+    }
+
+    // compare with different error type unexpected<E2>
+    {
+      using E2 = Type2;
+      ASSERT_FALSE((std::is_same_v<E, E2>));
+
+      Expected const value1;
+      Expected const error1 = iceberg::unexpected<E>("error1");
+      auto const error2 = iceberg::unexpected<E2>("error2");
+      auto const error1Same = iceberg::unexpected<E2>("error1");
+
+      EXPECT_TRUE(EqualityTester<true>(error1, error1Same));
+      EXPECT_TRUE(EqualityTester<false>(error1, error2));
+      EXPECT_TRUE(EqualityTester<false>(value1, error2));
+    }
+  }
+}
+
+TEST(ExpectedTest, AndThen) {
+  using T = std::string;
+  using Expected = iceberg::expected<int, T>;
+
+  {  // non-void
+    using Expected2 = iceberg::expected<double, T>;
+
+    Expected e = 42;
+
+    auto const newVal = e.and_then([](int x) { return Expected2{x * 2}; });
+
+    EXPECT_TRUE((std::is_same_v<std::remove_cv_t<decltype(newVal)>, Expected2>));
+  }
+  {  // void
+    using Expected2 = iceberg::expected<void, T>;
+
+    Expected e = 42;
+
+    auto const newVal = e.and_then([](int) -> Expected2 { return Expected2{}; });
+
+    EXPECT_TRUE((std::is_same_v<std::remove_cv_t<decltype(newVal)>, Expected2>));
+  }
+}
+
+TEST(ExpectedTest, VoidAndThen) {
+  using T = std::string;
+  using Expected = iceberg::expected<void, T>;
+
+  {  // non-void
+    using Expected2 = iceberg::expected<double, T>;
+
+    Expected e{};
+
+    auto const newVal = e.and_then([]() { return Expected2{}; });
+
+    EXPECT_TRUE((std::is_same_v<std::remove_cv_t<decltype(newVal)>, Expected2>));
+  }
+  {  // void
+    using Expected2 = iceberg::expected<void, T>;
+
+    Expected e{};
+
+    auto const newVal = e.and_then([]() -> Expected2 { return Expected2{}; });
+
+    EXPECT_TRUE((std::is_same_v<std::remove_cv_t<decltype(newVal)>, Expected2>));
+  }
+}
+
+TEST(ExpectedTest, OrElse) {
+  using T = std::string;
+  using Expected = iceberg::expected<T, int>;
+
+  {  // non-void
+    using Expected2 = iceberg::expected<T, double>;
+
+    Expected e{};
+
+    auto const newVal = e.or_else([](auto&&) { return Expected2{}; });
+
+    EXPECT_TRUE((std::is_same_v<std::remove_cv_t<decltype(newVal)>, Expected2>));
+  }
+}
+
+TEST(ExpectedTest, VoidOrElse) {
+  using Expected = iceberg::expected<void, int>;
+
+  {  // void
+    using Expected2 = iceberg::expected<void, double>;
+
+    Expected e{};
+
+    auto const newVal = e.or_else([](auto&&) { return Expected2{}; });
+
+    EXPECT_TRUE(newVal.has_value());
+    EXPECT_TRUE((std::is_same_v<std::remove_cv_t<decltype(newVal)>, Expected2>));
+  }
+}
+
+TEST(ExpectedTest, Transform) {
+  using Expected = iceberg::expected<int, int>;
+
+  {
+    Expected e{42};
+
+    auto const newVal = e.transform([](int n) { return n + 100; });
+
+    EXPECT_TRUE((std::is_same_v<std::remove_cv_t<decltype(newVal)>, Expected>));
+    EXPECT_EQ(newVal.value(), 142);
+  }
+
+  {
+    Expected e = iceberg::unexpected{-1};
+    auto const newVal = e.transform_error([](int n) { return n + 100; });
+
+    EXPECT_EQ(newVal.error(), 99);
+  }
+}
+
+namespace {
+struct FromType {};
+
+enum class NoThrowConvertible {
+  Yes,
+  No,
+};
+
+template <NoThrowConvertible N>
+struct ToType;
+
+template <>
+struct ToType<NoThrowConvertible::Yes> {
+  ToType() = default;
+  ToType(ToType const&) = default;
+  ToType(ToType&&) = default;
+
+  explicit ToType(FromType const&) noexcept {}
+};
+
+template <>
+struct ToType<NoThrowConvertible::No> {
+  ToType() = default;
+  ToType(ToType const&) = default;
+  ToType(ToType&&) = default;
+
+  explicit ToType(FromType const&) noexcept(false) {}
+};
+
+}  // namespace
+
+TEST(ExpectedTest, ValueOrNoexcept) {
+  {  // noexcept(true)
+    using T = ToType<NoThrowConvertible::Yes>;
+    using E = int;
+    using Expected = iceberg::expected<T, E>;
+    Expected e;
+    EXPECT_TRUE(noexcept(e.value_or(FromType{})));
+  }
+  {  // noexcept(false)
+    using T = ToType<NoThrowConvertible::No>;
+    using E = int;
+    using Expected = iceberg::expected<T, E>;
+    Expected e;
+    EXPECT_FALSE(noexcept(e.value_or(FromType{})));
+  }
+}
+
+TEST(ExpectedTest, ErrorOrNoexcept) {
+  {  // noexcept(true)
+    using T = int;
+    using E = ToType<NoThrowConvertible::Yes>;
+    using Expected = iceberg::expected<T, E>;
+    Expected e;
+    EXPECT_TRUE(noexcept(e.error_or(FromType{})));
+  }
+  {  // noexcept(false)
+    using T = int;
+    using E = ToType<NoThrowConvertible::No>;
+    using Expected = iceberg::expected<T, E>;
+    Expected e;
+    EXPECT_FALSE(noexcept(e.error_or(FromType{})));
+  }
+}
+
+TEST(ExpectedTest, VoidTErrorOrNoxcept) {
+  {  // noexcept(true)
+    using T = void;
+    using E = ToType<NoThrowConvertible::Yes>;
+    using Expected = iceberg::expected<T, E>;
+    Expected e;
+    EXPECT_TRUE(noexcept(e.error_or(FromType{})));
+  }
+  {  // noexcept(false)
+    using T = void;
+    using E = ToType<NoThrowConvertible::No>;
+    using Expected = iceberg::expected<T, E>;
+    Expected e;
+    EXPECT_FALSE(noexcept(e.error_or(FromType{})));
+  }
+}
diff --git a/src/iceberg/transform.h b/src/iceberg/transform.h
index 0228c020a..ea97779ac 100644
--- a/src/iceberg/transform.h
+++ b/src/iceberg/transform.h
@@ -32,6 +32,7 @@
 #include "iceberg/result.h"
 #include "iceberg/type_fwd.h"
 #include "iceberg/util/formattable.h"
+#include "iceberg/util/unreachable.h"
 
 namespace iceberg {
 
@@ -80,7 +81,7 @@ ICEBERG_EXPORT constexpr std::string_view TransformTypeToString(TransformType ty
     case TransformType::kVoid:
       return "void";
   }
-  std::unreachable();
+  Unreachable();
 }
 
 /// \brief Represents a transform used in partitioning or sorting in Iceberg.
diff --git a/src/iceberg/update/snapshot_update.h b/src/iceberg/update/snapshot_update.h
index 1812b7072..e05744a6e 100644
--- a/src/iceberg/update/snapshot_update.h
+++ b/src/iceberg/update/snapshot_update.h
@@ -61,6 +61,13 @@ class ICEBERG_EXPORT SnapshotUpdate : public PendingUpdate {
   bool IsRetryable() const override { return true; }
   Status Commit() override;
 
+// C++23 uses deducing `this` so chaining keeps returning the derived update type.
+// C++20 exposes the same operations but returns SnapshotUpdate&, because preserving
+// the derived type would require making the update hierarchy CRTP. Keyed on the
+// language version rather than __cpp_explicit_this_parameter, which Apple clang does
+// not define, and compared with "> 202002L" because MSVC's /std:c++latest only
+// promises a value above 202002L.
+#if __cplusplus > 202002L || (defined(_MSVC_LANG) && _MSVC_LANG > 202002L)
   /// \brief Set the metrics reporter for this snapshot update.
   ///
   /// \param reporter The metrics reporter to use.
@@ -155,6 +162,99 @@ class ICEBERG_EXPORT SnapshotUpdate : public PendingUpdate {
     self.write_manifest_parallelism_ = parallelism;
     return self;
   }
+#else
+  /// \brief Set the metrics reporter for this snapshot update.
+  ///
+  /// \param reporter The metrics reporter to use.
+  /// \return This snapshot update for method chaining.
+  SnapshotUpdate& ReportWith(std::shared_ptr<MetricsReporter> reporter) {
+    reporter_ = std::move(reporter);
+    return *this;
+  }
+
+  /// \brief Set a callback to delete files instead of the table's default.
+  ///
+  /// \param delete_func A function used to delete file locations.
+  /// \return This snapshot update for method chaining.
+  /// \note Cannot be called more than once.
+  SnapshotUpdate& DeleteWith(std::function<Status(const std::string&)> delete_func) {
+    if (delete_func_) {
+      AddError(ErrorKind::kInvalidArgument, "Cannot set delete callback more than once");
+      return *this;
+    }
+    delete_func_ = std::move(delete_func);
+    return *this;
+  }
+
+  /// \brief Stage a snapshot in table metadata, but do not make it current.
+  ///
+  /// \return This snapshot update for method chaining.
+  SnapshotUpdate& StageOnly() {
+    stage_only_ = true;
+    return *this;
+  }
+
+  /// \brief Configure an executor for manifest planning work.
+  ///
+  /// \param executor Executor to use while planning manifests.
+  /// \return This snapshot update for method chaining.
+  SnapshotUpdate& ScanManifestsWith(Executor& executor) {
+    plan_executor_ = std::ref(executor);
+    return *this;
+  }
+
+  /// \brief Perform operations on a particular branch.
+  ///
+  /// \param branch The name of a SnapshotRef of type branch.
+  /// \return This snapshot update for method chaining.
+  SnapshotUpdate& ToBranch(const std::string& branch) {
+    if (branch.empty()) [[unlikely]] {
+      AddError(ErrorKind::kInvalidArgument, "Branch name cannot be empty");
+      return *this;
+    }
+
+    if (auto ref_it = base().refs.find(branch); ref_it != base().refs.end()) {
+      if (ref_it->second->type() != SnapshotRefType::kBranch) {
+        AddError(ErrorKind::kInvalidArgument,
+                 "{} is a tag, not a branch. Tags cannot be targets for "
+                 "producing snapshots",
+                 branch);
+        return *this;
+      }
+    }
+
+    target_branch_ = branch;
+    return *this;
+  }
+
+  /// \brief Set a summary property in the snapshot produced by this update.
+  ///
+  /// \param property A String property name.
+  /// \param value A String property value.
+  /// \return This snapshot update for method chaining.
+  SnapshotUpdate& Set(const std::string& property, const std::string& value) {
+    SetSummaryProperty(property, value);
+    return *this;
+  }
+
+  /// \brief Configure an executor and max writer count for writing new manifests.
+  ///
+  /// \param executor Executor to use while writing manifests.
+  /// \param parallelism Maximum number of concurrent manifest writers.
+  /// \return This snapshot update for method chaining.
+  SnapshotUpdate& WriteManifestsWith(Executor& executor, int32_t parallelism) {
+    if (parallelism <= 0) [[unlikely]] {
+      AddError(ErrorKind::kInvalidArgument,
+               "Manifest write parallelism must be greater than 0, but was: {}",
+               parallelism);
+      return *this;
+    }
+
+    write_manifest_executor_ = std::ref(executor);
+    write_manifest_parallelism_ = parallelism;
+    return *this;
+  }
+#endif  // C++23
 
   /// \brief Apply the update's changes to create a new snapshot.
   ///
diff --git a/src/iceberg/util/endian.h b/src/iceberg/util/endian.h
index 8aa559f40..81f1a40e0 100644
--- a/src/iceberg/util/endian.h
+++ b/src/iceberg/util/endian.h
@@ -21,14 +21,43 @@
 
 #include <bit>
 #include <concepts>
+#include <cstddef>
 #include <cstdint>
 #include <cstring>
+#include <type_traits>
 
 /// \file iceberg/util/endian.h
 /// \brief Endianness conversion utilities
 
 namespace iceberg {
 
+namespace internal {
+
+// std::byteswap is C++23 and this header is public. GCC and Clang provide the same
+// swap as builtins, which are usable in constant expressions and compile to a
+// single instruction at any optimization level; other compilers reverse the bytes
+// by hand.
+template <std::unsigned_integral T>
+constexpr T ByteSwapUnsigned(T value) {
+#if defined(__GNUC__) || defined(__clang__)
+  if constexpr (sizeof(T) == sizeof(uint16_t)) {
+    return static_cast<T>(__builtin_bswap16(value));
+  } else if constexpr (sizeof(T) == sizeof(uint32_t)) {
+    return static_cast<T>(__builtin_bswap32(value));
+  } else if constexpr (sizeof(T) == sizeof(uint64_t)) {
+    return static_cast<T>(__builtin_bswap64(value));
+  }
+#endif
+  T swapped{0};
+  for (size_t byte = 0; byte < sizeof(T); ++byte) {
+    swapped = static_cast<T>(swapped << 8) | static_cast<T>(value & 0xFF);
+    value = static_cast<T>(value >> 8);
+  }
+  return swapped;
+}
+
+}  // namespace internal
+
 /// \brief Concept for values that can be converted to/from another endian format.
 template <typename T>
 concept EndianConvertible = std::is_arithmetic_v<T>;
@@ -40,14 +69,15 @@ constexpr T ByteSwap(T value) {
   if constexpr (sizeof(T) <= 1) {
     return value;
   } else if constexpr (std::is_integral_v<T>) {
-    return std::byteswap(value);
+    return static_cast<T>(
+        internal::ByteSwapUnsigned(static_cast<std::make_unsigned_t<T>>(value)));
   } else if constexpr (std::is_floating_point_v<T>) {
     if constexpr (sizeof(T) == sizeof(uint16_t)) {
-      return std::bit_cast<T>(std::byteswap(std::bit_cast<uint16_t>(value)));
+      return std::bit_cast<T>(internal::ByteSwapUnsigned(std::bit_cast<uint16_t>(value)));
     } else if constexpr (sizeof(T) == sizeof(uint32_t)) {
-      return std::bit_cast<T>(std::byteswap(std::bit_cast<uint32_t>(value)));
+      return std::bit_cast<T>(internal::ByteSwapUnsigned(std::bit_cast<uint32_t>(value)));
     } else if constexpr (sizeof(T) == sizeof(uint64_t)) {
-      return std::bit_cast<T>(std::byteswap(std::bit_cast<uint64_t>(value)));
+      return std::bit_cast<T>(internal::ByteSwapUnsigned(std::bit_cast<uint64_t>(value)));
     } else {
       static_assert(sizeof(T) == 0,
                     "Unsupported floating-point size for endian conversion.");
diff --git a/src/iceberg/util/error_collector.h b/src/iceberg/util/error_collector.h
index 7e8ab218b..85f652cbc 100644
--- a/src/iceberg/util/error_collector.h
+++ b/src/iceberg/util/error_collector.h
@@ -48,7 +48,8 @@ namespace iceberg {
 #define ICEBERG_BUILDER_ASSIGN_OR_RETURN_WITH_ERROR_IMPL(result_name, lhs, rexpr, ...) \
   auto&& result_name = (rexpr);                                                        \
   if (!result_name) [[unlikely]] {                                                     \
-    return AddError(ErrorKind::kInvalidArgument, __VA_ARGS__);                         \
+    AddError(ErrorKind::kInvalidArgument, __VA_ARGS__);                                \
+    return *this;                                                                      \
   }                                                                                    \
   lhs = std::move(result_name.value());
 
@@ -56,11 +57,12 @@ namespace iceberg {
   ICEBERG_BUILDER_ASSIGN_OR_RETURN_WITH_ERROR_IMPL(                  \
       ICEBERG_ASSIGN_OR_RAISE_NAME(result_, __COUNTER__), lhs, rexpr, __VA_ARGS__)
 
-#define ICEBERG_BUILDER_CHECK(expr, ...)                         \
-  do {                                                           \
-    if (!(expr)) [[unlikely]] {                                  \
-      return AddError(ErrorKind::kInvalidArgument, __VA_ARGS__); \
-    }                                                            \
+#define ICEBERG_BUILDER_CHECK(expr, ...)                  \
+  do {                                                    \
+    if (!(expr)) [[unlikely]] {                           \
+      AddError(ErrorKind::kInvalidArgument, __VA_ARGS__); \
+      return *this;                                       \
+    }                                                     \
   } while (false)
 
 /// \brief Base class for collecting errors in the builder pattern.
@@ -75,7 +77,8 @@ namespace iceberg {
 ///    public:
 ///     MyBuilder& SetValue(int val) {
 ///       if (val < 0) {
-///         return AddError(ErrorKind::kInvalidArgument, "Value must be non-negative");
+///         AddError(ErrorKind::kInvalidArgument, "Value must be non-negative");
+///         return *this;
 ///       }
 ///       value_ = val;
 ///       return *this;
@@ -101,6 +104,13 @@ class ICEBERG_EXPORT ErrorCollector {
   ErrorCollector(const ErrorCollector&) = default;
   ErrorCollector& operator=(const ErrorCollector&) = default;
 
+// C++23 uses deducing `this` so that `return AddError(...)` keeps returning the
+// derived builder type. C++20 exposes the same overloads returning ErrorCollector&,
+// because preserving the derived type would require making the builders CRTP. Keyed
+// on the language version rather than __cpp_explicit_this_parameter, which Apple
+// clang does not define, and compared with "> 202002L" because MSVC's
+// /std:c++latest only promises a value above 202002L.
+#if __cplusplus > 202002L || (defined(_MSVC_LANG) && _MSVC_LANG > 202002L)
   /// \brief Add a specific error and return reference to derived class
   ///
   /// \param self Deduced reference to the derived class instance
@@ -138,10 +148,42 @@ class ICEBERG_EXPORT ErrorCollector {
   /// \param self Deduced reference to the derived class instance
   /// \param err The unexpected result containing the error to add
   /// \return Reference to the derived class for method chaining
-  auto& AddError(this auto& self, std::unexpected<Error> err) {
+  auto& AddError(this auto& self, unexpected<Error> err) {
     self.errors_.push_back(std::move(err.error()));
     return self;
   }
+#else
+  /// \brief Add a specific error
+  ///
+  /// \param kind The kind of error
+  /// \param fmt The format string
+  /// \param args The arguments to format the message
+  /// \return This error collector for method chaining
+  template <typename... Args>
+  ErrorCollector& AddError(ErrorKind kind, const std::format_string<Args...> fmt,
+                           Args&&... args) {
+    errors_.emplace_back(kind, std::format(fmt, std::forward<Args>(args)...));
+    return *this;
+  }
+
+  /// \brief Add an existing error object
+  ///
+  /// \param err The error to add
+  /// \return This error collector for method chaining
+  ErrorCollector& AddError(Error err) {
+    errors_.push_back(std::move(err));
+    return *this;
+  }
+
+  /// \brief Add an unexpected result's error
+  ///
+  /// \param err The unexpected result containing the error to add
+  /// \return This error collector for method chaining
+  ErrorCollector& AddError(unexpected<Error> err) {
+    errors_.push_back(std::move(err.error()));
+    return *this;
+  }
+#endif  // C++23
 
   /// \brief Check if any errors have been collected
   ///
diff --git a/src/iceberg/util/macros.h b/src/iceberg/util/macros.h
index 400573d8b..ca481a939 100644
--- a/src/iceberg/util/macros.h
+++ b/src/iceberg/util/macros.h
@@ -29,7 +29,7 @@
 
 #define ICEBERG_RETURN_UNEXPECTED(expr)                       \
   if (auto&& result_name = expr; !result_name) [[unlikely]] { \
-    return std::unexpected<Error>(result_name.error());       \
+    return iceberg::unexpected<Error>(result_name.error());   \
   }
 
 #define ICEBERG_ASSIGN_OR_RAISE_IMPL(result_name, lhs, rexpr) \
diff --git a/src/iceberg/util/stream.h b/src/iceberg/util/stream.h
index 97ab07be1..fc01e98c0 100644
--- a/src/iceberg/util/stream.h
+++ b/src/iceberg/util/stream.h
@@ -68,7 +68,7 @@ class Stream {
   /// terminal result without invoking NextImpl().
   Result<std::optional<T>> Next() {
     if (error_.has_value()) {
-      return std::unexpected(*error_);
+      return unexpected(*error_);
     }
     if (finished_) {
       return std::nullopt;
@@ -90,7 +90,7 @@ class Stream {
       while (true) {
         auto result = Next();
         if (!result.has_value()) {
-          return std::unexpected(std::move(result.error()));
+          return unexpected(std::move(result.error()));
         }
         auto& value = result.value();
         if (!value.has_value()) {
diff --git a/src/iceberg/util/string_util.h b/src/iceberg/util/string_util.h
index 8202e60a3..4c5b4d342 100644
--- a/src/iceberg/util/string_util.h
+++ b/src/iceberg/util/string_util.h
@@ -36,6 +36,7 @@
 
 #include "iceberg/iceberg_export.h"
 #include "iceberg/result.h"
+#include "iceberg/util/unreachable.h"
 
 namespace iceberg {
 
@@ -70,8 +71,12 @@ class ICEBERG_EXPORT StringUtils {
   /// simple case mapping would be wrong for some letters (e.g. "ß" (U+00DF) would stay
   /// unchanged instead of becoming "SS"), and no caller needs it.
   static std::string ToUpper(std::string_view str) {
-    return str | std::ranges::views::transform(ToUpperAscii) |
-           std::ranges::to<std::string>();
+    std::string upper;
+    upper.reserve(str.size());
+    for (char ch : str) {
+      upper.push_back(ToUpperAscii(ch));
+    }
+    return upper;
   }
 
   /// \brief Case-insensitive equality using Unicode simple (1:1) case mapping.
@@ -132,7 +137,7 @@ class ICEBERG_EXPORT StringUtils {
       return InvalidArgument("Failed to parse {} from string '{}': value out of range",
                              typeid(T).name(), str);
     }
-    std::unreachable();
+    Unreachable();
   }
 
   /// \brief Decode a hex string (upper or lower case) into bytes.
diff --git a/src/iceberg/util/task_group.h b/src/iceberg/util/task_group.h
index 3d345c240..5be18ab7d 100644
--- a/src/iceberg/util/task_group.h
+++ b/src/iceberg/util/task_group.h
@@ -73,26 +73,30 @@ class ICEBERG_TEMPLATE_CLASS_EXPORT TaskGroup {
     requires(kRetryEnabled)
       : retry_config_(std::move(retry_config)) {}
 
-  auto&& SetExecutor(this auto&& self, OptionalExecutor executor) {
-    self.executor_ = std::move(executor);
-    return std::forward<decltype(self)>(self);
+  TaskGroup& SetExecutor(OptionalExecutor executor) & {
+    executor_ = std::move(executor);
+    return *this;
+  }
+
+  TaskGroup&& SetExecutor(OptionalExecutor executor) && {
+    executor_ = std::move(executor);
+    return std::move(*this);
   }
 
   template <typename F>
     requires((!kRetryEnabled && internal::OnceStatusTask<F>) ||
              (kRetryEnabled && internal::RetryableStatusTask<F>))
-  auto&& Submit(this auto&& self, F&& task) {
-    self.tasks_.emplace_back([&] {
-      if constexpr (!kRetryEnabled) {
-        return std::forward<F>(task);
-      } else {
-        return [retry_config = self.retry_config_,
-                task = std::forward<F>(task)]() mutable -> Status {
-          return RetryRunner<RetryPolicy>(retry_config).Run(task);
-        };
-      }
-    }());
-    return std::forward<decltype(self)>(self);
+  TaskGroup& Submit(F&& task) & {
+    AddTask(std::forward<F>(task));
+    return *this;
+  }
+
+  template <typename F>
+    requires((!kRetryEnabled && internal::OnceStatusTask<F>) ||
+             (kRetryEnabled && internal::RetryableStatusTask<F>))
+  TaskGroup&& Submit(F&& task) && {
+    AddTask(std::forward<F>(task));
+    return std::move(*this);
   }
 
   Status Run() && {
@@ -103,6 +107,21 @@ class ICEBERG_TEMPLATE_CLASS_EXPORT TaskGroup {
   }
 
  private:
+  // Shared by both Submit overloads.
+  template <typename F>
+  void AddTask(F&& task) {
+    tasks_.emplace_back([&] {
+      if constexpr (!kRetryEnabled) {
+        return std::forward<F>(task);
+      } else {
+        return [retry_config = retry_config_,
+                task = std::forward<F>(task)]() mutable -> Status {
+          return RetryRunner<RetryPolicy>(retry_config).Run(task);
+        };
+      }
+    }());
+  }
+
   std::vector<FnOnce<Status()>> tasks_;
   OptionalExecutor executor_;
   [[no_unique_address]] RetryConfigStorage retry_config_;
diff --git a/src/iceberg/util/unreachable.h b/src/iceberg/util/unreachable.h
new file mode 100644
index 000000000..428426f56
--- /dev/null
+++ b/src/iceberg/util/unreachable.h
@@ -0,0 +1,39 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#pragma once
+
+/// \file iceberg/util/unreachable.h
+/// \brief Portable stand-in for std::unreachable.
+
+namespace iceberg {
+
+/// \brief Marks a branch the program can never take.
+///
+/// Reaching it is undefined behavior, as with std::unreachable. That is C++23,
+/// so it cannot appear in a header a C++20 consumer includes.
+[[noreturn]] inline void Unreachable() {
+#if defined(_MSC_VER) && !defined(__clang__)
+  __assume(false);
+#else
+  __builtin_unreachable();
+#endif
+}
+
+}  // namespace iceberg
diff --git a/src/iceberg/util/visit_type.h b/src/iceberg/util/visit_type.h
index 73fbbb5fd..c49361431 100644
--- a/src/iceberg/util/visit_type.h
+++ b/src/iceberg/util/visit_type.h
@@ -29,6 +29,7 @@
 #include "iceberg/result.h"
 #include "iceberg/type.h"
 #include "iceberg/util/checked_cast.h"
+#include "iceberg/util/unreachable.h"
 #include "iceberg/util/visitor_generate.h"
 
 namespace iceberg {
@@ -94,7 +95,7 @@ inline auto VisitType(const Type& type, VISITOR&& visitor, ARGS&&... args)
   switch (type.type_id()) {
     ICEBERG_GENERATE_FOR_ALL_TYPES(TYPE_VISIT_INLINE);
     default:
-      std::unreachable();
+      Unreachable();
   }
 }