Fix unwrap_and_invoke for functions returning void. Fixes #145 .

Update .drone.jsonnet
Add windows-cmake-use to ci.yml
2026-06-11 19:51:11 +02:00 · 2026-05-31 14:34:01 +03:00 · 2026-05-01 16:45:55 +03:00 · 2026-04-30 20:31:59 +03:00 · 2026-04-30 19:36:42 +03:00 · 2026-04-30 19:29:54 +03:00
36 changed files with 1912 additions and 289 deletions
@@ -239,19 +239,26 @@ local windows_pipeline(name, image, environment, arch = "amd64") =
    ),

    linux_pipeline(
-        "Linux 25.04 GCC 15 UBSAN",
-        "cppalliance/droneubuntu2504:1",
+        "Linux 26.04 GCC 15 UBSAN",
+        "cppalliance/droneubuntu2604:1",
        { TOOLSET: 'gcc', COMPILER: 'g++-15', CXXSTD: '11,14,17,20,23,2c' } + ubsan,
        "g++-15-multilib",
    ),

    linux_pipeline(
-        "Linux 25.04 GCC 15 ASAN",
-        "cppalliance/droneubuntu2504:1",
+        "Linux 26.04 GCC 15 ASAN",
+        "cppalliance/droneubuntu2604:1",
        { TOOLSET: 'gcc', COMPILER: 'g++-15', CXXSTD: '11,14,17,20,23,2c' } + asan,
        "g++-15-multilib",
    ),

+    linux_pipeline(
+        "Linux 26.04 GCC 16",
+        "cppalliance/droneubuntu2604:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-16', CXXSTD: '11,14,17,20,23,2c' },
+        "g++-16-multilib",
+    ),
+
    linux_pipeline(
        "Linux 16.04 Clang 3.5",
        "cppalliance/droneubuntu1604:1",
@@ -280,6 +287,27 @@ local windows_pipeline(name, image, environment, arch = "amd64") =
        "clang-3.8",
    ),

+    linux_pipeline(
+        "Linux 18.04 Clang 3.9",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-3.9', CXXSTD: '11,14' },
+        "clang-3.9",
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 Clang 4.0",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-4.0', CXXSTD: '11,14' },
+        "clang-4.0",
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 Clang 5.0",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-5.0', CXXSTD: '11,14' },
+        "clang-5.0",
+    ),
+
    linux_pipeline(
        "Linux 22.04 Clang 13",
        "cppalliance/droneubuntu2204:1",
@@ -316,54 +344,47 @@ local windows_pipeline(name, image, environment, arch = "amd64") =
    ),

    linux_pipeline(
-        "Linux 24.04 Clang 18 UBSAN",
+        "Linux 24.04 Clang 18",
        "cppalliance/droneubuntu2404:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-18', CXXSTD: '11,14,17,20,2b' } + ubsan,
+        { TOOLSET: 'clang', COMPILER: 'clang++-18', CXXSTD: '11,14,17,20,2b' },
        "clang-18",
    ),

    linux_pipeline(
-        "Linux 24.04 Clang 18 ASAN",
+        "Linux 24.04 Clang 19",
        "cppalliance/droneubuntu2404:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-18', CXXSTD: '11,14,17,20,2b' } + asan,
-        "clang-18",
-    ),
-
-    linux_pipeline(
-        "Linux 24.04 Clang 19 UBSAN",
-        "cppalliance/droneubuntu2404:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-19', CXXSTD: '11,14,17,20,2b' } + ubsan,
+        { TOOLSET: 'clang', COMPILER: 'clang++-19', CXXSTD: '11,14,17,20,2b' },
        "clang-19",
    ),

    linux_pipeline(
-        "Linux 24.04 Clang 19 ASAN",
+        "Linux 24.04 Clang 20",
        "cppalliance/droneubuntu2404:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-19', CXXSTD: '11,14,17,20,2b' } + asan,
-        "clang-19",
-    ),
-
-    linux_pipeline(
-        "Linux 24.04 Clang 20 UBSAN",
-        "cppalliance/droneubuntu2404:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-20', CXXSTD: '11,14,17,20,23,2c' } + ubsan,
+        { TOOLSET: 'clang', COMPILER: 'clang++-20', CXXSTD: '11,14,17,20,23,2c' },
        "clang-20",
    ),

    linux_pipeline(
-        "Linux 24.04 Clang 20 ASAN",
-        "cppalliance/droneubuntu2404:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-20', CXXSTD: '11,14,17,20,23,2c' } + asan,
-        "clang-20",
-    ),
-
-    linux_pipeline(
-        "Linux 25.10 Clang 21",
-        "cppalliance/droneubuntu2510:1",
+        "Linux 26.04 Clang 21",
+        "cppalliance/droneubuntu2604:1",
        { TOOLSET: 'clang', COMPILER: 'clang++-21', CXXSTD: '11,14,17,20,23,2c' },
        "clang-21",
    ),

+    linux_pipeline(
+        "Linux 26.04 Clang 22 UBSAN",
+        "cppalliance/droneubuntu2604:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-22', CXXSTD: '11,14,17,20,23,2c' } + ubsan,
+        "clang-22",
+    ),
+
+    linux_pipeline(
+        "Linux 26.04 Clang 22 ASAN",
+        "cppalliance/droneubuntu2604:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-22', CXXSTD: '11,14,17,20,23,2c' } + asan,
+        "clang-22",
+    ),
+
    macos_pipeline(
        "MacOS 10.15 Xcode 12.2 UBSAN",
        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '11,14,1z' } + ubsan,
@@ -17,25 +17,11 @@ jobs:
      fail-fast: false
      matrix:
        include:
-          - toolset: gcc-4.8
-            cxxstd: "11"
-            container: ubuntu:18.04
-            os: ubuntu-latest
-            install: g++-4.8
-          - toolset: gcc-5
-            cxxstd: "11,14,1z"
-            container: ubuntu:18.04
-            os: ubuntu-latest
-            install: g++-5
-          - toolset: gcc-6
-            cxxstd: "11,14,1z"
-            container: ubuntu:18.04
-            os: ubuntu-latest
-            install: g++-6
          - toolset: gcc-7
            cxxstd: "11,14,17"
-            container: ubuntu:18.04
+            container: ubuntu:20.04
            os: ubuntu-latest
+            install: g++-7
          - toolset: gcc-8
            cxxstd: "11,14,17,2a"
            container: ubuntu:20.04
@@ -52,10 +38,12 @@ jobs:
            install: g++-10
          - toolset: gcc-11
            cxxstd: "11,14,17,2a"
-            os: ubuntu-22.04
+            container: ubuntu:22.04
+            os: ubuntu-latest
          - toolset: gcc-12
            cxxstd: "11,14,17,20,2b"
-            os: ubuntu-22.04
+            container: ubuntu:22.04
+            os: ubuntu-latest
            install: g++-12
          - toolset: gcc-13
            cxxstd: "11,14,17,20,2b"
@@ -69,27 +57,14 @@ jobs:
            install: g++-14
          - toolset: gcc-15
            cxxstd: "11,14,17,20,23,2c"
-            container: ubuntu:25.04
+            container: ubuntu:26.04
            os: ubuntu-latest
            install: g++-15
-          - toolset: clang
-            compiler: clang++-3.9
-            cxxstd: "11,14"
-            container: ubuntu:18.04
+          - toolset: gcc-16
+            cxxstd: "11,14,17,20,23,2c"
+            container: ubuntu:26.04
            os: ubuntu-latest
-            install: clang-3.9
-          - toolset: clang
-            compiler: clang++-4.0
-            cxxstd: "11,14"
-            container: ubuntu:18.04
-            os: ubuntu-latest
-            install: clang-4.0
-          - toolset: clang
-            compiler: clang++-5.0
-            cxxstd: "11,14,1z"
-            container: ubuntu:18.04
-            os: ubuntu-latest
-            install: clang-5.0
+            install: g++-16
          - toolset: clang
            compiler: clang++-6.0
            cxxstd: "11,14,17"
@@ -198,9 +173,16 @@ jobs:
            compiler: clang++-21
            cxxstd: "11,14,17,20,23,2c"
            stdlib: "native,libc++"
-            container: ubuntu:25.10
+            container: ubuntu:26.04
            os: ubuntu-latest
            install: clang-21 libc++-21-dev libc++abi-21-dev
+          - toolset: clang
+            compiler: clang++-22
+            cxxstd: "11,14,17,20,23,2c"
+            stdlib: "native,libc++"
+            container: ubuntu:26.04
+            os: ubuntu-latest
+            install: clang-22 libc++-22-dev libc++abi-22-dev
          - toolset: clang
            cxxstd: "11,14,17,20,2b"
            os: macos-14
@@ -212,12 +194,7 @@ jobs:
            os: macos-26

    runs-on: ${{matrix.os}}
-
-    container:
-      image: ${{matrix.container}}
-      volumes:
-        - /node20217:/node20217:rw,rshared
-        - ${{ startsWith(matrix.container, 'ubuntu:1') && '/node20217:/__e/node20:ro,rshared' || ' ' }}
+    container: ${{matrix.container}}

    defaults:
      run:
@@ -230,14 +207,7 @@ jobs:
          apt-get update
          apt-get -y install sudo python3 git g++ curl xz-utils

-      - name: Install nodejs20glibc2.17
-        if: ${{ startsWith( matrix.container, 'ubuntu:1' ) }}
-        run: |
-          curl -LO https://archives.boost.io/misc/node/node-v20.9.0-linux-x64-glibc-217.tar.xz
-          tar -xf node-v20.9.0-linux-x64-glibc-217.tar.xz --strip-components 1 -C /node20217
-          ldd /__e/node20/bin/node
-
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6

      - name: Install packages
        if: matrix.install
@@ -286,19 +256,23 @@ jobs:
            cxxstd: "14,17,20,latest"
            addrmd: 32,64
            os: windows-2022
+          - toolset: msvc-14.5
+            cxxstd: "14,17,20,latest"
+            addrmd: 32,64
+            os: windows-2025-vs2026
          - toolset: clang-win
            cxxstd: "14,17,20,latest"
            addrmd: 32,64
-            os: windows-2022
+            os: windows-latest
          - toolset: gcc
            cxxstd: "11,14,17,2a"
            addrmd: 64
-            os: windows-2022
+            os: windows-latest

    runs-on: ${{matrix.os}}

    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6

      - name: Setup Boost
        shell: cmd
@@ -339,7 +313,7 @@ jobs:
    runs-on: ${{matrix.os}}

    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6

      - name: Install packages
        if: matrix.install
@@ -384,7 +358,7 @@ jobs:
    runs-on: ${{matrix.os}}

    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6

      - name: Install packages
        if: matrix.install
@@ -439,7 +413,7 @@ jobs:
    runs-on: ${{matrix.os}}

    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6

      - name: Install packages
        if: matrix.install
@@ -481,6 +455,57 @@ jobs:
          cd ../boost-root/__build__
          ctest --output-on-failure --no-tests=error

+  posix-cmake-use:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-latest
+          - os: macos-latest
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Install packages
+        if: matrix.install
+        run: sudo apt-get -y install ${{matrix.install}}
+
+      - name: Setup Boost
+        run: |
+          echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
+          LIBRARY=${GITHUB_REPOSITORY#*/}
+          echo LIBRARY: $LIBRARY
+          echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
+          echo GITHUB_BASE_REF: $GITHUB_BASE_REF
+          echo GITHUB_REF: $GITHUB_REF
+          REF=${GITHUB_BASE_REF:-$GITHUB_REF}
+          REF=${REF#refs/heads/}
+          echo REF: $REF
+          BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
+          echo BOOST_BRANCH: $BOOST_BRANCH
+          cd ..
+          git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
+          ./bootstrap.sh
+          ./b2 -d0 headers
+
+      - name: Install Boost --with-library
+        run: |
+          cd ../boost-root
+          ./b2 -j3 --with-$LIBRARY --prefix=$HOME/.local install
+
+      - name: Use the installed library
+        run: |
+          cd ../boost-root/libs/$LIBRARY/test/cmake_install_test && mkdir __build__ && cd __build__
+          cmake -DCMAKE_INSTALL_PREFIX=~/.local ..
+          cmake --build .
+          ctest --output-on-failure --no-tests=error
+
  windows-cmake-subdir:
    strategy:
      fail-fast: false
@@ -491,7 +516,7 @@ jobs:
    runs-on: ${{matrix.os}}

    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6

      - name: Setup Boost
        shell: cmd
@@ -539,7 +564,7 @@ jobs:
    runs-on: ${{matrix.os}}

    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6

      - name: Setup Boost
        shell: cmd
@@ -605,7 +630,7 @@ jobs:
    runs-on: ${{matrix.os}}

    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6

      - name: Setup Boost
        shell: cmd
@@ -657,3 +682,58 @@ jobs:
        run: |
          cd ../boost-root/__build__
          ctest --output-on-failure --no-tests=error -C Release
+
+  windows-cmake-use:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: windows-latest
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Setup Boost
+        shell: cmd
+        run: |
+          echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
+          for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
+          echo LIBRARY: %LIBRARY%
+          echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
+          echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
+          echo GITHUB_REF: %GITHUB_REF%
+          if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
+          set BOOST_BRANCH=develop
+          for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
+          echo BOOST_BRANCH: %BOOST_BRANCH%
+          cd ..
+          git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" %LIBRARY%
+          cmd /c bootstrap
+          b2 -d0 headers
+
+      - name: Install Boost --with-library
+        shell: cmd
+        run: |
+          cd ../boost-root
+          b2 -j3 --with-%LIBRARY% install
+
+      - name: Use the installed library (Debug)
+        shell: cmd
+        run: |
+          cd ../boost-root/libs/%LIBRARY%/test/cmake_install_test && mkdir __build__ && cd __build__
+          cmake -DBoost_ROOT=C:/Boost ..
+          cmake --build . --config Debug
+          ctest --output-on-failure --no-tests=error -C Debug
+
+      - name: Use the installed library (Release)
+        shell: cmd
+        run: |
+          cd ../boost-root/libs/%LIBRARY%/test/cmake_install_test/__build__
+          cmake --build . --config Release
+          ctest --output-on-failure --no-tests=error -C Release
@@ -15,6 +15,11 @@ https://www.boost.org/LICENSE_1_0.txt
 * A CMake config file is now installed, even though the library is header-only. This
  avoids breaking third-party `CMakeLists.txt` files that contain
  `find_package(Boost COMPONENTS system ...)`.
+* `error_code` is now even more `constexpr` under {cpp}20 and later.
+* Added `unsafe_value` to `result`.
+* Changed `result<>::operator*` and `result<>::operator\->` to throw when `!has_value()`,
+  instead of having that as a precondition. The old behavior is now spelled `unsafe_value()`.
+* Added `boost/system/unwrap_and_invoke.hpp`.

 ## Changes in Boost 1.89

@@ -1670,15 +1670,20 @@ public:
    constexpr T const&& value( boost::source_location const & loc =
      BOOST_CURRENT_LOCATION ) const&& ;

+    constexpr T* operator->();
+    constexpr T const* operator->() const;
+
+    constexpr T& operator*() &;
+    constexpr T const& operator*() const &;
+    constexpr T&& operator*() &&;
+    constexpr T const&& operator*() const &&;
+
    // unchecked value access

-    constexpr T* operator->() noexcept;
-    constexpr T const* operator->() const noexcept;
-
-    constexpr T& operator*() & noexcept;
-    constexpr T const& operator*() const & noexcept;
-    constexpr T&& operator*() && noexcept;
-    constexpr T const&& operator*() const && noexcept;
+    constexpr T& unsafe_value() & ;
+    constexpr T const& unsafe_value() const& ;
+    constexpr T&& unsafe_value() && ;
+    constexpr T const&& unsafe_value() const&& ;

    // error access

@@ -1840,39 +1845,50 @@ Effects: ::
  calls `throw_exception_from_error`, passing it a reference to
  the held error, and `loc`.

+```
+constexpr T* operator->();
+constexpr T const* operator->() const;
+```
+[none]
+* {blank}
+
+Returns: ::
+  `&value()`.
+
+```
+constexpr T& operator*() &;
+constexpr T const& operator*() const &;
+```
+[none]
+* {blank}
+
+Returns: ::
+  `value()`.
+
+```
+constexpr T&& operator*() &&;
+constexpr T const&& operator*() const &&;
+```
+[none]
+* {blank}
+
+Returns: ::
+  `std::move( value() )`.
+
 #### Unchecked Value Access

 ```
-constexpr T* operator->() noexcept;
-constexpr T const* operator->() const noexcept;
-```
-[none]
-* {blank}
-+
-Returns: ::
-  If `*this` holds a value, a pointer to it. Otherwise, `nullptr`.
-
-```
-constexpr T& operator*() & noexcept;
-constexpr T const& operator*() const & noexcept;
+constexpr T& unsafe_value() &;
+constexpr T const& unsafe_value() const &;
+constexpr T&& unsafe_value() &&;
+constexpr T const&& unsafe_value() const &&;
 ```
 [none]
 * {blank}
 +
 Requires: :: `*this` holds a value.
 Returns: ::
-  `*operator\->()`.
-
-```
-constexpr T&& operator*() && noexcept;
-constexpr T const&& operator*() const && noexcept;
-```
-[none]
-* {blank}
-+
-Requires: :: `*this` holds a value.
-Returns: ::
-  `std::move( *operator\->() )`.
+  A reference to the held value.

 #### Error Access

@@ -2000,12 +2016,14 @@ public:
    constexpr void value( boost::source_location const & loc =
      BOOST_CURRENT_LOCATION ) const;

+    constexpr void* operator->();
+    constexpr void const* operator->() const;
+
+    constexpr void operator*() const;
+
    // unchecked value access

-    constexpr void* operator->() noexcept;
-    constexpr void const* operator->() const noexcept;
-
-    constexpr void operator*() const noexcept;
+    constexpr void unsafe_value() const;

    // error access

@@ -2138,8 +2156,6 @@ Effects: ::
  If `*this` doesn't hold a value, calls `throw_exception_from_error`,
  passing it a reference to the held error, and `loc`.

-#### Unchecked Value Access
-
 ```
 constexpr void* operator->() noexcept;
 constexpr void const* operator->() const noexcept;
@@ -2147,8 +2163,8 @@ constexpr void const* operator->() const noexcept;
 [none]
 * {blank}
 +
-Returns: ::
-  If `*this` holds a value, a pointer to it. Otherwise, `nullptr`.
+Effects: ::
+  If `*this` holds a value, returns a pointer to it. Otherwise, calls `value()`.

 ```
 constexpr void operator*() const noexcept;
@@ -2156,6 +2172,17 @@ constexpr void operator*() const noexcept;
 [none]
 * {blank}
 +
+Returns: ::
+  `value()`.
+
+#### Unchecked Value Access
+
+```
+constexpr void unsafe_value() const;
+```
+[none]
+* {blank}
+
 Requires: :: `*this` holds a value.
 Effects: ::
  none.
@@ -2285,10 +2312,12 @@ public:
    constexpr U& value( boost::source_location const & loc =
      BOOST_CURRENT_LOCATION ) const;

+    constexpr U* operator->() const;
+    constexpr U& operator*() const;
+
    // unchecked value access

-    constexpr U* operator->() const noexcept;
-    constexpr U& operator*() const noexcept;
+    constexpr U& unsafe_value() const;

    // error access

@@ -2422,26 +2451,35 @@ Effects: ::
  calls `throw_exception_from_error`, passing it a reference to
  the held error, and `loc`.

-#### Unchecked Value Access
-
 ```
-constexpr U* operator->() const noexcept;
+constexpr U* operator->() const;
 ```
 [none]
 * {blank}
 +
 Returns: ::
-  If `*this` holds a reference, a pointer to its referent. Otherwise, `nullptr`.
+  `&value()`.

 ```
-constexpr U& operator*() const noexcept;
+constexpr U& operator*() const;
+```
+[none]
+* {blank}
+
+Returns: ::
+  `value()`.
+
+#### Unchecked Value Access
+
+```
+constexpr U& unsafe_value() const;
 ```
 [none]
 * {blank}
 +
 Requires: :: `*this` holds a reference.
 Returns: ::
-  `*operator\->()`.
+  The held reference.

 #### Error Access

@@ -2873,6 +2911,82 @@ Returns: :: `r`.
 Remarks: ::
  Only enabled when `R` is an instance of `result<void, E2>` and `E2` is convertible to `E`.

+## <boost/system/{zwsp}unwrap_and_invoke.hpp>
+
+```
+namespace boost {
+namespace system {
+
+template<class F, class... A>
+auto unwrap_and_invoke( F&& f, A&&... a ) -> result</*...*/>;
+
+template<class T, class... A>
+auto unwrap_and_construct( A&&... a ) -> /*...*/;
+
+} // namespace system
+} // namespace boost
+```
+
+### unwrap_and_invoke
+
+```
+template<class F, class... A>
+auto unwrap_and_invoke( F&& f, A&&... a ) -> result</*...*/>;
+```
+[none]
+* {blank}
+
+Mandates: ::
+At least one of the arguments in `a...` must be an instance of `result`.
+
+All arguments in `a...` that are instances of `result` must have the same error type.
+
+Effects: ::
+If `ai`, one of the arguments in `a...`, is an instance of `result` for which `has_error()` is `true`, returns `ai.error()`.
+
+Otherwise, returns `f(b...)`, where `bi` is `*ai` if `ai` is an instance of `result`, `ai` otherwise.
+
+Remarks: ::
+The return type is `result<R, E>`, where `R` is the type of the application of `f`, and `E` is the common error type of the arguments in `a...` that are instances of `result`.
+
+
+### unwrap_and_construct
+
+```
+template<class T, class... A>
+auto unwrap_and_construct( A&&... a ) -> /*...*/;
+```
+[none]
+* {blank}
+
+Like `unwrap_and_invoke`, but instead of a function object, invokes a constructor of the passed type `T`.
+
+Returns: :: `unwrap_and_invoke(cf, a...)`, where `cf` is a function object such that `cf(args...)` returns `T{args...}` when `T` is an aggregate, `T(args...)` otherwise.
+
+Example: ::
+
+```
+struct JsonValue
+{
+    result<JsonValue const&> at( std::string_view key ) const noexcept;
+};
+
+result<int> int_from_json( JsonValue const& jv ) noexcept;
+
+struct X
+{
+    int a;
+    int b;
+};
+
+result<X> X_from_json( JsonValue const& jv ) noexcept
+{
+    return unwrap_and_construct<X>(
+        jv.at( "a" ) & int_from_json,
+        jv.at( "b" ) & int_from_json );
+}
+```
+
 ## <boost/system.hpp>

 This convenience header includes all the headers previously described.
@@ -10,5 +10,6 @@
 #include <boost/system/error_code.hpp>
 #include <boost/system/system_error.hpp>
 #include <boost/system/result.hpp>
+#include <boost/system/unwrap_and_invoke.hpp>

 #endif // #ifndef BOOST_SYSTEM_HPP_INCLUDED
@@ -0,0 +1,60 @@
+#ifndef BOOST_SYSTEM_DETAIL_IS_AGGREGATE_HPP_INCLUDED
+#define BOOST_SYSTEM_DETAIL_IS_AGGREGATE_HPP_INCLUDED
+
+// Copyright 2026 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/config.hpp>
+#include <type_traits>
+
+#if defined(__has_builtin)
+# if __has_builtin(__is_aggregate)
+#  define BOOST_SYSTEM_HAS_BUILTIN_IS_AGGREGATE
+# endif
+#endif
+
+#if !defined(BOOST_SYSTEM_HAS_BUILTIN_IS_AGGREGATE) && defined(BOOST_CLANG_VERSION) && BOOST_CLANG_VERSION >= 50000
+# define BOOST_SYSTEM_HAS_BUILTIN_IS_AGGREGATE
+#endif
+
+#if !defined(BOOST_SYSTEM_HAS_BUILTIN_IS_AGGREGATE) && defined(BOOST_GCC) && BOOST_GCC >= 70000
+# define BOOST_SYSTEM_HAS_BUILTIN_IS_AGGREGATE
+#endif
+
+#if !defined(BOOST_SYSTEM_HAS_BUILTIN_IS_AGGREGATE) && defined(BOOST_MSVC) && BOOST_MSVC >= 1910
+# define BOOST_SYSTEM_HAS_BUILTIN_IS_AGGREGATE
+#endif
+
+namespace boost
+{
+namespace system
+{
+namespace detail
+{
+
+#if defined(BOOST_SYSTEM_HAS_BUILTIN_IS_AGGREGATE)
+
+template<class T> struct is_aggregate: public std::integral_constant<bool, __is_aggregate(T)>
+{
+};
+
+#elif defined(__cpp_lib_is_aggregate) && __cpp_lib_is_aggregate >= 201703L
+
+template<class T> struct is_aggregate: public std::is_aggregate<T>
+{
+};
+
+#else
+
+template<class T> struct is_aggregate: public std::false_type
+{
+};
+
+#endif
+
+} // namespace detail
+} // namespace system
+} // namespace boost
+
+#endif // #ifndef BOOST_SYSTEM_DETAIL_IS_AGGREGATE_HPP_INCLUDED
@@ -205,7 +205,7 @@ public:
    {
        if( r2 )
        {
-            v_.template emplace<0>( *r2 );
+            v_.template emplace<0>( r2.unsafe_value() );
        }
    }

@@ -224,7 +224,7 @@ public:
    {
        if( r2 )
        {
-            v_.template emplace<0>( std::move( *r2 ) );
+            v_.template emplace<0>( std::move( r2 ).unsafe_value() );
        }
    }

@@ -317,73 +317,133 @@ public:

 #endif

-    // unchecked value access
+    // checked value access

-    BOOST_CXX14_CONSTEXPR T* operator->() noexcept
+    BOOST_CXX14_CONSTEXPR T* operator->()
    {
-        return variant2::get_if<0>( &v_ );
+        return &value();
    }

-    BOOST_CXX14_CONSTEXPR T const* operator->() const noexcept
+    BOOST_CXX14_CONSTEXPR T const* operator->() const
    {
-        return variant2::get_if<0>( &v_ );
+        return &value();
    }

 #if defined( BOOST_NO_CXX11_REF_QUALIFIERS )

-    BOOST_CXX14_CONSTEXPR T& operator*() noexcept
+    BOOST_CXX14_CONSTEXPR T& operator*()
    {
-        BOOST_ASSERT( has_value() );
-        return *operator->();
+        return value();
    }

-    BOOST_CXX14_CONSTEXPR T const& operator*() const noexcept
+    BOOST_CXX14_CONSTEXPR T const& operator*() const
    {
-        BOOST_ASSERT( has_value() );
-        return *operator->();
+        return value();
    }

 #else

-    BOOST_CXX14_CONSTEXPR T& operator*() & noexcept
+    BOOST_CXX14_CONSTEXPR T& operator*() &
    {
-        BOOST_ASSERT( has_value() );
-        return *operator->();
+        return value();
    }

-    BOOST_CXX14_CONSTEXPR T const& operator*() const & noexcept
+    BOOST_CXX14_CONSTEXPR T const& operator*() const &
    {
-        BOOST_ASSERT( has_value() );
-        return *operator->();
+        return value();
    }

    template<class U = T>
        BOOST_CXX14_CONSTEXPR
        typename std::enable_if<std::is_move_constructible<U>::value, T>::type
-        operator*() && noexcept(std::is_nothrow_move_constructible<T>::value)
+        operator*() &&
    {
-        return std::move(**this);
+        return std::move( value() );
    }

    template<class U = T>
        BOOST_CXX14_CONSTEXPR
        typename std::enable_if<!std::is_move_constructible<U>::value, T&&>::type
-        operator*() && noexcept
+        operator*() &&
    {
-        return std::move(**this);
+        return std::move( value() );
    }

    template<class U = T>
        BOOST_CXX14_CONSTEXPR
        typename std::enable_if<std::is_move_constructible<U>::value, T>::type
-        operator*() const && noexcept = delete;
+        operator*() const && = delete;

    template<class U = T>
        BOOST_CXX14_CONSTEXPR
        typename std::enable_if<!std::is_move_constructible<U>::value, T const&&>::type
-        operator*() const && noexcept
+        operator*() const &&
    {
-        return std::move(**this);
+        return std::move( value() );
+    }
+
+#endif
+
+    // unchecked value access
+
+#if defined( BOOST_NO_CXX11_REF_QUALIFIERS )
+
+    BOOST_CXX14_CONSTEXPR T& unsafe_value()
+    {
+        BOOST_ASSERT( has_value() );
+        return *variant2::get_if<0>( &v_ );
+    }
+
+    BOOST_CXX14_CONSTEXPR T const& unsafe_value() const
+    {
+        BOOST_ASSERT( has_value() );
+        return *variant2::get_if<0>( &v_ );
+    }
+
+#else
+
+    BOOST_CXX14_CONSTEXPR T& unsafe_value() &
+    {
+        BOOST_ASSERT( has_value() );
+        return *variant2::get_if<0>( &v_ );
+    }
+
+    BOOST_CXX14_CONSTEXPR T const& unsafe_value() const &
+    {
+        BOOST_ASSERT( has_value() );
+        return *variant2::get_if<0>( &v_ );
+    }
+
+    template<class U = T>
+        BOOST_CXX14_CONSTEXPR
+        typename std::enable_if<std::is_move_constructible<U>::value, T>::type
+        unsafe_value() &&
+    {
+        BOOST_ASSERT( has_value() );
+        return std::move( *variant2::get_if<0>( &v_ ) );
+    }
+
+    template<class U = T>
+        BOOST_CXX14_CONSTEXPR
+        typename std::enable_if<!std::is_move_constructible<U>::value, T&&>::type
+        unsafe_value() &&
+    {
+        BOOST_ASSERT( has_value() );
+        return std::move( *variant2::get_if<0>( &v_ ) );
+    }
+
+    template<class U = T>
+        BOOST_CXX14_CONSTEXPR
+        typename std::enable_if<std::is_move_constructible<U>::value, T>::type
+        unsafe_value() const && = delete;
+
+    template<class U = T>
+        BOOST_CXX14_CONSTEXPR
+        typename std::enable_if<!std::is_move_constructible<U>::value, T const&&>::type
+        unsafe_value() const &&
+    {
+        BOOST_ASSERT( has_value() );
+        return std::move( *variant2::get_if<0>( &v_ ) );
    }

 #endif
@@ -450,7 +510,7 @@ template<class Ch, class Tr, class T, class E> std::basic_ostream<Ch, Tr>& opera
 {
    if( r.has_value() )
    {
-        os << "value:" << *r;
+        os << "value:" << r.unsafe_value();
    }
    else
    {
@@ -581,19 +641,28 @@ public:
        }
    }

+    // checked value access
+
+    BOOST_CXX14_CONSTEXPR void* operator->()
+    {
+        value();
+        return &variant2::unsafe_get<0>( v_ );
+    }
+
+    BOOST_CXX14_CONSTEXPR void const* operator->() const
+    {
+        value();
+        return &variant2::unsafe_get<0>( v_ );
+    }
+
+    BOOST_CXX14_CONSTEXPR void operator*() const
+    {
+        return value();
+    }
+
    // unchecked value access

-    BOOST_CXX14_CONSTEXPR void* operator->() noexcept
-    {
-        return variant2::get_if<0>( &v_ );
-    }
-
-    BOOST_CXX14_CONSTEXPR void const* operator->() const noexcept
-    {
-        return variant2::get_if<0>( &v_ );
-    }
-
-    BOOST_CXX14_CONSTEXPR void operator*() const noexcept
+    BOOST_CXX14_CONSTEXPR void unsafe_value() const
    {
        BOOST_ASSERT( has_value() );
    }
@@ -783,7 +852,7 @@ public:
    {
        if( r2 )
        {
-            this->emplace( *r2 );
+            this->emplace( r2.unsafe_value() );
        }
    }

@@ -818,17 +887,24 @@ public:
        }
    }

-    // unchecked value access
+    // checked value access

-    BOOST_CXX14_CONSTEXPR U* operator->() const noexcept
+    BOOST_CXX14_CONSTEXPR U* operator->() const
    {
-        return has_value()? variant2::unsafe_get<0>( v_ ): 0;
+        return &value();
    }

-    BOOST_CXX14_CONSTEXPR U& operator*() const noexcept
+    BOOST_CXX14_CONSTEXPR U& operator*() const
+    {
+        return value();
+    }
+
+    // unchecked value access
+
+    BOOST_CXX14_CONSTEXPR U& unsafe_value() const
    {
        BOOST_ASSERT( has_value() );
-        return *operator->();
+        return *( has_value()? variant2::unsafe_get<0>( v_ ): 0 );
    }

    // error access
@@ -873,9 +949,9 @@ public:
    // equality

    friend constexpr bool operator==( result const & r1, result const & r2 )
-        noexcept( noexcept( r1 && r2? *r1 == *r2: r1.v_ == r2.v_ ) )
+        noexcept( noexcept( r1 && r2? r1.unsafe_value() == r2.unsafe_value(): r1.v_ == r2.v_ ) )
    {
-        return r1 && r2? *r1 == *r2: r1.v_ == r2.v_;
+        return r1 && r2? r1.unsafe_value() == r2.unsafe_value(): r1.v_ == r2.v_;
    }

    friend constexpr bool operator!=( result const & r1, result const & r2 )
@@ -927,7 +1003,7 @@ operator|( result<T, E> const& r, U&& u )
 {
    if( r )
    {
-        return *r;
+        return r.unsafe_value();
    }
    else
    {
@@ -943,7 +1019,7 @@ operator|( result<T, E>&& r, U&& u )
 {
    if( r )
    {
-        return *std::move( r );
+        return std::move( r ).unsafe_value();
    }
    else
    {
@@ -961,7 +1037,7 @@ T operator|( result<T, E> const& r, F&& f )
 {
    if( r )
    {
-        return *r;
+        return r.unsafe_value();
    }
    else
    {
@@ -977,7 +1053,7 @@ T operator|( result<T, E>&& r, F&& f )
 {
    if( r )
    {
-        return *std::move( r );
+        return std::move( r ).unsafe_value();
    }
    else
    {
@@ -997,7 +1073,7 @@ operator|( result<T&, E> const& r, F&& f )
 {
    if( r )
    {
-        return *r;
+        return r.unsafe_value();
    }
    else
    {
@@ -1016,7 +1092,7 @@ U operator|( result<T, E> const& r, F&& f )
 {
    if( r )
    {
-        return *r;
+        return r.unsafe_value();
    }
    else
    {
@@ -1033,7 +1109,7 @@ U operator|( result<T, E>&& r, F&& f )
 {
    if( r )
    {
-        return *std::move( r );
+        return std::move( r ).unsafe_value();
    }
    else
    {
@@ -1143,7 +1219,7 @@ result<U, E> operator&( result<T, E>& r, F&& f )
    }
    else
    {
-        return compat::invoke( std::forward<F>( f ), *r );
+        return compat::invoke( std::forward<F>( f ), r.unsafe_value() );
    }
 }

@@ -1160,7 +1236,7 @@ result<U, E> operator&( result<T, E> const& r, F&& f )
    }
    else
    {
-        return compat::invoke( std::forward<F>( f ), *r );
+        return compat::invoke( std::forward<F>( f ), r.unsafe_value() );
    }
 }

@@ -1177,7 +1253,7 @@ result<U, E> operator&( result<T, E>&& r, F&& f )
    }
    else
    {
-        return compat::invoke( std::forward<F>( f ), *std::move( r ) );
+        return compat::invoke( std::forward<F>( f ), std::move( r ).unsafe_value() );
    }
 }

@@ -1194,7 +1270,7 @@ result<U, E> operator&( result<T&, E>&& r, F&& f )
    }
    else
    {
-        return compat::invoke( std::forward<F>( f ), *std::move( r ) );
+        return compat::invoke( std::forward<F>( f ), std::move( r ).unsafe_value() );
    }
 }

@@ -1210,7 +1286,7 @@ result<U, E> operator&( result<T, E> const& r, F&& f )
    }
    else
    {
-        compat::invoke( std::forward<F>( f ), *r );
+        compat::invoke( std::forward<F>( f ), r.unsafe_value() );
        return {};
    }
 }
@@ -1227,7 +1303,7 @@ result<U, E> operator&( result<T, E>&& r, F&& f )
    }
    else
    {
-        compat::invoke( std::forward<F>( f ), *std::move( r ) );
+        compat::invoke( std::forward<F>( f ), std::move( r ).unsafe_value() );
        return {};
    }
 }
@@ -1281,7 +1357,7 @@ U operator&( result<T, E>& r, F&& f )
    }
    else
    {
-        return compat::invoke( std::forward<F>( f ), *r );
+        return compat::invoke( std::forward<F>( f ), r.unsafe_value() );
    }
 }

@@ -1298,7 +1374,7 @@ U operator&( result<T, E> const& r, F&& f )
    }
    else
    {
-        return compat::invoke( std::forward<F>( f ), *r );
+        return compat::invoke( std::forward<F>( f ), r.unsafe_value() );
    }
 }

@@ -1315,7 +1391,7 @@ U operator&( result<T, E>&& r, F&& f )
    }
    else
    {
-        return compat::invoke( std::forward<F>( f ), *std::move( r ) );
+        return compat::invoke( std::forward<F>( f ), std::move( r ).unsafe_value() );
    }
 }

@@ -1349,7 +1425,7 @@ result<T, E>& operator&=( result<T, E>& r, F&& f )
 {
    if( r )
    {
-        r = std::forward<F>( f )( *std::move( r ) );
+        r = std::forward<F>( f )( std::move( r ).unsafe_value() );
    }

    return r;
@@ -1381,7 +1457,7 @@ result<T, E>& operator&=( result<T, E>& r, F&& f )
 {
    if( r )
    {
-        r = std::forward<F>( f )( *std::move( r ) );
+        r = std::forward<F>( f )( std::move( r ).unsafe_value() );
    }

    return r;
@@ -0,0 +1,147 @@
+#ifndef BOOST_SYSTEM_UNWRAP_AND_INVOKE_HPP_INCLUDED
+#define BOOST_SYSTEM_UNWRAP_AND_INVOKE_HPP_INCLUDED
+
+// Copyright 2026 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/result.hpp>
+#include <boost/system/detail/is_aggregate.hpp>
+#include <boost/compat/type_traits.hpp>
+#include <boost/mp11/algorithm.hpp>
+#include <boost/mp11/utility.hpp>
+#include <type_traits>
+#include <utility>
+
+namespace boost
+{
+namespace system
+{
+
+// unwrap_and_invoke
+
+namespace detail
+{
+
+// get_error_type
+
+template<class... T> using first_if_same =
+    mp11::mp_if<mp11::mp_same<T...>, mp11::mp_first<mp11::mp_list<T...>>>;
+
+template<class... A> using get_error_type =
+    mp11::mp_apply<first_if_same,
+        mp11::mp_transform<mp11::mp_second,
+            mp11::mp_copy_if<mp11::mp_list<A...>, is_result>
+        >
+    >;
+
+// invoke_unwrap
+
+template< class T, class En = typename std::enable_if< !is_result< compat::remove_cvref_t<T> >::value >::type >
+auto invoke_unwrap( T&& t ) noexcept -> T&&
+{
+    return std::forward<T>( t );
+}
+
+template< class T, class = void, class En = typename std::enable_if< is_result< compat::remove_cvref_t<T> >::value >::type >
+auto invoke_unwrap( T&& t ) noexcept -> decltype( std::forward<T>( t ).unsafe_value() )
+{
+    return std::forward<T>( t ).unsafe_value();
+}
+
+// invoke_test
+
+template<class R, class A> int invoke_test( R&, A const& )
+{
+    return 0;
+}
+
+template<class R, class T, class E> int invoke_test( R& r, result<T, E> const& r2 )
+{
+    if( r && r2.has_error() ) r = r2.error();
+    return 0;
+}
+
+} // namespace detail
+
+template<class F, class... A,
+    class R = decltype( compat::invoke( std::declval<F>(), detail::invoke_unwrap( std::declval<A>() )... ) ),
+    class E = detail::get_error_type<compat::remove_cvref_t<A>...>,
+    class En = typename std::enable_if< !std::is_void<R>::value >::type
+>
+auto unwrap_and_invoke( F&& f, A&&... a ) -> result<R, E>
+{
+    {
+        result<void, E> r;
+
+        using Q = int[];
+        (void)Q{ detail::invoke_test( r, a )... };
+
+        if( !r ) return r.error();
+    }
+
+    return compat::invoke( std::forward<F>(f), detail::invoke_unwrap( std::forward<A>(a) )... );
+}
+
+template<class F, class... A,
+    class R = decltype( compat::invoke( std::declval<F>(), detail::invoke_unwrap( std::declval<A>() )... ) ),
+    class E = detail::get_error_type<compat::remove_cvref_t<A>...>,
+    class En1 = void,
+    class En2 = typename std::enable_if< std::is_void<R>::value >::type
+>
+auto unwrap_and_invoke( F&& f, A&&... a ) -> result<R, E>
+{
+    {
+        result<void, E> r;
+
+        using Q = int[];
+        (void)Q{ detail::invoke_test( r, a )... };
+
+        if( !r ) return r.error();
+    }
+
+    compat::invoke( std::forward<F>(f), detail::invoke_unwrap( std::forward<A>(a) )... );
+
+    return {};
+}
+
+// unwrap_and_construct
+
+namespace detail
+{
+
+template<class T> struct construct
+{
+private:
+
+    template<class... A> static inline T call_impl( std::false_type, A&&... a )
+    {
+        return T( std::forward<A>(a)... );
+    }
+
+    template<class... A> static inline T call_impl( std::true_type, A&&... a )
+    {
+        return T{ std::forward<A>(a)... };
+    }
+
+public:
+
+    template<class... A> inline T operator()( A&&... a ) const
+    {
+        return this->call_impl( detail::is_aggregate<T>(), std::forward<A>(a)... );
+    }
+};
+
+} // namespace detail
+
+template<class T, class... A>
+auto unwrap_and_construct( A&&... a )
+-> decltype( unwrap_and_invoke( detail::construct<T>(), std::forward<A>(a)... ) )
+{
+    return unwrap_and_invoke( detail::construct<T>(), std::forward<A>(a)... );
+}
+
+} // namespace system
+} // namespace boost
+
+#endif // #ifndef BOOST_SYSTEM_UNWRAP_AND_INVOKE_HPP_INCLUDED
@@ -184,3 +184,14 @@ boost_test(TYPE run SOURCES result_and_mfn1r.cpp)
 boost_test(TYPE compile SOURCES result_value_construct_cx.cpp)
 boost_test(TYPE compile SOURCES result_error_construct_cx.cpp)
 boost_test(TYPE compile SOURCES result_error_construct_cx2.cpp)
+
+boost_test(TYPE run SOURCES result_unsafe_value_access.cpp)
+boost_test(TYPE run SOURCES result_unsafe_value_access2.cpp)
+
+boost_test(TYPE run SOURCES unwrap_and_invoke.cpp)
+boost_test(TYPE run SOURCES unwrap_and_invoke2.cpp)
+
+boost_test(TYPE run SOURCES unwrap_and_construct.cpp)
+boost_test(TYPE run SOURCES unwrap_and_construct2.cpp)
+
+boost_test(TYPE run SOURCES detail_is_aggregate_test.cpp)
@@ -217,3 +217,16 @@ run result_and_mfn1r.cpp ;
 compile result_value_construct_cx.cpp ;
 compile result_error_construct_cx.cpp ;
 compile result_error_construct_cx2.cpp ;
+
+run result_unsafe_value_access.cpp ;
+run result_unsafe_value_access2.cpp ;
+
+run unwrap_and_invoke.cpp ;
+run unwrap_and_invoke2.cpp ;
+
+run unwrap_and_construct.cpp ;
+run unwrap_and_construct2.cpp ;
+
+run detail_is_aggregate_test.cpp ;
+
+run unwrap_and_invoke3.cpp ;
@@ -2,11 +2,11 @@
 # Distributed under the Boost Software License, Version 1.0.
 # See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt

-cmake_minimum_required(VERSION 3.5...3.16)
+cmake_minimum_required(VERSION 3.5...3.31)

 project(cmake_install_test LANGUAGES CXX)

-find_package(boost_system REQUIRED)
+find_package(Boost COMPONENTS system REQUIRED)

 add_executable(main main.cpp)
 target_link_libraries(main Boost::system)
@@ -0,0 +1,57 @@
+// Copyright 2026 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/detail/is_aggregate.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <boost/config/pragma_message.hpp>
+#include <string>
+
+struct X1
+{
+};
+
+struct X2
+{
+    int a, b;
+};
+
+struct X3
+{
+    std::string a, b;
+};
+
+struct X4
+{
+    X1 x1;
+    X2 x2;
+    X3 x3;
+};
+
+struct Y1
+{
+    Y1() {}
+};
+
+#if !defined(BOOST_SYSTEM_HAS_BUILTIN_IS_AGGREGATE) && !( defined(__cpp_lib_is_aggregate) && __cpp_lib_is_aggregate >= 201703L )
+
+BOOST_PRAGMA_MESSAGE("Test skipped, detail::is_aggregate isn't functional")
+int main() {}
+
+#else
+
+int main()
+{
+    using boost::system::detail::is_aggregate;
+
+    BOOST_TEST_TRAIT_TRUE((is_aggregate<X1>));
+    BOOST_TEST_TRAIT_TRUE((is_aggregate<X2>));
+    BOOST_TEST_TRAIT_TRUE((is_aggregate<X3>));
+    BOOST_TEST_TRAIT_TRUE((is_aggregate<X4>));
+
+    BOOST_TEST_TRAIT_FALSE((is_aggregate<Y1>));
+
+    return boost::report_errors();
+}
+
+#endif
@@ -8,6 +8,10 @@

 // See library home page at http://www.boost.org/libs/system

+#if defined(__GNUC__) && __GNUC__ >= 16
+# pragma GCC diagnostic ignored "-Wformat-truncation"
+#endif
+
 #include <boost/system/error_code.hpp>
 #include <boost/core/lightweight_test.hpp>
 #include <boost/core/snprintf.hpp>
@@ -8,6 +8,10 @@

 // See library home page at http://www.boost.org/libs/system

+#if defined(__GNUC__) && __GNUC__ >= 16
+# pragma GCC diagnostic ignored "-Wformat-truncation"
+#endif
+
 #include <boost/system/error_category.hpp>
 #include <boost/core/lightweight_test.hpp>
 #include <boost/core/snprintf.hpp>
@@ -96,7 +96,7 @@ int main()
        result<int, E2> r( 1 );

        r &= fi;
-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( *r, 3 );
+        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( r.unsafe_value(), 3 );

        r &= fi2;
        BOOST_TEST( r.has_error() );
@@ -109,7 +109,7 @@ int main()
        result<Y, E2> r( in_place_value, 1 );

        r &= fy;
-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( r->v_, 3 );
+        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( r.unsafe_value().v_, 3 );

        r &= fy2;
        BOOST_TEST( r.has_error() );
@@ -123,7 +123,7 @@ int main()
        result<int&, E2> r( x1 );

        r &= fri;
-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( &*r, &*fri( x1 ) );
+        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( &r.unsafe_value(), &fri( x1 ).unsafe_value() );

        r &= fri2;
        BOOST_TEST( r.has_error() );
@@ -112,7 +112,7 @@ int main()

        {
            result<int, E2> r2 = r & fi;
-            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 3 );
+            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2.unsafe_value(), 3 );
        }

        {
@@ -131,7 +131,7 @@ int main()

        {
            result<int, E2> r2 = r & fi;
-            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 3 );
+            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2.unsafe_value(), 3 );
        }

        {
@@ -147,7 +147,7 @@ int main()

    {
        result<int, E2> r2 = result<int, E>( 1 ) & fi;
-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 3 );
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2.unsafe_value(), 3 );
    }

    {
@@ -216,7 +216,7 @@ int main()
    {
        result<X, E2> r2 = result<Y, E>( in_place_value, 1 ) & fy;

-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2->v_, 3 );
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2.unsafe_value().v_, 3 );
    }

    {
@@ -255,7 +255,7 @@ int main()

        {
            result<int, E2> r2 = r & fri;
-            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 3 );
+            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2.unsafe_value(), 3 );
        }

        {
@@ -275,7 +275,7 @@ int main()

        {
            result<int, E2> r2 = r & fri;
-            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 3 );
+            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2.unsafe_value(), 3 );
        }

        {
@@ -293,7 +293,7 @@ int main()
        int x1 = 1;

        result<int, E2> r2 = result<int&, E>( x1 ) & fri;
-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 3 );
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2.unsafe_value(), 3 );
    }

    {
@@ -368,7 +368,7 @@ int main()

        {
            result<int, E2> r2 = r & fk;
-            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 7 );
+            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2.unsafe_value(), 7 );
        }

        {
@@ -392,7 +392,7 @@ int main()

        {
            result<int, E2> r2 = r & fk;
-            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 7 );
+            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2.unsafe_value(), 7 );
        }

        {
@@ -413,7 +413,7 @@ int main()

    {
        result<int, E2> r2 = result<void, E>() & fk;
-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 7 );
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2.unsafe_value(), 7 );
    }

    {
@@ -41,7 +41,7 @@ int main()

        {
            result<int, E2> r2 = r & &X::f;
-            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 1 );
+            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2.unsafe_value(), 1 );
        }

        {
@@ -51,12 +51,12 @@ int main()

        {
            result<int&, E2> r2 = r & &X::g;
-            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &*r2, &r->v_ );
+            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &r2.unsafe_value(), &r.unsafe_value().v_ );
        }

        {
            result<int const&, E2> r2 = r & &X::g2;
-            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &*r2, &r->v_ );
+            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &r2.unsafe_value(), &r.unsafe_value().v_ );
        }

        {
@@ -75,7 +75,7 @@ int main()

        {
            result<int, E2> r2 = r & &X::f;
-            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 1 );
+            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2.unsafe_value(), 1 );
        }

        {
@@ -85,7 +85,7 @@ int main()

        {
            result<int const&, E2> r2 = r & &X::g2;
-            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &*r2, &r->v_ );
+            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &r2.unsafe_value(), &r.unsafe_value().v_ );
        }

        {
@@ -102,7 +102,7 @@ int main()
    {
        {
            result<int, E2> r2 = result<X, E>( 1 ) & &X::f;
-            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 1 );
+            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2.unsafe_value(), 1 );
        }

        {
@@ -126,7 +126,7 @@ int main()
        result<char const*, int> r( "test" );
        result<std::string, X> r2 = r;

-        BOOST_TEST( r2 ) && BOOST_TEST_EQ( *r2, std::string( "test" ) );
+        BOOST_TEST( r2 ) && BOOST_TEST_EQ( r2.unsafe_value(), std::string( "test" ) );
        BOOST_TEST_EQ( X::instances, 0 );
    }

@@ -136,7 +136,7 @@ int main()
        result<char const*, int> const r( "test" );
        result<std::string, X> r2 = r;

-        BOOST_TEST( r2 ) && BOOST_TEST_EQ( *r2, std::string( "test" ) );
+        BOOST_TEST( r2 ) && BOOST_TEST_EQ( r2.unsafe_value(), std::string( "test" ) );
        BOOST_TEST_EQ( X::instances, 0 );
    }

@@ -145,7 +145,7 @@ int main()
    {
        result<std::string, X> r2 = result<char const*, int>( "test" );

-        BOOST_TEST( r2 ) && BOOST_TEST_EQ( *r2, std::string( "test" ) );
+        BOOST_TEST( r2 ) && BOOST_TEST_EQ( r2.unsafe_value(), std::string( "test" ) );
        BOOST_TEST_EQ( X::instances, 0 );
    }

@@ -42,6 +42,15 @@ struct Y

 int Y::instances = 0;

+struct E
+{
+};
+
+BOOST_NORETURN void throw_exception_from_error( Y const &, boost::source_location const& )
+{
+    throw E();
+}
+
 int main()
 {
    {
@@ -87,11 +87,11 @@ int main()

        r |= fi;

-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( *r, 1 );
+        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( r.unsafe_value(), 1 );

        r |= fi2;

-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( *r, 1 );
+        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( r.unsafe_value(), 1 );
    }

    {
@@ -103,7 +103,7 @@ int main()

        r |= fi;

-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( *r, 2 );
+        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( r.unsafe_value(), 2 );
    }

    {
@@ -111,11 +111,11 @@ int main()

        r |= fy;

-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( r->v_, 1 );
+        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( r.unsafe_value().v_, 1 );

        r |= fy2;

-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( r->v_, 1 );
+        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( r.unsafe_value().v_, 1 );
    }

    {
@@ -127,7 +127,7 @@ int main()

        r |= fy;

-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( r->v_, 2 );
+        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( r.unsafe_value().v_, 2 );
    }

    {
@@ -137,11 +137,11 @@ int main()

        r |= fri;

-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( &*r, &x1 );
+        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( &r.unsafe_value(), &x1 );

        r |= fri2;

-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( &*r, &x1 );
+        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( &r.unsafe_value(), &x1 );
    }

    {
@@ -153,7 +153,7 @@ int main()

        r |= fri;

-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( &*r, &*fri() );
+        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( &r.unsafe_value(), &fri().unsafe_value() );
    }

    return boost::report_errors();
@@ -74,7 +74,7 @@ int main()

        r |= f;

-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( *r, 2 );
+        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( r.unsafe_value(), 2 );
    }

    {
@@ -90,7 +90,7 @@ int main()

        r |= g;

-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( r->v_, 2 );
+        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( r.unsafe_value().v_, 2 );
    }

    {
@@ -108,7 +108,7 @@ int main()

        r |= h;

-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( &*r, &h() );
+        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( &r.unsafe_value(), &h() );
    }

    return boost::report_errors();
@@ -58,7 +58,7 @@ int main()

        r |= 2;

-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( *r, 2 );
+        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( r.unsafe_value(), 2 );
    }

    {
@@ -74,7 +74,7 @@ int main()

        r |= X{2};

-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( r->v_, 2 );
+        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( r.unsafe_value().v_, 2 );
    }

    {
@@ -85,7 +85,7 @@ int main()

        r |= x2;

-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( &*r, &x1 );
+        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( &r.unsafe_value(), &x1 );
    }

    {
@@ -95,7 +95,7 @@ int main()

        r |= x2;

-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( &*r, &x2 );
+        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( &r.unsafe_value(), &x2 );
    }

    return boost::report_errors();
@@ -196,7 +196,7 @@ int main()

        auto r2 = r | fri;

-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &*r2, &x1 );
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &r2.unsafe_value(), &x1 );
    }

    {
@@ -206,7 +206,7 @@ int main()

        auto r2 = r | fri;

-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &*r2, &x1 );
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &r2.unsafe_value(), &x1 );
    }

    {
@@ -214,7 +214,7 @@ int main()

        auto r2 = result<int&>( x1 ) | fri;

-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &*r2, &x1 );
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &r2.unsafe_value(), &x1 );
    }

    {
@@ -224,7 +224,7 @@ int main()

        auto r2 = r | fri2;

-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &*r2, &x1 );
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &r2.unsafe_value(), &x1 );
    }

    {
@@ -234,7 +234,7 @@ int main()

        auto r2 = r | fri2;

-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &*r2, &x1 );
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &r2.unsafe_value(), &x1 );
    }

    {
@@ -242,7 +242,7 @@ int main()

        auto r2 = result<int&>( x1 ) | fri2;

-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &*r2, &x1 );
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &r2.unsafe_value(), &x1 );
    }

    {
@@ -250,7 +250,7 @@ int main()

        auto r2 = r | fri;

-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &*r2, &*fri() );
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &r2.unsafe_value(), &fri().unsafe_value() );
    }

    {
@@ -258,13 +258,13 @@ int main()

        auto r2 = r | fri;

-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &*r2, &*fri() );
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &r2.unsafe_value(), &fri().unsafe_value() );
    }

    {
        auto r2 = result<int&, E>( in_place_error ) | fri;

-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &*r2, &*fri() );
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &r2.unsafe_value(), &fri().unsafe_value() );
    }

    {
@@ -0,0 +1,137 @@
+// Copyright 2017, 2021, 2022, 2026 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/result.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/config.hpp>
+
+using namespace boost::system;
+
+struct X
+{
+    int v_;
+
+    explicit X( int v ): v_( v ) {}
+
+    X( X const& ) = delete;
+    X& operator=( X const& ) = delete;
+};
+
+int main()
+{
+    {
+        result<int> r;
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST_EQ( r.unsafe_value(), 0 );
+    }
+
+    {
+        result<int> const r;
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST_EQ( r.unsafe_value(), 0 );
+    }
+
+    {
+        BOOST_TEST( result<int>().has_value() );
+        BOOST_TEST_EQ( result<int>().unsafe_value(), 0 );
+    }
+
+    {
+        result<int> r( 1 );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST_EQ( r.unsafe_value(), 1 );
+    }
+
+    {
+        result<int> const r( 1 );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST_EQ( r.unsafe_value(), 1 );
+    }
+
+    {
+        BOOST_TEST( result<int>( 1 ).has_value() );
+        BOOST_TEST_EQ( result<int>( 1 ).unsafe_value(), 1 );
+    }
+
+    //
+
+    {
+        result<X> r( 1 );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST_EQ( r.unsafe_value().v_, 1 );
+    }
+
+    {
+        result<X> const r( 1 );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST_EQ( r.unsafe_value().v_, 1 );
+    }
+
+    {
+        BOOST_TEST( result<X>( 1 ).has_value() );
+        BOOST_TEST_EQ( result<X>( 1 ).unsafe_value().v_, 1 );
+    }
+
+    //
+
+    {
+        result<void> r;
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST_NO_THROW( r.unsafe_value() );
+    }
+
+    {
+        result<void> const r;
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST_NO_THROW( r.unsafe_value() );
+    }
+
+    {
+        BOOST_TEST( result<void>().has_value() );
+        BOOST_TEST_NO_THROW( result<void>().unsafe_value() );
+    }
+
+    //
+
+    {
+        int x1 = 1;
+        result<int&> r( x1 );
+
+        BOOST_TEST( r.has_value() );
+
+        BOOST_TEST_EQ( r.unsafe_value(), 1 );
+        BOOST_TEST_EQ( &r.unsafe_value(), &x1 );
+    }
+
+    {
+        int x1 = 1;
+        result<int&> const r( x1 );
+
+        BOOST_TEST( r.has_value() );
+
+        BOOST_TEST_EQ( r.unsafe_value(), 1 );
+        BOOST_TEST_EQ( &r.unsafe_value(), &x1 );
+    }
+
+    {
+        int x1 = 1;
+
+        BOOST_TEST( result<int&>( x1 ).has_value() );
+
+        BOOST_TEST_EQ( result<int&>( x1 ).unsafe_value(), 1 );
+        BOOST_TEST_EQ( &result<int&>( x1 ).unsafe_value(), &x1 );
+    }
+
+    //
+
+    return boost::report_errors();
+}
@@ -0,0 +1,139 @@
+// Copyright 2017, 2021, 2022, 2026 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#define BOOST_ENABLE_ASSERT_HANDLER
+
+#include <boost/system/result.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+struct assertion_failure
+{
+};
+
+namespace boost
+{
+
+void assertion_failed( char const* /*expr*/, char const* /*function*/, char const* /*file*/, long /*line*/ )
+{
+    throw assertion_failure();
+}
+
+} // namespace boost
+
+using namespace boost::system;
+
+struct X
+{
+    int v_;
+
+    explicit X( int v ): v_( v ) {}
+
+    X( X const& ) = delete;
+    X& operator=( X const& ) = delete;
+};
+
+int main()
+{
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+        result<int> r( ec );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST_THROWS( r.unsafe_value(), assertion_failure );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+        result<int> const r( ec );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST_THROWS( r.unsafe_value(), assertion_failure );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        BOOST_TEST( !result<int>( ec ).has_value() );
+        BOOST_TEST_THROWS( result<int>( ec ).unsafe_value(), assertion_failure );
+    }
+
+    //
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+        result<X> r( ec );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST_THROWS( r.unsafe_value(), assertion_failure );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+        result<X> const r( ec );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST_THROWS( r.unsafe_value(), assertion_failure );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        BOOST_TEST(( !result<X>( ec ).has_value() ));
+        BOOST_TEST_THROWS( (result<X>( ec ).unsafe_value()), assertion_failure );
+    }
+
+    //
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+        result<void> r( ec );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST_THROWS( r.unsafe_value(), assertion_failure );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+        result<void> const r( ec );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST_THROWS( r.unsafe_value(), assertion_failure );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        BOOST_TEST( !result<void>( ec ).has_value() );
+        BOOST_TEST_THROWS( result<void>( ec ).unsafe_value(), assertion_failure );
+    }
+
+    //
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+        result<int&> r( ec );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST_THROWS( r.unsafe_value(), assertion_failure );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+        result<int&> const r( ec );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST_THROWS( r.unsafe_value(), assertion_failure );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        BOOST_TEST( !result<int&>( ec ).has_value() );
+        BOOST_TEST_THROWS( result<int&>( ec ).unsafe_value(), assertion_failure );
+    }
+
+    //
+
+    return boost::report_errors();
+}
@@ -138,7 +138,8 @@ int main()

        BOOST_TEST_THROWS( r.value(), system_error );

-        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
+        BOOST_TEST_THROWS( *r, system_error );
+        BOOST_TEST_THROWS( r.operator->(), system_error );
    }

    {
@@ -154,7 +155,8 @@ int main()

        BOOST_TEST_THROWS( r.value(), system_error );

-        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
+        BOOST_TEST_THROWS( *r, system_error );
+        BOOST_TEST_THROWS( r.operator->(), system_error );
    }

    {
@@ -168,7 +170,8 @@ int main()

        BOOST_TEST_THROWS( result<int>( ec ).value(), system_error );

-        BOOST_TEST_EQ( result<int>( ec ).operator->(), static_cast<int*>(0) );
+        BOOST_TEST_THROWS( *result<int>( ec ), system_error );
+        BOOST_TEST_THROWS( result<int>( ec ).operator->(), system_error );
    }

    {
@@ -184,7 +187,8 @@ int main()

        BOOST_TEST_THROWS( r.value(), std::system_error );

-        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
+        BOOST_TEST_THROWS( *r, std::system_error );
+        BOOST_TEST_THROWS( r.operator->(), std::system_error );
    }

    {
@@ -198,7 +202,8 @@ int main()

        BOOST_TEST_THROWS( r.value(), system_error );

-        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
+        BOOST_TEST_THROWS( *r, system_error );
+        BOOST_TEST_THROWS( r.operator->(), system_error );
    }

    {
@@ -212,7 +217,8 @@ int main()

        BOOST_TEST_THROWS( r.value(), std::system_error );

-        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
+        BOOST_TEST_THROWS( *r, std::system_error );
+        BOOST_TEST_THROWS( r.operator->(), std::system_error );
    }

    {
@@ -227,9 +233,9 @@ int main()
 #if defined(BOOST_CLANG_VERSION) && BOOST_CLANG_VERSION < 30600
 #else
        BOOST_TEST_THROWS( r.value(), E2 );
+        BOOST_TEST_THROWS( *r, E2 );
+        BOOST_TEST_THROWS( r.operator->(), E2 );
 #endif
-
-        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
    }

    {
@@ -243,7 +249,8 @@ int main()

        BOOST_TEST_THROWS( r.value(), std::bad_exception );

-        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
+        BOOST_TEST_THROWS( *r, std::bad_exception );
+        BOOST_TEST_THROWS( r.operator->(), std::bad_exception );
    }

    {
@@ -303,7 +310,8 @@ int main()

        BOOST_TEST_THROWS( r.value(), E );

-        BOOST_TEST_EQ( r.operator->(), static_cast<X*>(0) );
+        BOOST_TEST_THROWS( *r, E );
+        BOOST_TEST_THROWS( r.operator->(), E );
    }

    {
@@ -319,7 +327,8 @@ int main()

        BOOST_TEST_THROWS( r.value(), E );

-        BOOST_TEST_EQ( r.operator->(), static_cast<X*>(0) );
+        BOOST_TEST_THROWS( *r, E );
+        BOOST_TEST_THROWS( r.operator->(), E );
    }

    {
@@ -333,7 +342,8 @@ int main()

        BOOST_TEST_THROWS( (result<X, Y>( ec ).value()), E );

-        BOOST_TEST_EQ( (result<X, Y>( ec ).operator->()), static_cast<X*>(0) );
+        BOOST_TEST_THROWS( *(result<X, Y>( ec )), E );
+        BOOST_TEST_THROWS( (result<X, Y>( ec )).operator->(), E );
    }

    //
@@ -349,6 +359,9 @@ int main()

        BOOST_TEST_NO_THROW( r.value() );

+        BOOST_TEST_NO_THROW( *r );
+        BOOST_TEST_NO_THROW( r.operator->() );
+
        BOOST_TEST( r.operator->() != 0 );
    }

@@ -363,6 +376,9 @@ int main()

        BOOST_TEST_NO_THROW( r.value() );

+        BOOST_TEST_NO_THROW( *r );
+        BOOST_TEST_NO_THROW( r.operator->() );
+
        BOOST_TEST( r.operator->() != 0 );
    }

@@ -375,6 +391,9 @@ int main()

        BOOST_TEST_NO_THROW( result<void>().value() );

+        BOOST_TEST_NO_THROW( *result<void>() );
+        BOOST_TEST_NO_THROW( result<void>().operator->() );
+
        BOOST_TEST( result<void>().operator->() != 0 );
    }

@@ -391,7 +410,8 @@ int main()

        BOOST_TEST_THROWS( r.value(), system_error );

-        BOOST_TEST_EQ( r.operator->(), static_cast<void*>(0) );
+        BOOST_TEST_THROWS( *r, system_error );
+        BOOST_TEST_THROWS( r.operator->(), system_error );
    }

    {
@@ -407,7 +427,8 @@ int main()

        BOOST_TEST_THROWS( r.value(), system_error );

-        BOOST_TEST_EQ( r.operator->(), static_cast<void*>(0) );
+        BOOST_TEST_THROWS( *r, system_error );
+        BOOST_TEST_THROWS( r.operator->(), system_error );
    }

    {
@@ -421,7 +442,8 @@ int main()

        BOOST_TEST_THROWS( result<void>( ec ).value(), system_error );

-        BOOST_TEST_EQ( result<void>( ec ).operator->(), static_cast<void*>(0) );
+        BOOST_TEST_THROWS( *result<void>( ec ), system_error );
+        BOOST_TEST_THROWS( result<void>( ec ).operator->(), system_error );
    }

    {
@@ -437,7 +459,8 @@ int main()

        BOOST_TEST_THROWS( r.value(), std::system_error );

-        BOOST_TEST_EQ( r.operator->(), static_cast<void*>(0) );
+        BOOST_TEST_THROWS( *r, std::system_error );
+        BOOST_TEST_THROWS( r.operator->(), std::system_error );
    }

    {
@@ -451,7 +474,8 @@ int main()

        BOOST_TEST_THROWS( r.value(), system_error );

-        BOOST_TEST_EQ( r.operator->(), static_cast<void*>(0) );
+        BOOST_TEST_THROWS( *r, system_error );
+        BOOST_TEST_THROWS( r.operator->(), system_error );
    }

    {
@@ -465,7 +489,8 @@ int main()

        BOOST_TEST_THROWS( r.value(), std::system_error );

-        BOOST_TEST_EQ( r.operator->(), static_cast<void*>(0) );
+        BOOST_TEST_THROWS( *r, std::system_error );
+        BOOST_TEST_THROWS( r.operator->(), std::system_error );
    }

    {
@@ -480,9 +505,9 @@ int main()
 #if defined(BOOST_CLANG_VERSION) && BOOST_CLANG_VERSION < 30600
 #else
        BOOST_TEST_THROWS( r.value(), E2 );
+        BOOST_TEST_THROWS( *r, E2 );
+        BOOST_TEST_THROWS( r.operator->(), E2 );
 #endif
-
-        BOOST_TEST_EQ( r.operator->(), static_cast<void*>(0) );
    }

    {
@@ -496,7 +521,8 @@ int main()

        BOOST_TEST_THROWS( r.value(), std::bad_exception );

-        BOOST_TEST_EQ( r.operator->(), static_cast<void*>(0) );
+        BOOST_TEST_THROWS( *r, std::bad_exception );
+        BOOST_TEST_THROWS( r.operator->(), std::bad_exception );
    }

    //
@@ -563,7 +589,8 @@ int main()

        BOOST_TEST_THROWS( r.value(), system_error );

-        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
+        BOOST_TEST_THROWS( *r, system_error );
+        BOOST_TEST_THROWS( r.operator->(), system_error );
    }

    {
@@ -579,7 +606,8 @@ int main()

        BOOST_TEST_THROWS( r.value(), system_error );

-        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
+        BOOST_TEST_THROWS( *r, system_error );
+        BOOST_TEST_THROWS( r.operator->(), system_error );
    }

    {
@@ -593,7 +621,8 @@ int main()

        BOOST_TEST_THROWS( result<int&>( ec ).value(), system_error );

-        BOOST_TEST_EQ( result<int&>( ec ).operator->(), static_cast<int*>(0) );
+        BOOST_TEST_THROWS( *result<int&>( ec ), system_error );
+        BOOST_TEST_THROWS( result<int&>( ec ).operator->(), system_error );
    }

    {
@@ -609,7 +638,8 @@ int main()

        BOOST_TEST_THROWS( r.value(), std::system_error );

-        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
+        BOOST_TEST_THROWS( *r, std::system_error );
+        BOOST_TEST_THROWS( r.operator->(), std::system_error );
    }

    {
@@ -623,7 +653,8 @@ int main()

        BOOST_TEST_THROWS( r.value(), system_error );

-        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
+        BOOST_TEST_THROWS( *r, system_error );
+        BOOST_TEST_THROWS( r.operator->(), system_error );
    }

    {
@@ -637,7 +668,8 @@ int main()

        BOOST_TEST_THROWS( r.value(), std::system_error );

-        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
+        BOOST_TEST_THROWS( *r, std::system_error );
+        BOOST_TEST_THROWS( r.operator->(), std::system_error );
    }

    {
@@ -652,9 +684,9 @@ int main()
 #if defined(BOOST_CLANG_VERSION) && BOOST_CLANG_VERSION < 30600
 #else
        BOOST_TEST_THROWS( r.value(), E2 );
+        BOOST_TEST_THROWS( *r, E2 );
+        BOOST_TEST_THROWS( r.operator->(), E2 );
 #endif
-
-        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
    }

    {
@@ -668,7 +700,8 @@ int main()

        BOOST_TEST_THROWS( r.value(), std::bad_exception );

-        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
+        BOOST_TEST_THROWS( *r, std::bad_exception );
+        BOOST_TEST_THROWS( r.operator->(), std::bad_exception );
    }

    //
@@ -27,6 +27,15 @@ struct X

 int X::instances = 0;

+struct E
+{
+};
+
+BOOST_NORETURN void throw_exception_from_error( X const &, boost::source_location const& )
+{
+    throw E();
+}
+
 int main()
 {
    {
@@ -53,7 +62,7 @@ int main()
        BOOST_TEST( r.has_value() );
        BOOST_TEST( !r.has_error() );

-        BOOST_TEST_EQ( *r, 1 );
+        BOOST_TEST_EQ( r.unsafe_value(), 1 );
    }

    BOOST_TEST_EQ( X::instances, 0 );
@@ -74,6 +74,15 @@ result<void> fw0()
    return {};
 }

+struct E2
+{
+};
+
+BOOST_NORETURN void throw_exception_from_error( E const &, boost::source_location const& )
+{
+    throw E2();
+}
+
 int main()
 {
    {
@@ -26,6 +26,15 @@ struct X

 int X::instances = 0;

+struct E
+{
+};
+
+BOOST_NORETURN void throw_exception_from_error( X const &, boost::source_location const& )
+{
+    throw E();
+}
+
 int main()
 {
    {
@@ -45,7 +54,7 @@ int main()
        BOOST_TEST( r.has_value() );
        BOOST_TEST( !r.has_error() );

-        BOOST_TEST_EQ( *r, 1 );
+        BOOST_TEST_EQ( r.unsafe_value(), 1 );
    }

    BOOST_TEST_EQ( X::instances, 0 );
@@ -135,7 +144,7 @@ int main()
        BOOST_TEST( r.has_value() );
        BOOST_TEST( !r.has_error() );

-        BOOST_TEST_EQ( *r, 1 );
+        BOOST_TEST_EQ( r.unsafe_value(), 1 );
    }

    return boost::report_errors();
@@ -24,6 +24,15 @@ struct X

 int X::instances = 0;

+struct E
+{
+};
+
+BOOST_NORETURN void throw_exception_from_error( X const &, boost::source_location const& )
+{
+    throw E();
+}
+
 int main()
 {
    {
@@ -53,7 +62,7 @@ int main()
        BOOST_TEST( r.has_value() );
        BOOST_TEST( !r.has_error() );

-        BOOST_TEST_EQ( *r, 1 );
+        BOOST_TEST_EQ( r.unsafe_value(), 1 );
    }

    BOOST_TEST_EQ( X::instances, 0 );
@@ -24,6 +24,15 @@ struct X

 int X::instances = 0;

+struct E
+{
+};
+
+BOOST_NORETURN void throw_exception_from_error( X const &, boost::source_location const& )
+{
+    throw E();
+}
+
 int main()
 {
    {
@@ -73,7 +82,7 @@ int main()
        BOOST_TEST( r.has_value() );
        BOOST_TEST( !r.has_error() );

-        BOOST_TEST_EQ( *r, 1 );
+        BOOST_TEST_EQ( r.unsafe_value(), 1 );
    }

    {
@@ -83,7 +92,7 @@ int main()
        BOOST_TEST( r.has_value() );
        BOOST_TEST( !r.has_error() );

-        BOOST_TEST_EQ( *r, 1 );
+        BOOST_TEST_EQ( r.unsafe_value(), 1 );
    }

    BOOST_TEST_EQ( X::instances, 0 );
@@ -0,0 +1,109 @@
+// Copyright 2026 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/unwrap_and_invoke.hpp>
+#include <boost/system/result.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+
+using namespace boost::system;
+
+struct X
+{
+    int v;
+};
+
+struct Y
+{
+    int v;
+
+    explicit Y( X a1 = {0}, X a2 = {0}, X a3 = {0}, X a4 = {0} ): v( a1.v + a2.v + a3.v + a4.v )
+    {
+    }
+};
+
+struct E
+{
+    int w;
+};
+
+int main()
+{
+    {
+        auto r = unwrap_and_construct<Y>( result<X, E>( E{1} ) );
+        BOOST_TEST( !r ) && BOOST_TEST_EQ( r.error().w, 1 );
+    }
+
+    {
+        auto r = unwrap_and_construct<Y>( result<X, E>( X{1} ) );
+        BOOST_TEST( r ) && BOOST_TEST_EQ( r.unsafe_value().v, 1 );
+    }
+
+    //
+
+    {
+        auto r = unwrap_and_construct<Y>( result<X, E>( E{1} ), result<X, E>( E{2} ) );
+        BOOST_TEST( !r ) && BOOST_TEST_EQ( r.error().w, 1 );
+    }
+
+    {
+        auto r = unwrap_and_construct<Y>( result<X, E>( X{1} ), result<X, E>( E{2} ) );
+        BOOST_TEST( !r ) && BOOST_TEST_EQ( r.error().w, 2 );
+    }
+
+    {
+        auto r = unwrap_and_construct<Y>( result<X, E>( X{1} ), result<X, E>( X{2} ) );
+        BOOST_TEST( r ) && BOOST_TEST_EQ( r.unsafe_value().v, 3 );
+    }
+
+    //
+
+    {
+        auto r = unwrap_and_construct<Y>( result<X, E>( E{1} ), result<X, E>( E{2} ), result<X, E>( E{3} ) );
+        BOOST_TEST( !r ) && BOOST_TEST_EQ( r.error().w, 1 );
+    }
+
+    {
+        auto r = unwrap_and_construct<Y>( result<X, E>( X{1} ), result<X, E>( E{2} ), result<X, E>( E{3} ) );
+        BOOST_TEST( !r ) && BOOST_TEST_EQ( r.error().w, 2 );
+    }
+
+    {
+        auto r = unwrap_and_construct<Y>( result<X, E>( X{1} ), result<X, E>( X{2} ), result<X, E>( E{3} ) );
+        BOOST_TEST( !r ) && BOOST_TEST_EQ( r.error().w, 3 );
+    }
+
+    {
+        auto r = unwrap_and_construct<Y>( result<X, E>( X{1} ), result<X, E>( X{2} ), result<X, E>( X{3} ) );
+        BOOST_TEST( r ) && BOOST_TEST_EQ( r.unsafe_value().v, 6 );
+    }
+
+    //
+
+    {
+        auto r = unwrap_and_construct<Y>( result<X, E>( E{1} ), result<X, E>( E{2} ), result<X, E>( E{3} ), result<X, E>( E{4} ) );
+        BOOST_TEST( !r ) && BOOST_TEST_EQ( r.error().w, 1 );
+    }
+
+    {
+        auto r = unwrap_and_construct<Y>( result<X, E>( X{1} ), result<X, E>( E{2} ), result<X, E>( E{3} ), result<X, E>( E{4} ) );
+        BOOST_TEST( !r ) && BOOST_TEST_EQ( r.error().w, 2 );
+    }
+
+    {
+        auto r = unwrap_and_construct<Y>( result<X, E>( X{1} ), result<X, E>( X{2} ), result<X, E>( E{3} ), result<X, E>( E{4} ) );
+        BOOST_TEST( !r ) && BOOST_TEST_EQ( r.error().w, 3 );
+    }
+
+    {
+        auto r = unwrap_and_construct<Y>( result<X, E>( X{1} ), result<X, E>( X{2} ), result<X, E>( X{3} ), result<X, E>( E{4} ) );
+        BOOST_TEST( !r ) && BOOST_TEST_EQ( r.error().w, 4 );
+    }
+
+    {
+        auto r = unwrap_and_construct<Y>( result<X, E>( X{1} ), result<X, E>( X{2} ), result<X, E>( X{3} ), result<X, E>( X{4} ) );
+        BOOST_TEST( r ) && BOOST_TEST_EQ( r.unsafe_value().v, 10 );
+    }
+
+    return boost::report_errors();
+}
@@ -0,0 +1,144 @@
+// Copyright 2026 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#if defined(__GNUC__) || defined(__clang__)
+# pragma GCC diagnostic ignored "-Wmissing-field-initializers"
+#endif
+
+#include <boost/system/unwrap_and_invoke.hpp>
+#include <boost/system/result.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <boost/config/pragma_message.hpp>
+#include <boost/config.hpp>
+
+struct X
+{
+    int v;
+};
+
+struct Y
+{
+    X x1, x2, x3, x4;
+};
+
+struct E
+{
+    int w;
+};
+
+#if !defined(BOOST_SYSTEM_HAS_BUILTIN_IS_AGGREGATE) && !( defined(__cpp_lib_is_aggregate) && __cpp_lib_is_aggregate >= 201703L )
+
+BOOST_PRAGMA_MESSAGE("Test skipped, detail::is_aggregate isn't functional")
+int main() {}
+
+#else
+
+using namespace boost::system;
+
+int main()
+{
+    {
+        auto r = unwrap_and_construct<Y>( result<X, E>( E{1} ) );
+        BOOST_TEST( !r ) && BOOST_TEST_EQ( r.error().w, 1 );
+    }
+
+    {
+        auto r = unwrap_and_construct<Y>( result<X, E>( X{1} ) );
+
+        BOOST_TEST( r )
+            && BOOST_TEST_EQ( r.unsafe_value().x1.v, 1 )
+            && BOOST_TEST_EQ( r.unsafe_value().x2.v, 0 )
+            && BOOST_TEST_EQ( r.unsafe_value().x3.v, 0 )
+            && BOOST_TEST_EQ( r.unsafe_value().x4.v, 0 )
+        ;
+    }
+
+    //
+
+    {
+        auto r = unwrap_and_construct<Y>( result<X, E>( E{1} ), result<X, E>( E{2} ) );
+        BOOST_TEST( !r ) && BOOST_TEST_EQ( r.error().w, 1 );
+    }
+
+    {
+        auto r = unwrap_and_construct<Y>( result<X, E>( X{1} ), result<X, E>( E{2} ) );
+        BOOST_TEST( !r ) && BOOST_TEST_EQ( r.error().w, 2 );
+    }
+
+    {
+        auto r = unwrap_and_construct<Y>( result<X, E>( X{1} ), result<X, E>( X{2} ) );
+
+        BOOST_TEST( r )
+            && BOOST_TEST_EQ( r.unsafe_value().x1.v, 1 )
+            && BOOST_TEST_EQ( r.unsafe_value().x2.v, 2 )
+            && BOOST_TEST_EQ( r.unsafe_value().x3.v, 0 )
+            && BOOST_TEST_EQ( r.unsafe_value().x4.v, 0 )
+        ;
+    }
+
+    //
+
+    {
+        auto r = unwrap_and_construct<Y>( result<X, E>( E{1} ), result<X, E>( E{2} ), result<X, E>( E{3} ) );
+        BOOST_TEST( !r ) && BOOST_TEST_EQ( r.error().w, 1 );
+    }
+
+    {
+        auto r = unwrap_and_construct<Y>( result<X, E>( X{1} ), result<X, E>( E{2} ), result<X, E>( E{3} ) );
+        BOOST_TEST( !r ) && BOOST_TEST_EQ( r.error().w, 2 );
+    }
+
+    {
+        auto r = unwrap_and_construct<Y>( result<X, E>( X{1} ), result<X, E>( X{2} ), result<X, E>( E{3} ) );
+        BOOST_TEST( !r ) && BOOST_TEST_EQ( r.error().w, 3 );
+    }
+
+    {
+        auto r = unwrap_and_construct<Y>( result<X, E>( X{1} ), result<X, E>( X{2} ), result<X, E>( X{3} ) );
+
+        BOOST_TEST( r )
+            && BOOST_TEST_EQ( r.unsafe_value().x1.v, 1 )
+            && BOOST_TEST_EQ( r.unsafe_value().x2.v, 2 )
+            && BOOST_TEST_EQ( r.unsafe_value().x3.v, 3 )
+            && BOOST_TEST_EQ( r.unsafe_value().x4.v, 0 )
+        ;
+    }
+
+    //
+
+    {
+        auto r = unwrap_and_construct<Y>( result<X, E>( E{1} ), result<X, E>( E{2} ), result<X, E>( E{3} ), result<X, E>( E{4} ) );
+        BOOST_TEST( !r ) && BOOST_TEST_EQ( r.error().w, 1 );
+    }
+
+    {
+        auto r = unwrap_and_construct<Y>( result<X, E>( X{1} ), result<X, E>( E{2} ), result<X, E>( E{3} ), result<X, E>( E{4} ) );
+        BOOST_TEST( !r ) && BOOST_TEST_EQ( r.error().w, 2 );
+    }
+
+    {
+        auto r = unwrap_and_construct<Y>( result<X, E>( X{1} ), result<X, E>( X{2} ), result<X, E>( E{3} ), result<X, E>( E{4} ) );
+        BOOST_TEST( !r ) && BOOST_TEST_EQ( r.error().w, 3 );
+    }
+
+    {
+        auto r = unwrap_and_construct<Y>( result<X, E>( X{1} ), result<X, E>( X{2} ), result<X, E>( X{3} ), result<X, E>( E{4} ) );
+        BOOST_TEST( !r ) && BOOST_TEST_EQ( r.error().w, 4 );
+    }
+
+    {
+        auto r = unwrap_and_construct<Y>( result<X, E>( X{1} ), result<X, E>( X{2} ), result<X, E>( X{3} ), result<X, E>( X{4} ) );
+
+        BOOST_TEST( r )
+            && BOOST_TEST_EQ( r.unsafe_value().x1.v, 1 )
+            && BOOST_TEST_EQ( r.unsafe_value().x2.v, 2 )
+            && BOOST_TEST_EQ( r.unsafe_value().x3.v, 3 )
+            && BOOST_TEST_EQ( r.unsafe_value().x4.v, 4 )
+        ;
+    }
+
+    return boost::report_errors();
+}
+
+#endif
@@ -0,0 +1,254 @@
+// Copyright 2026 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/unwrap_and_invoke.hpp>
+#include <boost/system/result.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <memory>
+
+using namespace boost::system;
+
+int f( int x, int y )
+{
+    return x + y;
+}
+
+struct X
+{
+    int x_ = 0;
+
+    explicit X( int x ): x_( x )
+    {
+    }
+
+    int f( int y ) const
+    {
+        return x_ + y;
+    }
+
+    int g( std::unique_ptr<X> p ) const
+    {
+        return x_ + p->x_;
+    }
+};
+
+template<class T, class... A> std::unique_ptr<T> make_unique( A&&... a )
+{
+    return std::unique_ptr<T>( new T( std::forward<A>(a)... ) );
+}
+
+int main()
+{
+    {
+        result<int> a1( 1 );
+
+        auto r = unwrap_and_invoke( f, a1, 2 );
+        BOOST_TEST( r ) && BOOST_TEST_EQ( *r, 3 );
+    }
+
+    {
+        result<int> const a1( 1 );
+
+        auto r = unwrap_and_invoke( f, a1, 2 );
+        BOOST_TEST( r ) && BOOST_TEST_EQ( *r, 3 );
+    }
+
+    {
+        result<int const> a1( 1 );
+
+        auto r = unwrap_and_invoke( f, a1, 2 );
+        BOOST_TEST( r ) && BOOST_TEST_EQ( *r, 3 );
+    }
+
+    {
+        auto r = unwrap_and_invoke( f, result<int>( 1 ), 2 );
+        BOOST_TEST( r ) && BOOST_TEST_EQ( *r, 3 );
+    }
+
+    //
+
+    {
+        result<int> a2( 2 );
+
+        auto r = unwrap_and_invoke( f, 1, a2 );
+        BOOST_TEST( r ) && BOOST_TEST_EQ( *r, 3 );
+    }
+
+    {
+        result<int> const a2( 2 );
+
+        auto r = unwrap_and_invoke( f, 1, a2 );
+        BOOST_TEST( r ) && BOOST_TEST_EQ( *r, 3 );
+    }
+
+    {
+        result<int const> a2( 2 );
+
+        auto r = unwrap_and_invoke( f, 1, a2 );
+        BOOST_TEST( r ) && BOOST_TEST_EQ( *r, 3 );
+    }
+
+    {
+        auto r = unwrap_and_invoke( f, 1, result<int>( 2 ) );
+        BOOST_TEST( r ) && BOOST_TEST_EQ( *r, 3 );
+    }
+
+    //
+
+    {
+        result<int> a1( 1 );
+        result<int> const a2( 2 );
+
+        auto r = unwrap_and_invoke( f, a1, a2 );
+        BOOST_TEST( r ) && BOOST_TEST_EQ( *r, 3 );
+    }
+
+    {
+        result<int const> a1( 1 );
+
+        auto r = unwrap_and_invoke( f, a1, result<int>( 2 ) );
+        BOOST_TEST( r ) && BOOST_TEST_EQ( *r, 3 );
+    }
+
+    //
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<int> a1( ec );
+
+        auto r = unwrap_and_invoke( f, a1, 2 );
+        BOOST_TEST( r.has_error() ) && BOOST_TEST_EQ( r.error(), ec );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<int> const a1( ec );
+
+        auto r = unwrap_and_invoke( f, a1, 2 );
+        BOOST_TEST( r.has_error() ) && BOOST_TEST_EQ( r.error(), ec );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<int const> a1( ec );
+
+        auto r = unwrap_and_invoke( f, a1, 2 );
+        BOOST_TEST( r.has_error() ) && BOOST_TEST_EQ( r.error(), ec );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        auto r = unwrap_and_invoke( f, result<int>( ec ), 2 );
+        BOOST_TEST( r.has_error() ) && BOOST_TEST_EQ( r.error(), ec );
+    }
+
+    //
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<int> a2( ec );
+
+        auto r = unwrap_and_invoke( f, 1, a2 );
+        BOOST_TEST( r.has_error() ) && BOOST_TEST_EQ( r.error(), ec );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<int> const a2( ec );
+
+        auto r = unwrap_and_invoke( f, 1, a2 );
+        BOOST_TEST( r.has_error() ) && BOOST_TEST_EQ( r.error(), ec );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<int const> a2( ec );
+
+        auto r = unwrap_and_invoke( f, 1, a2 );
+        BOOST_TEST( r.has_error() ) && BOOST_TEST_EQ( r.error(), ec );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        auto r = unwrap_and_invoke( f, 1, result<int>( ec ) );
+        BOOST_TEST( r.has_error() ) && BOOST_TEST_EQ( r.error(), ec );
+    }
+
+    //
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<int> a1( ec );
+        result<int> const a2( 2 );
+
+        auto r = unwrap_and_invoke( f, a1, a2 );
+        BOOST_TEST( r.has_error() ) && BOOST_TEST_EQ( r.error(), ec );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<int> a1( 1 );
+        result<int> const a2( ec );
+
+        auto r = unwrap_and_invoke( f, a1, a2 );
+        BOOST_TEST( r.has_error() ) && BOOST_TEST_EQ( r.error(), ec );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<int const> a1( ec );
+
+        auto r = unwrap_and_invoke( f, a1, result<int>( 2 ) );
+        BOOST_TEST( r.has_error() ) && BOOST_TEST_EQ( r.error(), ec );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<int const> a1( 1 );
+
+        auto r = unwrap_and_invoke( f, a1, result<int>( ec ) );
+        BOOST_TEST( r.has_error() ) && BOOST_TEST_EQ( r.error(), ec );
+    }
+
+    //
+
+    {
+        result<X> a1( X( 1 ) );
+        result<int> const a2( 2 );
+
+        auto r = unwrap_and_invoke( &X::f, a1, a2 );
+        BOOST_TEST( r ) && BOOST_TEST_EQ( *r, 3 );
+    }
+
+    {
+        result<X const> a1( X( 1 ) );
+
+        auto r = unwrap_and_invoke( &X::f, a1, result<int>( 2 ) );
+        BOOST_TEST( r ) && BOOST_TEST_EQ( *r, 3 );
+    }
+
+    //
+
+    {
+        result< std::unique_ptr<X> > a1( ::make_unique<X>( 1 ) );
+        result< std::unique_ptr<X> > a2( ::make_unique<X>( 2 ) );
+
+        auto r = unwrap_and_invoke( &X::g, std::move( a1 ), std::move( a2 ) );
+        BOOST_TEST( r ) && BOOST_TEST_EQ( *r, 3 );
+    }
+
+    return boost::report_errors();
+}
@@ -0,0 +1,120 @@
+// Copyright 2026 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/unwrap_and_invoke.hpp>
+#include <boost/system/result.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+
+using namespace boost::system;
+
+struct X
+{
+    int v;
+};
+
+struct E
+{
+    int w;
+};
+
+X f1( X x1 )
+{
+    return x1;
+}
+
+X f2( X x1, X x2 )
+{
+    return X{ x1.v + x2.v };
+}
+
+X f3( X x1, X x2, X x3 )
+{
+    return X{ x1.v + x2.v + x3.v };
+}
+
+X f4( X x1, X x2, X x3, X x4 )
+{
+    return X{ x1.v + x2.v + x3.v + x4.v };
+}
+
+int main()
+{
+    {
+        auto r = unwrap_and_invoke( f1, result<X, E>( E{1} ) );
+        BOOST_TEST( !r ) && BOOST_TEST_EQ( r.error().w, 1 );
+    }
+
+    {
+        auto r = unwrap_and_invoke( f1, result<X, E>( X{1} ) );
+        BOOST_TEST( r ) && BOOST_TEST_EQ( r.unsafe_value().v, 1 );
+    }
+
+    //
+
+    {
+        auto r = unwrap_and_invoke( f2, result<X, E>( E{1} ), result<X, E>( E{2} ) );
+        BOOST_TEST( !r ) && BOOST_TEST_EQ( r.error().w, 1 );
+    }
+
+    {
+        auto r = unwrap_and_invoke( f2, result<X, E>( X{1} ), result<X, E>( E{2} ) );
+        BOOST_TEST( !r ) && BOOST_TEST_EQ( r.error().w, 2 );
+    }
+
+    {
+        auto r = unwrap_and_invoke( f2, result<X, E>( X{1} ), result<X, E>( X{2} ) );
+        BOOST_TEST( r ) && BOOST_TEST_EQ( r.unsafe_value().v, 3 );
+    }
+
+    //
+
+    {
+        auto r = unwrap_and_invoke( f3, result<X, E>( E{1} ), result<X, E>( E{2} ), result<X, E>( E{3} ) );
+        BOOST_TEST( !r ) && BOOST_TEST_EQ( r.error().w, 1 );
+    }
+
+    {
+        auto r = unwrap_and_invoke( f3, result<X, E>( X{1} ), result<X, E>( E{2} ), result<X, E>( E{3} ) );
+        BOOST_TEST( !r ) && BOOST_TEST_EQ( r.error().w, 2 );
+    }
+
+    {
+        auto r = unwrap_and_invoke( f3, result<X, E>( X{1} ), result<X, E>( X{2} ), result<X, E>( E{3} ) );
+        BOOST_TEST( !r ) && BOOST_TEST_EQ( r.error().w, 3 );
+    }
+
+    {
+        auto r = unwrap_and_invoke( f3, result<X, E>( X{1} ), result<X, E>( X{2} ), result<X, E>( X{3} ) );
+        BOOST_TEST( r ) && BOOST_TEST_EQ( r.unsafe_value().v, 6 );
+    }
+
+    //
+
+    {
+        auto r = unwrap_and_invoke( f4, result<X, E>( E{1} ), result<X, E>( E{2} ), result<X, E>( E{3} ), result<X, E>( E{4} ) );
+        BOOST_TEST( !r ) && BOOST_TEST_EQ( r.error().w, 1 );
+    }
+
+    {
+        auto r = unwrap_and_invoke( f4, result<X, E>( X{1} ), result<X, E>( E{2} ), result<X, E>( E{3} ), result<X, E>( E{4} ) );
+        BOOST_TEST( !r ) && BOOST_TEST_EQ( r.error().w, 2 );
+    }
+
+    {
+        auto r = unwrap_and_invoke( f4, result<X, E>( X{1} ), result<X, E>( X{2} ), result<X, E>( E{3} ), result<X, E>( E{4} ) );
+        BOOST_TEST( !r ) && BOOST_TEST_EQ( r.error().w, 3 );
+    }
+
+    {
+        auto r = unwrap_and_invoke( f4, result<X, E>( X{1} ), result<X, E>( X{2} ), result<X, E>( X{3} ), result<X, E>( E{4} ) );
+        BOOST_TEST( !r ) && BOOST_TEST_EQ( r.error().w, 4 );
+    }
+
+    {
+        auto r = unwrap_and_invoke( f4, result<X, E>( X{1} ), result<X, E>( X{2} ), result<X, E>( X{3} ), result<X, E>( X{4} ) );
+        BOOST_TEST( r ) && BOOST_TEST_EQ( r.unsafe_value().v, 10 );
+    }
+
+    return boost::report_errors();
+}
@@ -0,0 +1,40 @@
+// Copyright 2026 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/unwrap_and_invoke.hpp>
+#include <boost/system/result.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+using namespace boost::system;
+
+int g_x;
+
+void f( int x )
+{
+    g_x += x;
+}
+
+int main()
+{
+    {
+        g_x = 0;
+
+        result<int> a1( 1 );
+        result<void> r = unwrap_and_invoke( f, a1 );
+
+        BOOST_TEST( r );
+        BOOST_TEST_EQ( g_x, 1 );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<int> a1( ec );
+        result<void> r = unwrap_and_invoke( f, a1 );
+
+        BOOST_TEST( r.has_error() ) && BOOST_TEST_EQ( r.error(), ec );
+    }
+
+    return boost::report_errors();
+}
Author	SHA1	Message	Date
Peter Dimov	8c935dc996	Fix unwrap_and_invoke for functions returning void. Fixes #145 .	2026-05-31 14:34:01 +03:00
Peter Dimov	e6595f0d64	Update .drone.jsonnet	2026-05-01 16:45:55 +03:00
Peter Dimov	48cc883bd3	Add windows-cmake-use to ci.yml	2026-04-30 20:31:59 +03:00
Peter Dimov	a66df030ae	Add posix-cmake-use to ci.yml	2026-04-30 19:36:42 +03:00
Peter Dimov	04ac86837c	Disable -Wformat-truncation in error_category_test(2).cpp under GCC 16	2026-04-30 19:29:54 +03:00
Peter Dimov	080b4e9961	Update ci.yml	2026-04-30 17:06:37 +03:00
Peter Dimov	571076780e	Update cmake_install_test/CMakeLists.txt	2026-04-30 17:02:01 +03:00
Peter Dimov	f80b9ccbf1	Update documentation	2026-03-03 20:14:14 +02:00
Peter Dimov	2db6b8e595	Add unwrap_and_invoke.hpp to boost/system.hpp	2026-03-03 19:36:13 +02:00
Peter Dimov	026862285e	Disable -Wmissing-field-initializers in test/unwrap_and_construct2	2026-02-25 20:02:57 +02:00
Peter Dimov	f7408130d0	Members with initializers make a class non-aggregate in C++11	2026-02-25 19:31:23 +02:00
Peter Dimov	59b11b120d	Disable test/unwrap_and_construct2 when detail::is_aggregate isn't functional	2026-02-25 18:52:28 +02:00
Peter Dimov	8ce9b50730	Support aggregates in unwrap_and_construct	2026-02-25 18:19:49 +02:00
Peter Dimov	700f246dd3	Rename BOOST_SYSTEM_HAS_IS_AGGREGATE to BOOST_SYSTEM_HAS_BUILTIN_IS_AGGREGATE	2026-02-25 17:54:22 +02:00
Peter Dimov	78149b00c6	Disable detail_is_aggregate_test when detail::is_aggregate isn't functional	2026-02-25 17:52:23 +02:00
Peter Dimov	9c1c586a32	Add detail::is_aggregate	2026-02-25 16:52:10 +02:00
Peter Dimov	d9248a93ab	Placate GCC 4.x	2026-02-25 16:40:15 +02:00
Peter Dimov	fa3babf4e6	Add unwrap_and_construct	2026-02-25 14:10:14 +02:00
Peter Dimov	739179a494	Add test/unwrap_and_invoke2.cpp	2026-02-25 02:30:48 +02:00
Peter Dimov	ee43711c1c	std::make_unique is C++14	2026-02-24 20:03:04 +02:00
Peter Dimov	af53bce037	Add unwrap_and_invoke.hpp	2026-02-24 18:59:48 +02:00
Peter Dimov	9fe049b534	Update documentation	2026-02-22 18:33:34 +02:00
Peter Dimov	eceff8b487	Apply Clang 3.5 workarounds properly in test/result_value_access	2026-02-21 12:17:20 +02:00
Peter Dimov	9ead4aeea9	Change operator* and operator-> to throw instead of having a precondition	2026-02-21 03:26:49 +02:00
Peter Dimov	0ff6989330	Add result<>::unsafe_value	2026-02-20 21:26:56 +02:00