Update documentation

Remove dependencies on Boost.StaticAssert

.drone.jsonnet

@@ -32,7 +32,8 @@ local linux_pipeline(name, image, environment, packages = "", sources = [], arch
             commands:
             [
                 'set -e',
-                'wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | apt-key add -',
+                'uname -a',
+                'echo $DRONE_STAGE_MACHINE',
             ] +
             (if sources != [] then [ ('apt-add-repository "' + source + '"') for source in sources ] else []) +
             (if packages != "" then [ 'apt-get update', 'apt-get -y install ' + packages ] else []) +
@@ -189,33 +190,68 @@ local windows_pipeline(name, image, environment, arch = "amd64") =
     ),
 
     linux_pipeline(
-        "Linux 22.04 GCC 12 32 ASAN",
+        "Linux 22.04 GCC 12 32",
         "cppalliance/droneubuntu2204:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++-12', CXXSTD: '11,14,17,20,2b', ADDRMD: '32' } + asan,
+        { TOOLSET: 'gcc', COMPILER: 'g++-12', CXXSTD: '11,14,17,20,2b', ADDRMD: '32' },
         "g++-12-multilib",
     ),
 
     linux_pipeline(
-        "Linux 22.04 GCC 12 64 ASAN",
+        "Linux 22.04 GCC 12 64",
         "cppalliance/droneubuntu2204:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++-12', CXXSTD: '11,14,17,20,2b', ADDRMD: '64' } + asan,
+        { TOOLSET: 'gcc', COMPILER: 'g++-12', CXXSTD: '11,14,17,20,2b', ADDRMD: '64' },
         "g++-12-multilib",
     ),
 
     linux_pipeline(
-        "Linux 23.04 GCC 13 32 UBSAN",
-        "cppalliance/droneubuntu2304:1",
+        "Linux 24.04 GCC 13 32 UBSAN",
+        "cppalliance/droneubuntu2404:1",
         { TOOLSET: 'gcc', COMPILER: 'g++-13', CXXSTD: '11,14,17,20,2b', ADDRMD: '32' } + ubsan,
         "g++-13-multilib",
     ),
 
     linux_pipeline(
-        "Linux 23.04 GCC 13 64 UBSAN",
-        "cppalliance/droneubuntu2304:1",
+        "Linux 24.04 GCC 13 64 UBSAN",
+        "cppalliance/droneubuntu2404:1",
         { TOOLSET: 'gcc', COMPILER: 'g++-13', CXXSTD: '11,14,17,20,2b', ADDRMD: '64' } + ubsan,
         "g++-13-multilib",
     ),
 
+    linux_pipeline(
+        "Linux 24.04 GCC 13 32 ASAN",
+        "cppalliance/droneubuntu2404:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-13', CXXSTD: '11,14,17,20,2b', ADDRMD: '32' } + asan,
+        "g++-13-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 24.04 GCC 14 UBSAN",
+        "cppalliance/droneubuntu2404:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-14', CXXSTD: '11,14,17,20,2b' } + ubsan,
+        "g++-14-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 24.04 GCC 14 ASAN",
+        "cppalliance/droneubuntu2404:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-14', CXXSTD: '11,14,17,20,2b' } + asan,
+        "g++-14-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 25.04 GCC 15 UBSAN",
+        "cppalliance/droneubuntu2504: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",
+        { TOOLSET: 'gcc', COMPILER: 'g++-15', CXXSTD: '11,14,17,20,23,2c' } + asan,
+        "g++-15-multilib",
+    ),
+
     linux_pipeline(
         "Linux 16.04 Clang 3.5",
         "cppalliance/droneubuntu1604:1",
@@ -266,24 +302,66 @@ local windows_pipeline(name, image, environment, arch = "amd64") =
     ),
 
     linux_pipeline(
-        "Linux 23.04 Clang 16",
-        "cppalliance/droneubuntu2304:1",
+        "Linux 24.04 Clang 16",
+        "cppalliance/droneubuntu2404:1",
         { TOOLSET: 'clang', COMPILER: 'clang++-16', CXXSTD: '11,14,17,20,2b' },
         "clang-16",
     ),
 
     linux_pipeline(
-        "Linux 23.10 Clang 17 UBSAN",
-        "cppalliance/droneubuntu2310:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-17', CXXSTD: '11,14,17,20,2b' } + ubsan,
+        "Linux 24.04 Clang 17",
+        "cppalliance/droneubuntu2404:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-17', CXXSTD: '11,14,17,20,2b' },
         "clang-17",
     ),
 
     linux_pipeline(
-        "Linux 23.10 Clang 17 ASAN",
-        "cppalliance/droneubuntu2310:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-17', CXXSTD: '11,14,17,20,2b' } + asan,
-        "clang-17",
+        "Linux 24.04 Clang 18 UBSAN",
+        "cppalliance/droneubuntu2404:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-18', CXXSTD: '11,14,17,20,2b' } + ubsan,
+        "clang-18",
+    ),
+
+    linux_pipeline(
+        "Linux 24.04 Clang 18 ASAN",
+        "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,
+        "clang-19",
+    ),
+
+    linux_pipeline(
+        "Linux 24.04 Clang 19 ASAN",
+        "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,
+        "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",
+        { TOOLSET: 'clang', COMPILER: 'clang++-21', CXXSTD: '11,14,17,20,23,2c' },
+        "clang-21",
     ),
 
     macos_pipeline(
@@ -331,4 +409,10 @@ local windows_pipeline(name, image, environment, arch = "amd64") =
         "cppalliance/dronevs2022:1",
         { TOOLSET: 'msvc-14.3', CXXSTD: '14,17,20,latest' },
     ),
+
+    windows_pipeline(
+        "Windows VS2026 msvc-14.5",
+        "cppalliance/dronevs2026:1",
+        { TOOLSET: 'msvc-14.5', CXXSTD: '14,17,20,latest' },
+    ),
 ]

.github/workflows/ci.yml

@@ -19,152 +19,225 @@ jobs:
         include:
           - toolset: gcc-4.8
             cxxstd: "11"
-            os: ubuntu-latest
             container: ubuntu:18.04
+            os: ubuntu-latest
             install: g++-4.8
           - toolset: gcc-5
             cxxstd: "11,14,1z"
-            os: ubuntu-latest
             container: ubuntu:18.04
+            os: ubuntu-latest
             install: g++-5
           - toolset: gcc-6
             cxxstd: "11,14,1z"
-            os: ubuntu-latest
             container: ubuntu:18.04
+            os: ubuntu-latest
             install: g++-6
           - toolset: gcc-7
             cxxstd: "11,14,17"
-            os: ubuntu-latest
             container: ubuntu:18.04
+            os: ubuntu-latest
           - toolset: gcc-8
             cxxstd: "11,14,17,2a"
-            os: ubuntu-20.04
+            container: ubuntu:20.04
+            os: ubuntu-latest
             install: g++-8
           - toolset: gcc-9
             cxxstd: "11,14,17,2a"
-            os: ubuntu-20.04
+            container: ubuntu:20.04
+            os: ubuntu-latest
           - toolset: gcc-10
             cxxstd: "11,14,17,2a"
-            os: ubuntu-20.04
+            container: ubuntu:20.04
+            os: ubuntu-latest
             install: g++-10
           - toolset: gcc-11
             cxxstd: "11,14,17,2a"
-            os: ubuntu-20.04
-            install: g++-11
+            os: ubuntu-22.04
           - toolset: gcc-12
             cxxstd: "11,14,17,20,2b"
             os: ubuntu-22.04
             install: g++-12
           - toolset: gcc-13
             cxxstd: "11,14,17,20,2b"
+            container: ubuntu:24.04
             os: ubuntu-latest
-            container: ubuntu:23.04
             install: g++-13
+          - toolset: gcc-14
+            cxxstd: "11,14,17,20,2b"
+            container: ubuntu:24.04
+            os: ubuntu-latest
+            install: g++-14
+          - toolset: gcc-15
+            cxxstd: "11,14,17,20,23,2c"
+            container: ubuntu:25.04
+            os: ubuntu-latest
+            install: g++-15
           - toolset: clang
             compiler: clang++-3.9
             cxxstd: "11,14"
-            os: ubuntu-latest
             container: ubuntu:18.04
+            os: ubuntu-latest
             install: clang-3.9
           - toolset: clang
             compiler: clang++-4.0
             cxxstd: "11,14"
-            os: ubuntu-latest
             container: ubuntu:18.04
+            os: ubuntu-latest
             install: clang-4.0
           - toolset: clang
             compiler: clang++-5.0
             cxxstd: "11,14,1z"
-            os: ubuntu-latest
             container: ubuntu:18.04
+            os: ubuntu-latest
             install: clang-5.0
           - toolset: clang
             compiler: clang++-6.0
             cxxstd: "11,14,17"
-            os: ubuntu-20.04
+            container: ubuntu:20.04
+            os: ubuntu-latest
             install: clang-6.0
           - toolset: clang
             compiler: clang++-7
             cxxstd: "11,14,17"
-            os: ubuntu-20.04
-            install: clang-7
+            stdlib: "native,libc++"
+            container: ubuntu:20.04
+            os: ubuntu-latest
+            install: clang-7 libc++-7-dev libc++abi-7-dev
           - toolset: clang
             compiler: clang++-8
             cxxstd: "11,14,17"
-            os: ubuntu-20.04
-            install: clang-8
+            stdlib: "native,libc++"
+            container: ubuntu:20.04
+            os: ubuntu-latest
+            install: clang-8 libc++-8-dev libc++abi-8-dev
           - toolset: clang
             compiler: clang++-9
             cxxstd: "11,14,17"
-            os: ubuntu-20.04
-            install: clang-9
+            stdlib: "native,libc++"
+            container: ubuntu:20.04
+            os: ubuntu-latest
+            install: clang-9 libc++-9-dev libc++abi-9-dev
           - toolset: clang
             compiler: clang++-10
             cxxstd: "11,14,17,2a"
-            os: ubuntu-20.04
+            stdlib: "native,libc++"
+            container: ubuntu:20.04
+            os: ubuntu-latest
+            install: clang-10 libc++-10-dev libc++abi-10-dev
           - toolset: clang
             compiler: clang++-11
             cxxstd: "11,14,17,2a"
-            os: ubuntu-20.04
+            stdlib: "native,libc++"
+            container: ubuntu:20.04
+            os: ubuntu-latest
+            install: clang-11 libc++-11-dev libc++abi-11-dev
           - toolset: clang
             compiler: clang++-12
             cxxstd: "11,14,17,20"
-            os: ubuntu-20.04
+            stdlib: "native,libc++"
+            container: ubuntu:20.04
+            os: ubuntu-latest
+            install: clang-12 libc++-12-dev libc++abi-12-dev
           - toolset: clang
             compiler: clang++-13
             cxxstd: "11,14,17,20,2b"
+            stdlib: "native,libc++"
             container: ubuntu:22.04
             os: ubuntu-latest
-            install: clang-13
+            install: clang-13 libc++-13-dev libc++abi-13-dev
           - toolset: clang
             compiler: clang++-14
             cxxstd: "11,14,17,20,2b"
+            stdlib: "native,libc++"
             container: ubuntu:22.04
             os: ubuntu-latest
-            install: clang-14
+            install: clang-14 libc++-14-dev libc++abi-14-dev
           - toolset: clang
             compiler: clang++-15
             cxxstd: "11,14,17,20,2b"
             container: ubuntu:22.04
+            stdlib: "native,libc++"
             os: ubuntu-latest
-            install: clang-15
+            install: clang-15 libc++-15-dev libc++abi-15-dev
           - toolset: clang
             compiler: clang++-16
             cxxstd: "11,14,17,20,2b"
-            container: ubuntu:23.04
+            stdlib: "native,libc++"
+            container: ubuntu:24.04
             os: ubuntu-latest
-            install: clang-16
+            install: clang-16 libc++-16-dev libc++abi-16-dev
           - toolset: clang
             compiler: clang++-17
             cxxstd: "11,14,17,20,2b"
-            container: ubuntu:23.10
+            stdlib: "native,libc++"
+            container: ubuntu:24.04
             os: ubuntu-latest
-            install: clang-17
+            install: clang-17 libc++-17-dev libc++abi-17-dev
           - toolset: clang
-            cxxstd: "11,14,17,2a"
-            os: macos-11
+            compiler: clang++-18
+            cxxstd: "11,14,17,20,2b"
+            stdlib: "native,libc++"
+            container: ubuntu:24.04
+            os: ubuntu-latest
+            install: clang-18 libc++-18-dev libc++abi-18-dev
+          - toolset: clang
+            compiler: clang++-19
+            cxxstd: "11,14,17,20,2b"
+            stdlib: "native,libc++"
+            container: ubuntu:24.04
+            os: ubuntu-latest
+            install: clang-19 libc++-19-dev libc++abi-19-dev
+          - toolset: clang
+            compiler: clang++-20
+            cxxstd: "11,14,17,20,23,2c"
+            stdlib: "native,libc++"
+            container: ubuntu:24.04
+            os: ubuntu-latest
+            install: clang-20 libc++-20-dev libc++abi-20-dev
+          - toolset: clang
+            compiler: clang++-21
+            cxxstd: "11,14,17,20,23,2c"
+            stdlib: "native,libc++"
+            container: ubuntu:25.10
+            os: ubuntu-latest
+            install: clang-21 libc++-21-dev libc++abi-21-dev
           - toolset: clang
             cxxstd: "11,14,17,20,2b"
-            os: macos-12
+            os: macos-14
           - toolset: clang
             cxxstd: "11,14,17,20,2b"
-            os: macos-13
+            os: macos-15
+          - toolset: clang
+            cxxstd: "11,14,17,20,23,2c"
+            os: macos-26
 
     runs-on: ${{matrix.os}}
-    container: ${{matrix.container}}
+
+    container:
+      image: ${{matrix.container}}
+      volumes:
+        - /node20217:/node20217:rw,rshared
+        - ${{ startsWith(matrix.container, 'ubuntu:1') && '/node20217:/__e/node20:ro,rshared' || ' ' }}
 
     defaults:
       run:
         shell: bash
 
     steps:
-      - uses: actions/checkout@v3
-
       - name: Setup container environment
         if: matrix.container
         run: |
           apt-get update
-          apt-get -y install sudo python3 git g++
+          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
 
       - name: Install packages
         if: matrix.install
@@ -202,21 +275,13 @@ jobs:
       - name: Run tests
         run: |
           cd ../boost-root
-          ./b2 -j3 libs/$LIBRARY/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} variant=debug,release
+          ./b2 -j3 libs/$LIBRARY/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} variant=debug,release ${{ matrix.stdlib && format('stdlib={0}', matrix.stdlib) }}
 
   windows:
     strategy:
       fail-fast: false
       matrix:
         include:
-          - toolset: msvc-14.0
-            cxxstd: "14"
-            addrmd: 32,64
-            os: windows-2019
-          - toolset: msvc-14.2
-            cxxstd: "14,17,20,latest"
-            addrmd: 32,64
-            os: windows-2019
           - toolset: msvc-14.3
             cxxstd: "14,17,20,latest"
             addrmd: 32,64
@@ -228,7 +293,7 @@ jobs:
           - toolset: gcc
             cxxstd: "11,14,17,2a"
             addrmd: 64
-            os: windows-2019
+            os: windows-2022
 
     runs-on: ${{matrix.os}}
 
@@ -268,11 +333,8 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          - os: ubuntu-20.04
-          - os: ubuntu-22.04
-          - os: macos-11
-          - os: macos-12
-          - os: macos-13
+          - os: ubuntu-latest
+          - os: macos-latest
 
     runs-on: ${{matrix.os}}
 
@@ -316,11 +378,8 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          - os: ubuntu-20.04
-          - os: ubuntu-22.04
-          - os: macos-11
-          - os: macos-12
-          - os: macos-13
+          - os: ubuntu-latest
+          - os: macos-latest
 
     runs-on: ${{matrix.os}}
 
@@ -374,11 +433,8 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          - os: ubuntu-20.04
-          - os: ubuntu-22.04
-          - os: macos-11
-          - os: macos-12
-          - os: macos-13
+          - os: ubuntu-latest
+          - os: macos-latest
 
     runs-on: ${{matrix.os}}
 
@@ -430,8 +486,7 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          - os: windows-2019
-          - os: windows-2022
+          - os: windows-latest
 
     runs-on: ${{matrix.os}}
 
@@ -479,8 +534,7 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          - os: windows-2019
-          - os: windows-2022
+          - os: windows-latest
 
     runs-on: ${{matrix.os}}
 
@@ -546,8 +600,7 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          - os: windows-2019
-          - os: windows-2022
+          - os: windows-latest
 
     runs-on: ${{matrix.os}}
 

CMakeLists.txt

@@ -2,7 +2,7 @@
 # Distributed under the Boost Software License, Version 1.0.
 # https://www.boost.org/LICENSE_1_0.txt
 
-cmake_minimum_required(VERSION 3.8...3.20)
+cmake_minimum_required(VERSION 3.8...3.31)
 
 project(boost_system VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX)
 
@@ -14,6 +14,7 @@ target_include_directories(boost_system INTERFACE include)
 target_link_libraries(boost_system
   INTERFACE
     Boost::assert
+    Boost::compat
     Boost::config
     Boost::throw_exception
     Boost::variant2
@@ -22,7 +23,7 @@ target_link_libraries(boost_system
 
 target_compile_features(boost_system INTERFACE cxx_std_11)
 
-if(CMAKE_VERSION VERSION_GREATER 3.18 AND CMAKE_GENERATOR MATCHES "Visual Studio")
+if(NOT CMAKE_VERSION VERSION_LESS 3.19 AND CMAKE_GENERATOR MATCHES "Visual Studio")
 
   file(GLOB_RECURSE boost_system_IDEFILES CONFIGURE_DEPENDS include/*.hpp)
   source_group(TREE ${PROJECT_SOURCE_DIR}/include FILES ${boost_system_IDEFILES} PREFIX "Header Files")

build.jam

@@ -0,0 +1,26 @@
+# Copyright 2023-2024 René Ferdinand Rivera Morell
+# Copyright 2024 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# https://www.boost.org/LICENSE_1_0.txt
+
+require-b2 5.2 ;
+
+constant boost_dependencies :
+    /boost/assert//boost_assert
+    /boost/compat//boost_compat
+    /boost/config//boost_config
+    /boost/throw_exception//boost_throw_exception
+    /boost/variant2//boost_variant2
+    /boost/winapi//boost_winapi
+    ;
+
+project /boost/system ;
+
+explicit
+    [ alias boost_system : : : : <include>include <library>$(boost_dependencies) ]
+    [ alias all : boost_system test ]
+    ;
+
+call-if : boost-library system
+    : install boost_system
+    ;

build/Jamfile.v2

@@ -1,25 +0,0 @@
-# Boost System Library Build Jamfile
-
-# (C) Copyright Beman Dawes 2002, 2006
-
-# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or www.boost.org/LICENSE_1_0.txt)
-
-# See library home page at https://www.boost.org/libs/system
-
-project boost/system
-    : source-location ../src
-    : usage-requirements  # pass these requirement to dependents (i.e. users)
-      <link>shared:<define>BOOST_SYSTEM_DYN_LINK=1
-      <link>static:<define>BOOST_SYSTEM_STATIC_LINK=1
-    ;
-
-SOURCES = error_code ;
-
-lib boost_system
-   : $(SOURCES).cpp
-   : <link>shared:<define>BOOST_SYSTEM_DYN_LINK=1
-     <link>static:<define>BOOST_SYSTEM_STATIC_LINK=1
-   ;
-
-boost-install boost_system ;

doc/system/changes.adoc

@@ -1,5 +1,5 @@
 ////
-Copyright 2018-2022 Peter Dimov
+Copyright 2018-2025 Peter Dimov
 Distributed under the Boost Software License, Version 1.0.
 https://www.boost.org/LICENSE_1_0.txt
 ////
@@ -8,6 +8,33 @@ https://www.boost.org/LICENSE_1_0.txt
 # Revision History
 :idprefix:
 
+## Changes in Boost 1.91
+
+* The return type of `operator|(result<T&>, U)` has been changed to non-reference.
+* Pointers to members in `r & f` are now supported (by using `boost::compat::invoke`).
+* 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
+
+* The stub compiled library has been removed; System has been header-only since release 1.69.
++
+This may affect `CMakeLists.txt` files containing `find_package(Boost COMPONENTS system ...)`.
+The easiest fix is to just remove `system` from the list of components as it's no longer required.
+If compatibility with Boost releases earlier than 1.69 is to be preserved, one can use
+`find_package(Boost COMPONENTS ... OPTIONAL_COMPONENTS system)`.
+
+## Changes in Boost 1.86
+
+* Support `result<T> & fv`, where `fv` returns `void`.
+* Support `result<void> &= fv;`, where `fv` returns `void`.
+
 ## Changes in Boost 1.85
 
 * {cpp}03 is no longer supported; a {cpp}11 compiler is required. (This includes GCC 4.8 or later, and MSVC 14.0 (VS 2015) or later.)

doc/system/reference.adoc

@@ -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
 
@@ -2518,8 +2556,8 @@ Returns: ::
 #### operator|
 
 ```
-template<class T, class E, class U> T operator|( result<T, E> const& r, U&& u );
-template<class T, class E, class U> T operator|( result<T, E>&& r, U&& u );
+template<class T, class E, class U> std::decay_t<T> operator|( result<T, E> const& r, U&& u );
+template<class T, class E, class U> std::decay_t<T> operator|( result<T, E>&& r, U&& u );
 ```
 [none]
 * {blank}
@@ -2530,7 +2568,7 @@ Effects: ::
   - If `r.has_value()` is `true`, returns `*r`.
   - Otherwise, returns `u`.
 Remarks: ::
-  Only enabled when `U` is convertible to `T`.
+  Only enabled when `U` is convertible to `std::decay_t<T>`.
 Example: ::
 +
 ```
@@ -2545,6 +2583,7 @@ int get_port()
 ```
 template<class T, class E, class F> T operator|( result<T, E> const& r, F&& f );
 template<class T, class E, class F> T operator|( result<T, E>&& r, F&& f );
+template<class T, class E, class F> std::decay_t<T> operator|( result<T&, E> const& r, F&& f );
 ```
 [none]
 * {blank}
@@ -2556,7 +2595,7 @@ Effects: ::
   - If `r.has_value()` is `true`, returns `*r`.
   - Otherwise, returns `f()`.
 Remarks: ::
-  Only enabled when `f()` is convertible to `T`.
+  Only enabled when `f()` is convertible to `T`, or, when `T` is a reference, to `std::decay_t<T>`.
 Example: ::
 +
 ```
@@ -2872,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.

extra/boost_system.natvis

@@ -12,10 +12,10 @@
     <Type Name="boost::system::error_code">
         <DisplayString Condition="lc_flags_ == 0">{d1_.val_} [system] ✓</DisplayString>
 
-        <DisplayString Condition="lc_flags_ == 1 &amp;&amp; ((std::error_code*)d2_)->_Mycat->_Addr==1">{((std::error_code*)d2_)->_Myval} [std:future]</DisplayString>
-        <DisplayString Condition="lc_flags_ == 1 &amp;&amp; ((std::error_code*)d2_)->_Mycat->_Addr==3">{((std::error_code*)d2_)->_Myval} [std:generic]</DisplayString>
-        <DisplayString Condition="lc_flags_ == 1 &amp;&amp; ((std::error_code*)d2_)->_Mycat->_Addr==5">{((std::error_code*)d2_)->_Myval} [std:iostream]</DisplayString>
-        <DisplayString Condition="lc_flags_ == 1 &amp;&amp; ((std::error_code*)d2_)->_Mycat->_Addr==7">{((std::error_code*)d2_)->_Myval} [std:system]</DisplayString>
+        <DisplayString Condition="lc_flags_ == 1 &amp;&amp; ((std::error_code*)d2_)->_Mycat->_Addr._Num==1">{((std::error_code*)d2_)->_Myval} [std:future]</DisplayString>
+        <DisplayString Condition="lc_flags_ == 1 &amp;&amp; ((std::error_code*)d2_)->_Mycat->_Addr._Num==3">{((std::error_code*)d2_)->_Myval} [std:generic]</DisplayString>
+        <DisplayString Condition="lc_flags_ == 1 &amp;&amp; ((std::error_code*)d2_)->_Mycat->_Addr._Num==5">{((std::error_code*)d2_)->_Myval} [std:iostream]</DisplayString>
+        <DisplayString Condition="lc_flags_ == 1 &amp;&amp; ((std::error_code*)d2_)->_Mycat->_Addr._Num==7">{((std::error_code*)d2_)->_Myval} [std:system]</DisplayString>
         <DisplayString Condition="lc_flags_ == 1">{((std::error_code*)d2_)->_Myval} std@{((uintptr_t)((std::error_code*)d2_)->_Mycat),x}</DisplayString>
 
         <DisplayString Condition="d1_.cat_->id_ == 0xb2ab117a257edfd0 &amp;&amp;

include/boost/system.hpp

@@ -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

include/boost/system/api_config.hpp

@@ -33,7 +33,7 @@
 //    Standalone MinGW and all other known Windows compilers do predefine _WIN32
 //    Compilers that predefine _WIN32 or __MINGW32__ do so for Windows 64-bit builds too.
 
-# if defined(_WIN32) || defined(__CYGWIN__) // Windows default, including MinGW and Cygwin
+# if defined(_WIN32) // Windows default, including MinGW
 #   define BOOST_WINDOWS_API
 # else
 #   define BOOST_POSIX_API 

include/boost/system/detail/config.hpp

@@ -38,6 +38,22 @@
 # define BOOST_SYSTEM_CONSTEXPR
 #endif
 
+// BOOST_SYSTEM_HAS_CXX20_CONSTEXPR
+
+#if defined(__cpp_constexpr) && __cpp_constexpr >= 201907L
+# define BOOST_SYSTEM_HAS_CXX20_CONSTEXPR
+#endif
+
+#if BOOST_WORKAROUND(BOOST_CLANG_VERSION, < 110000)
+# undef BOOST_SYSTEM_HAS_CXX20_CONSTEXPR
+#endif
+
+#if defined(BOOST_SYSTEM_HAS_CXX20_CONSTEXPR)
+# define BOOST_SYSTEM_CXX20_CONSTEXPR constexpr
+#else
+# define BOOST_SYSTEM_CXX20_CONSTEXPR
+#endif
+
 // BOOST_SYSTEM_DEPRECATED
 
 #if defined(__clang__)

include/boost/system/detail/error_category.hpp

@@ -94,31 +94,31 @@ protected:
 
 public:
 
-    virtual const char * name() const noexcept = 0;
+    virtual const char* name() const noexcept = 0;
 
-    virtual error_condition default_error_condition( int ev ) const noexcept;
-    virtual bool equivalent( int code, const error_condition & condition ) const noexcept;
-    virtual bool equivalent( const error_code & code, int condition ) const noexcept;
+    BOOST_SYSTEM_CXX20_CONSTEXPR virtual error_condition default_error_condition( int ev ) const noexcept;
+    BOOST_SYSTEM_CXX20_CONSTEXPR virtual bool equivalent( int code, error_condition const& condition ) const noexcept;
+    BOOST_SYSTEM_CXX20_CONSTEXPR virtual bool equivalent( error_code const& code, int condition ) const noexcept;
 
     virtual std::string message( int ev ) const = 0;
-    virtual char const * message( int ev, char * buffer, std::size_t len ) const noexcept;
+    virtual char const* message( int ev, char* buffer, std::size_t len ) const noexcept;
 
-    virtual bool failed( int ev ) const noexcept
+    BOOST_SYSTEM_CXX20_CONSTEXPR virtual bool failed( int ev ) const noexcept
     {
         return ev != 0;
     }
 
-    friend BOOST_SYSTEM_CONSTEXPR bool operator==( error_category const & lhs, error_category const & rhs ) noexcept
+    friend BOOST_SYSTEM_CONSTEXPR bool operator==( error_category const& lhs, error_category const& rhs ) noexcept
     {
         return rhs.id_ == 0? &lhs == &rhs: lhs.id_ == rhs.id_;
     }
 
-    friend BOOST_SYSTEM_CONSTEXPR bool operator!=( error_category const & lhs, error_category const & rhs ) noexcept
+    friend BOOST_SYSTEM_CONSTEXPR bool operator!=( error_category const& lhs, error_category const& rhs ) noexcept
     {
         return !( lhs == rhs );
     }
 
-    friend BOOST_SYSTEM_CONSTEXPR bool operator<( error_category const & lhs, error_category const & rhs ) noexcept
+    friend BOOST_SYSTEM_CONSTEXPR bool operator<( error_category const& lhs, error_category const& rhs ) noexcept
     {
         if( lhs.id_ < rhs.id_ )
         {
@@ -135,15 +135,15 @@ public:
             return false; // equal
         }
 
-        return std::less<error_category const *>()( &lhs, &rhs );
+        return std::less<error_category const*>()( &lhs, &rhs );
     }
 
     void init_stdcat() const;
 
 # if defined(__SUNPRO_CC) // trailing __global is not supported
-    operator std::error_category const & () const;
+    operator std::error_category const& () const;
 # else
-    operator std::error_category const & () const BOOST_SYMBOL_VISIBLE;
+    operator std::error_category const& () const BOOST_SYMBOL_VISIBLE;
 # endif
 };
 
@@ -162,7 +162,7 @@ static const boost::ulong_long_type generic_category_id = ( boost::ulong_long_ty
 static const boost::ulong_long_type system_category_id = generic_category_id + 1;
 static const boost::ulong_long_type interop_category_id = generic_category_id + 2;
 
-BOOST_SYSTEM_CONSTEXPR inline bool failed_impl( int ev, error_category const & cat )
+BOOST_SYSTEM_CONSTEXPR inline bool failed_impl( int ev, error_category const& cat )
 {
     if( cat.id_ == system_category_id || cat.id_ == generic_category_id )
     {

include/boost/system/detail/error_category_impl.hpp

@@ -26,22 +26,22 @@ namespace system
 
 // error_category default implementation
 
-inline error_condition error_category::default_error_condition( int ev ) const noexcept
+BOOST_SYSTEM_CXX20_CONSTEXPR inline error_condition error_category::default_error_condition( int ev ) const noexcept
 {
     return error_condition( ev, *this );
 }
 
-inline bool error_category::equivalent( int code, const error_condition & condition ) const noexcept
+BOOST_SYSTEM_CXX20_CONSTEXPR inline bool error_category::equivalent( int code, error_condition const& condition ) const noexcept
 {
     return default_error_condition( code ) == condition;
 }
 
-inline bool error_category::equivalent( const error_code & code, int condition ) const noexcept
+BOOST_SYSTEM_CXX20_CONSTEXPR inline bool error_category::equivalent( error_code const& code, int condition ) const noexcept
 {
     return code.equals( condition, *this );
 }
 
-inline char const * error_category::message( int ev, char * buffer, std::size_t len ) const noexcept
+inline char const* error_category::message( int ev, char* buffer, std::size_t len ) const noexcept
 {
     if( len == 0 )
     {
@@ -116,7 +116,7 @@ inline void error_category::init_stdcat() const
 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
 #endif
 
-inline BOOST_NOINLINE error_category::operator std::error_category const & () const
+inline BOOST_NOINLINE error_category::operator std::error_category const& () const
 {
     if( id_ == detail::generic_category_id )
     {

include/boost/system/detail/generic_category_message.hpp

@@ -39,7 +39,19 @@ inline char const * strerror_r_helper( int r, char const * buffer ) noexcept
 
 inline char const * generic_error_category_message( int ev, char * buffer, std::size_t len ) noexcept
 {
-    return strerror_r_helper( strerror_r( ev, buffer, len ), buffer );
+    if( buffer != nullptr )
+    {
+        return strerror_r_helper( strerror_r( ev, buffer, len ), buffer );
+    }
+    else
+    {
+        // strerror_r requires non-null buffer pointer
+
+        char tmp[ 1 ] = {};
+        char const* r = strerror_r_helper( strerror_r( ev, tmp, 0 ), buffer );
+
+        return r == tmp? nullptr: r;
+    }
 }
 
 inline std::string generic_error_category_message( int ev )

include/boost/system/detail/is_aggregate.hpp

@@ -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

include/boost/system/detail/system_category_message_win32.hpp

@@ -73,7 +73,7 @@ inline char const * system_category_message_win32( int ev, char * buffer, std::s
         DWORD_ retval = boost::winapi::FormatMessageA(
             FORMAT_MESSAGE_FROM_SYSTEM_ | FORMAT_MESSAGE_IGNORE_INSERTS_,
             NULL,
-            ev,
+            static_cast<DWORD_>(ev),
             MAKELANGID_( LANG_NEUTRAL_, SUBLANG_DEFAULT_ ), // Default language
             buffer,
             static_cast<DWORD_>( len ),
@@ -94,7 +94,7 @@ inline char const * system_category_message_win32( int ev, char * buffer, std::s
         DWORD_ retval = boost::winapi::FormatMessageW(
             FORMAT_MESSAGE_ALLOCATE_BUFFER_ | FORMAT_MESSAGE_FROM_SYSTEM_ | FORMAT_MESSAGE_IGNORE_INSERTS_,
             NULL,
-            ev,
+            static_cast<DWORD_>(ev),
             MAKELANGID_( LANG_NEUTRAL_, SUBLANG_DEFAULT_ ), // Default language
             (LPWSTR_) &lpMsgBuf,
             0,
@@ -152,7 +152,7 @@ inline std::string system_category_message_win32( int ev )
     DWORD_ retval = boost::winapi::FormatMessageW(
         FORMAT_MESSAGE_ALLOCATE_BUFFER_ | FORMAT_MESSAGE_FROM_SYSTEM_ | FORMAT_MESSAGE_IGNORE_INSERTS_,
         NULL,
-        ev,
+        static_cast<DWORD_>(ev),
         MAKELANGID_( LANG_NEUTRAL_, SUBLANG_DEFAULT_ ), // Default language
         (LPWSTR_) &lpMsgBuf,
         0,
@@ -176,7 +176,7 @@ inline std::string system_category_message_win32( int ev )
         return unknown_message_win32( ev );
     }
 
-    std::string buffer( r, char() );
+    std::string buffer( static_cast<std::size_t>(r), char() );
 
     r = boost::winapi::WideCharToMultiByte( code_page, 0, lpMsgBuf, -1, &buffer[0], r, NULL, NULL );
 
@@ -187,12 +187,12 @@ inline std::string system_category_message_win32( int ev )
 
     --r; // exclude null terminator
 
-    while( r > 0 && ( buffer[ r-1 ] == '\n' || buffer[ r-1 ] == '\r' ) )
+    while( r > 0 && ( buffer[ static_cast<std::size_t>(r)-1 ] == '\n' || buffer[ static_cast<std::size_t>(r)-1 ] == '\r' ) )
     {
         --r;
     }
 
-    if( r > 0 && buffer[ r-1 ] == '.' )
+    if( r > 0 && buffer[ static_cast<std::size_t>(r)-1 ] == '.' )
     {
         --r;
     }

include/boost/system/result.hpp

@@ -1,7 +1,7 @@
 #ifndef BOOST_SYSTEM_RESULT_HPP_INCLUDED
 #define BOOST_SYSTEM_RESULT_HPP_INCLUDED
 
-// Copyright 2017, 2021, 2022 Peter Dimov.
+// Copyright 2017, 2021-2025 Peter Dimov.
 // Distributed under the Boost Software License, Version 1.0.
 // https://www.boost.org/LICENSE_1_0.txt
 
@@ -10,6 +10,7 @@
 #include <boost/system/detail/error_code.hpp>
 #include <boost/system/detail/error_category_impl.hpp>
 #include <boost/variant2/variant.hpp>
+#include <boost/compat/invoke.hpp>
 #include <boost/throw_exception.hpp>
 #include <boost/assert/source_location.hpp>
 #include <boost/assert.hpp>
@@ -204,7 +205,7 @@ public:
     {
         if( r2 )
         {
-            v_.template emplace<0>( *r2 );
+            v_.template emplace<0>( r2.unsafe_value() );
         }
     }
 
@@ -223,7 +224,7 @@ public:
     {
         if( r2 )
         {
-            v_.template emplace<0>( std::move( *r2 ) );
+            v_.template emplace<0>( std::move( r2 ).unsafe_value() );
         }
     }
 
@@ -316,85 +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*()
     {
-        T* p = operator->();
-
-        BOOST_ASSERT( p != 0 );
-
-        return *p;
+        return value();
     }
 
-    BOOST_CXX14_CONSTEXPR T const& operator*() const noexcept
+    BOOST_CXX14_CONSTEXPR T const& operator*() const
     {
-        T const* p = operator->();
-
-        BOOST_ASSERT( p != 0 );
-
-        return *p;
+        return value();
     }
 
 #else
 
-    BOOST_CXX14_CONSTEXPR T& operator*() & noexcept
+    BOOST_CXX14_CONSTEXPR T& operator*() &
     {
-        T* p = operator->();
-
-        BOOST_ASSERT( p != 0 );
-
-        return *p;
+        return value();
     }
 
-    BOOST_CXX14_CONSTEXPR T const& operator*() const & noexcept
+    BOOST_CXX14_CONSTEXPR T const& operator*() const &
     {
-        T const* p = operator->();
-
-        BOOST_ASSERT( p != 0 );
-
-        return *p;
+        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
@@ -461,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
     {
@@ -592,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() );
     }
@@ -794,7 +852,7 @@ public:
     {
         if( r2 )
         {
-            this->emplace( *r2 );
+            this->emplace( r2.unsafe_value() );
         }
     }
 
@@ -829,20 +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
     {
-        U* p = operator->();
+        return value();
+    }
 
-        BOOST_ASSERT( p != 0 );
+    // unchecked value access
 
-        return *p;
+    BOOST_CXX14_CONSTEXPR U& unsafe_value() const
+    {
+        BOOST_ASSERT( has_value() );
+        return *( has_value()? variant2::unsafe_get<0>( v_ ): 0 );
     }
 
     // error access
@@ -887,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 )
@@ -934,13 +996,14 @@ template<class T, class E> struct is_result< result<T, E> >: std::true_type {};
 // result | value
 
 template<class T, class E, class U,
-    class En = typename std::enable_if<detail::is_value_convertible_to<U, T>::value>::type
+    class En = typename std::enable_if<std::is_convertible<U, typename std::decay<T>::type>::value>::type
 >
-T operator|( result<T, E> const& r, U&& u )
+typename std::decay<T>::type
+operator|( result<T, E> const& r, U&& u )
 {
     if( r )
     {
-        return *r;
+        return r.unsafe_value();
     }
     else
     {
@@ -949,13 +1012,14 @@ T operator|( result<T, E> const& r, U&& u )
 }
 
 template<class T, class E, class U,
-    class En = typename std::enable_if<detail::is_value_convertible_to<U, T>::value>::type
+    class En = typename std::enable_if<std::is_convertible<U, typename std::decay<T>::type>::value>::type
 >
-T operator|( result<T, E>&& r, U&& u )
+typename std::decay<T>::type
+operator|( result<T, E>&& r, U&& u )
 {
     if( r )
     {
-        return *std::move( r );
+        return std::move( r ).unsafe_value();
     }
     else
     {
@@ -973,7 +1037,7 @@ T operator|( result<T, E> const& r, F&& f )
 {
     if( r )
     {
-        return *r;
+        return r.unsafe_value();
     }
     else
     {
@@ -989,7 +1053,27 @@ T operator|( result<T, E>&& r, F&& f )
 {
     if( r )
     {
-        return *std::move( r );
+        return std::move( r ).unsafe_value();
+    }
+    else
+    {
+        return std::forward<F>( f )();
+    }
+}
+
+template<class T, class E, class F,
+    class U = decltype( std::declval<F>()() ),
+    class En = typename std::enable_if<
+        std::is_convertible<U, typename std::decay<T>::type>::value &&
+        !detail::is_value_convertible_to<U, T&>::value
+    >::type
+>
+typename std::decay<T>::type
+operator|( result<T&, E> const& r, F&& f )
+{
+    if( r )
+    {
+        return r.unsafe_value();
     }
     else
     {
@@ -1008,7 +1092,7 @@ U operator|( result<T, E> const& r, F&& f )
 {
     if( r )
     {
-        return *r;
+        return r.unsafe_value();
     }
     else
     {
@@ -1025,7 +1109,7 @@ U operator|( result<T, E>&& r, F&& f )
 {
     if( r )
     {
-        return *std::move( r );
+        return std::move( r ).unsafe_value();
     }
     else
     {
@@ -1123,7 +1207,24 @@ result<T, E>& operator|=( result<T, E>& r, F&& f )
 // result & unary-returning-value
 
 template<class T, class E, class F,
-    class U = decltype( std::declval<F>()( std::declval<T const&>() ) ),
+    class U = compat::invoke_result_t<F, T&>,
+    class En1 = typename std::enable_if<!detail::is_result<U>::value>::type,
+    class En2 = typename std::enable_if<!std::is_void<U>::value>::type
+>
+result<U, E> operator&( result<T, E>& r, F&& f )
+{
+    if( r.has_error() )
+    {
+        return r.error();
+    }
+    else
+    {
+        return compat::invoke( std::forward<F>( f ), r.unsafe_value() );
+    }
+}
+
+template<class T, class E, class F,
+    class U = compat::invoke_result_t<F, T const&>,
     class En1 = typename std::enable_if<!detail::is_result<U>::value>::type,
     class En2 = typename std::enable_if<!std::is_void<U>::value>::type
 >
@@ -1135,12 +1236,12 @@ result<U, E> operator&( result<T, E> const& r, F&& f )
     }
     else
     {
-        return std::forward<F>( f )( *r );
+        return compat::invoke( std::forward<F>( f ), r.unsafe_value() );
     }
 }
 
 template<class T, class E, class F,
-    class U = decltype( std::declval<F>()( std::declval<T>() ) ),
+    class U = typename std::decay< compat::invoke_result_t<F, T> >::type,
     class En1 = typename std::enable_if<!detail::is_result<U>::value>::type,
     class En2 = typename std::enable_if<!std::is_void<U>::value>::type
 >
@@ -1152,12 +1253,29 @@ result<U, E> operator&( result<T, E>&& r, F&& f )
     }
     else
     {
-        return std::forward<F>( f )( *std::move( r ) );
+        return compat::invoke( std::forward<F>( f ), std::move( r ).unsafe_value() );
     }
 }
 
 template<class T, class E, class F,
-    class U = decltype( std::declval<F>()( std::declval<T const&>() ) ),
+    class U = compat::invoke_result_t<F, T&>,
+    class En1 = typename std::enable_if<!detail::is_result<U>::value>::type,
+    class En2 = typename std::enable_if<!std::is_void<U>::value>::type
+>
+result<U, E> operator&( result<T&, E>&& r, F&& f )
+{
+    if( r.has_error() )
+    {
+        return r.error();
+    }
+    else
+    {
+        return compat::invoke( std::forward<F>( f ), std::move( r ).unsafe_value() );
+    }
+}
+
+template<class T, class E, class F,
+    class U = compat::invoke_result_t<F, T const&>,
     class En = typename std::enable_if<std::is_void<U>::value>::type
 >
 result<U, E> operator&( result<T, E> const& r, F&& f )
@@ -1168,13 +1286,13 @@ result<U, E> operator&( result<T, E> const& r, F&& f )
     }
     else
     {
-        std::forward<F>( f )( *r );
+        compat::invoke( std::forward<F>( f ), r.unsafe_value() );
         return {};
     }
 }
 
 template<class T, class E, class F,
-    class U = decltype( std::declval<F>()( std::declval<T>() ) ),
+    class U = compat::invoke_result_t<F, T>,
     class En = typename std::enable_if<std::is_void<U>::value>::type
 >
 result<U, E> operator&( result<T, E>&& r, F&& f )
@@ -1185,7 +1303,7 @@ result<U, E> operator&( result<T, E>&& r, F&& f )
     }
     else
     {
-        std::forward<F>( f )( *std::move( r ) );
+        compat::invoke( std::forward<F>( f ), std::move( r ).unsafe_value() );
         return {};
     }
 }
@@ -1227,7 +1345,24 @@ result<U, E> operator&( result<void, E> const& r, F&& f )
 // result & unary-returning-result
 
 template<class T, class E, class F,
-    class U = decltype( std::declval<F>()( std::declval<T const&>() ) ),
+    class U = typename std::decay< compat::invoke_result_t<F, T&> >::type,
+    class En1 = typename std::enable_if<detail::is_result<U>::value>::type,
+    class En2 = typename std::enable_if<std::is_convertible<E, typename U::error_type>::value>::type
+>
+U operator&( result<T, E>& r, F&& f )
+{
+    if( r.has_error() )
+    {
+        return r.error();
+    }
+    else
+    {
+        return compat::invoke( std::forward<F>( f ), r.unsafe_value() );
+    }
+}
+
+template<class T, class E, class F,
+    class U = typename std::decay< compat::invoke_result_t<F, T const&> >::type,
     class En1 = typename std::enable_if<detail::is_result<U>::value>::type,
     class En2 = typename std::enable_if<std::is_convertible<E, typename U::error_type>::value>::type
 >
@@ -1239,12 +1374,12 @@ U operator&( result<T, E> const& r, F&& f )
     }
     else
     {
-        return std::forward<F>( f )( *r );
+        return compat::invoke( std::forward<F>( f ), r.unsafe_value() );
     }
 }
 
 template<class T, class E, class F,
-    class U = decltype( std::declval<F>()( std::declval<T>() ) ),
+    class U = typename std::decay< compat::invoke_result_t<F, T> >::type,
     class En1 = typename std::enable_if<detail::is_result<U>::value>::type,
     class En2 = typename std::enable_if<std::is_convertible<E, typename U::error_type>::value>::type
 >
@@ -1256,7 +1391,7 @@ U operator&( result<T, E>&& r, F&& f )
     }
     else
     {
-        return std::forward<F>( f )( *std::move( r ) );
+        return compat::invoke( std::forward<F>( f ), std::move( r ).unsafe_value() );
     }
 }
 
@@ -1290,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;
@@ -1322,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;

include/boost/system/unwrap_and_invoke.hpp

@@ -0,0 +1,124 @@
+#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>...>
+>
+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) )... );
+}
+
+// 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

src/error_code.cpp

@@ -1,31 +0,0 @@
-//  error_code stub implementation, for compatibility only
-
-//  Copyright Beman Dawes 2002, 2006
-//  Copyright Peter Dimov 2018
-
-//  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)
-
-//  See library home page at http://www.boost.org/libs/system
-
-//----------------------------------------------------------------------------//
-
-// define BOOST_SYSTEM_SOURCE so that <boost/system/config.hpp> knows
-// the library is being built (possibly exporting rather than importing code)
-#define BOOST_SYSTEM_SOURCE
-
-#include <boost/system/config.hpp>
-
-namespace boost
-{
-
-namespace system
-{
-
-BOOST_SYSTEM_DECL void dummy_exported_function()
-{
-}
-
-} // namespace system
-
-} // namespace boost

test/CMakeLists.txt

@@ -27,7 +27,7 @@ macro(lib name macro)
 
 endmacro()
 
-set(BOOST_TEST_LINK_LIBRARIES Boost::system Boost::core Boost::static_assert)
+set(BOOST_TEST_LINK_LIBRARIES Boost::system Boost::config Boost::core)
 
 boost_test(SOURCES quick.cpp)
 
@@ -135,6 +135,8 @@ boost_test(TYPE run SOURCES ec_hash_value_test.cpp)
 
 boost_test(TYPE run SOURCES std_interop_test16.cpp)
 
+boost_test(TYPE run SOURCES failed_constexpr_test2.cpp)
+
 # result
 
 boost_test(TYPE run SOURCES result_default_construct.cpp)
@@ -165,8 +167,6 @@ boost_test(TYPE run SOURCES result_value_construct6.cpp)
 boost_test(TYPE run SOURCES result_value_construct7.cpp)
 boost_test(TYPE run SOURCES result_error_construct5.cpp)
 boost_test(TYPE run SOURCES result_or_value.cpp)
-boost_test(TYPE compile-fail SOURCES result_or_value_fail.cpp)
-boost_test(TYPE compile-fail SOURCES result_or_value_fail2.cpp)
 boost_test(TYPE run SOURCES result_or_fn0v.cpp)
 boost_test(TYPE run SOURCES result_or_fn0r.cpp)
 boost_test(TYPE run SOURCES result_and_fn1v.cpp)
@@ -177,3 +177,21 @@ boost_test(TYPE run SOURCES result_in_place_use.cpp)
 boost_test(TYPE run SOURCES result_or_eq_value.cpp)
 boost_test(TYPE run SOURCES result_or_eq_fn0v.cpp)
 boost_test(TYPE run SOURCES result_or_eq_fn0r.cpp)
+
+boost_test(TYPE run SOURCES result_and_mfn1v.cpp)
+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)

test/Jamfile.v2

@@ -17,6 +17,9 @@ project
 
   : requirements
 
+    <library>/boost/system//boost_system
+    <library>/boost/core//boost_core
+
     <toolset>msvc:<warnings-as-errors>on
     <toolset>gcc:<warnings-as-errors>on
     <toolset>clang:<warnings-as-errors>on
@@ -165,6 +168,8 @@ run ec_hash_value_test.cpp ;
 
 run std_interop_test16.cpp ;
 
+run failed_constexpr_test2.cpp ;
+
 # result
 
 run result_default_construct.cpp ;
@@ -195,8 +200,6 @@ run result_value_construct6.cpp ;
 run result_value_construct7.cpp ;
 run result_error_construct5.cpp ;
 run result_or_value.cpp ;
-compile-fail result_or_value_fail.cpp ;
-compile-fail result_or_value_fail2.cpp ;
 run result_or_fn0v.cpp ;
 run result_or_fn0r.cpp ;
 run result_and_fn1v.cpp ;
@@ -207,3 +210,21 @@ run result_in_place_use.cpp ;
 run result_or_eq_value.cpp ;
 run result_or_eq_fn0v.cpp ;
 run result_or_eq_fn0r.cpp ;
+
+run result_and_mfn1v.cpp ;
+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 ;

test/cmake_install_test/CMakeLists.txt

@@ -14,4 +14,4 @@ target_link_libraries(main Boost::system)
 enable_testing()
 add_test(main main)
 
-add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -C $<CONFIG>)
+add_custom_target(check VERBATIM COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -C $<CONFIG>)

test/cmake_subdir_test/CMakeLists.txt

@@ -8,11 +8,11 @@ project(cmake_subdir_test LANGUAGES CXX)
 
 add_subdirectory(../.. boostorg/system)
 add_subdirectory(../../../assert boostorg/assert)
+add_subdirectory(../../../compat boostorg/compat)
 add_subdirectory(../../../config boostorg/config)
 add_subdirectory(../../../core boostorg/core)
 add_subdirectory(../../../mp11 boostorg/mp11)
 add_subdirectory(../../../predef boostorg/predef)
-add_subdirectory(../../../static_assert boostorg/static_assert)
 add_subdirectory(../../../throw_exception boostorg/throw_exception)
 add_subdirectory(../../../variant2 boostorg/variant2)
 add_subdirectory(../../../winapi boostorg/winapi)
@@ -23,4 +23,4 @@ target_link_libraries(quick Boost::system Boost::core)
 enable_testing()
 add_test(quick quick)
 
-add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure --no-tests=error -C $<CONFIG>)
+add_custom_target(check VERBATIM COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure --no-tests=error -C $<CONFIG>)

test/detail_is_aggregate_test.cpp

@@ -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

test/error_code_test2.cpp

@@ -11,26 +11,53 @@ namespace sys = boost::system;
 
 int main()
 {
-    char buffer[ 1024 ];
-
-    sys::error_code ec;
-
-    BOOST_TEST_EQ( ec.value(), 0 );
-    BOOST_TEST( ec.category() == sys::system_category() );
-    BOOST_TEST_EQ( ec.message(), ec.category().message( ec.value() ) );
-    BOOST_TEST_CSTR_EQ( ec.message( buffer, sizeof( buffer ) ), ec.category().message( ec.value(), buffer, sizeof( buffer ) ) );
-    BOOST_TEST( !ec.failed() );
-    BOOST_TEST( !ec );
-
-    BOOST_TEST_EQ( ec.to_string(), std::string( "system:0" ) );
+    char buffer[ 4096 ], buffer2[ 4096 ];
 
     {
+        sys::error_code ec;
+
+        BOOST_TEST_EQ( ec.value(), 0 );
+        BOOST_TEST( ec.category() == sys::system_category() );
+
+        BOOST_TEST_EQ( ec.message(), ec.category().message( ec.value() ) );
+        BOOST_TEST_CSTR_EQ( ec.message( buffer, sizeof( buffer ) ), ec.category().message( ec.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( ec.message( buffer, sizeof( buffer ) ), ec.message().c_str() );
+
+        {
+            char const* msg = ec.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, ec.message().c_str() );
+            }
+        }
+
+        BOOST_TEST( !ec.failed() );
+        BOOST_TEST( !ec );
+
+        BOOST_TEST_EQ( ec.to_string(), std::string( "system:0" ) );
+    }
+
+    {
+        sys::error_code ec;
         sys::error_code ec2( ec );
 
         BOOST_TEST_EQ( ec2.value(), 0 );
         BOOST_TEST( ec2.category() == sys::system_category() );
+
         BOOST_TEST_EQ( ec2.message(), ec2.category().message( ec2.value() ) );
-        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.category().message( ec2.value(), buffer, sizeof( buffer ) ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.category().message( ec2.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.message().c_str() );
+
+        {
+            char const* msg = ec2.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, ec2.message().c_str() );
+            }
+        }
+
         BOOST_TEST( !ec2.failed() );
         BOOST_TEST( !ec2 );
 
@@ -41,12 +68,25 @@ int main()
     }
 
     {
+        sys::error_code ec;
         sys::error_code ec2( ec.value(), ec.category() );
 
         BOOST_TEST_EQ( ec2.value(), 0 );
         BOOST_TEST( ec2.category() == sys::system_category() );
+
         BOOST_TEST_EQ( ec2.message(), ec2.category().message( ec2.value() ) );
-        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.category().message( ec2.value(), buffer, sizeof( buffer ) ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.category().message( ec2.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.message().c_str() );
+
+        {
+            char const* msg = ec2.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, ec2.message().c_str() );
+            }
+        }
+
         BOOST_TEST( !ec2.failed() );
         BOOST_TEST( !ec2 );
 
@@ -61,34 +101,124 @@ int main()
 
         BOOST_TEST_EQ( ec2.value(), 5 );
         BOOST_TEST( ec2.category() == sys::generic_category() );
+
         BOOST_TEST_EQ( ec2.message(), ec2.category().message( ec2.value() ) );
-        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.category().message( ec2.value(), buffer, sizeof( buffer ) ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.category().message( ec2.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.message().c_str() );
+
+        {
+            char const* msg = ec2.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, ec2.message().c_str() );
+            }
+        }
+
         BOOST_TEST( ec2.failed() );
         BOOST_TEST( ec2 );
         BOOST_TEST_NOT( !ec2 );
 
+        sys::error_code ec;
+
         BOOST_TEST_NE( ec, ec2 );
         BOOST_TEST_NOT( ec == ec2 );
 
         BOOST_TEST_EQ( ec2.to_string(), std::string( "generic:5" ) );
     }
 
+    {
+        sys::error_code ec2( -4, sys::generic_category() );
+
+        BOOST_TEST_EQ( ec2.value(), -4 );
+        BOOST_TEST( ec2.category() == sys::generic_category() );
+
+        BOOST_TEST_EQ( ec2.message(), ec2.category().message( ec2.value() ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.category().message( ec2.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.message().c_str() );
+
+        {
+            char const* msg = ec2.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, ec2.message().c_str() );
+            }
+        }
+
+        BOOST_TEST( ec2.failed() );
+        BOOST_TEST( ec2 );
+        BOOST_TEST_NOT( !ec2 );
+
+        sys::error_code ec;
+
+        BOOST_TEST_NE( ec, ec2 );
+        BOOST_TEST_NOT( ec == ec2 );
+
+        BOOST_TEST_EQ( ec2.to_string(), std::string( "generic:-4" ) );
+    }
+
     {
         sys::error_code ec2( 5, sys::system_category() );
 
         BOOST_TEST_EQ( ec2.value(), 5 );
         BOOST_TEST( ec2.category() == sys::system_category() );
+
         BOOST_TEST_EQ( ec2.message(), ec2.category().message( ec2.value() ) );
-        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.category().message( ec2.value(), buffer, sizeof( buffer ) ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.category().message( ec2.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.message().c_str() );
+
+        {
+            char const* msg = ec2.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, ec2.message().c_str() );
+            }
+        }
+
         BOOST_TEST( ec2.failed() );
         BOOST_TEST( ec2 );
         BOOST_TEST_NOT( !ec2 );
 
+        sys::error_code ec;
+
         BOOST_TEST_NE( ec, ec2 );
         BOOST_TEST_NOT( ec == ec2 );
 
         BOOST_TEST_EQ( ec2.to_string(), std::string( "system:5" ) );
     }
 
+    {
+        sys::error_code ec2( -4, sys::system_category() );
+
+        BOOST_TEST_EQ( ec2.value(), -4 );
+        BOOST_TEST( ec2.category() == sys::system_category() );
+
+        BOOST_TEST_EQ( ec2.message(), ec2.category().message( ec2.value() ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.category().message( ec2.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.message().c_str() );
+
+        {
+            char const* msg = ec2.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, ec2.message().c_str() );
+            }
+        }
+
+        BOOST_TEST( ec2.failed() );
+        BOOST_TEST( ec2 );
+        BOOST_TEST_NOT( !ec2 );
+
+        sys::error_code ec;
+
+        BOOST_TEST_NE( ec, ec2 );
+        BOOST_TEST_NOT( ec == ec2 );
+
+        BOOST_TEST_EQ( ec2.to_string(), std::string( "system:-4" ) );
+    }
+
     return boost::report_errors();
 }

test/error_condition_test3.cpp

@@ -11,26 +11,53 @@ namespace sys = boost::system;
 
 int main()
 {
-    char buffer[ 1024 ];
-
-    sys::error_condition en;
-
-    BOOST_TEST_EQ( en.value(), 0 );
-    BOOST_TEST( en.category() == sys::generic_category() );
-    BOOST_TEST_EQ( en.message(), en.category().message( en.value() ) );
-    BOOST_TEST_CSTR_EQ( en.message( buffer, sizeof( buffer ) ), en.category().message( en.value(), buffer, sizeof( buffer ) ) );
-    BOOST_TEST( !en.failed() );
-    BOOST_TEST( !en );
-
-    BOOST_TEST_EQ( en.to_string(), std::string( "cond:generic:0" ) );
+    char buffer[ 4096 ], buffer2[ 4096 ];
 
     {
+        sys::error_condition en;
+
+        BOOST_TEST_EQ( en.value(), 0 );
+        BOOST_TEST( en.category() == sys::generic_category() );
+
+        BOOST_TEST_EQ( en.message(), en.category().message( en.value() ) );
+        BOOST_TEST_CSTR_EQ( en.message( buffer, sizeof( buffer ) ), en.category().message( en.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( en.message( buffer, sizeof( buffer ) ), en.message().c_str() );
+
+        {
+            char const* msg = en.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, en.message().c_str() );
+            }
+        }
+
+        BOOST_TEST( !en.failed() );
+        BOOST_TEST( !en );
+
+        BOOST_TEST_EQ( en.to_string(), std::string( "cond:generic:0" ) );
+    }
+
+    {
+        sys::error_condition en;
         sys::error_condition en2( en );
 
         BOOST_TEST_EQ( en2.value(), 0 );
         BOOST_TEST( en2.category() == sys::generic_category() );
+
         BOOST_TEST_EQ( en2.message(), en2.category().message( en2.value() ) );
-        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.category().message( en2.value(), buffer, sizeof( buffer ) ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.category().message( en2.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.message().c_str() );
+
+        {
+            char const* msg = en2.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, en2.message().c_str() );
+            }
+        }
+
         BOOST_TEST( !en2.failed() );
         BOOST_TEST( !en2 );
 
@@ -41,12 +68,25 @@ int main()
     }
 
     {
+        sys::error_condition en;
         sys::error_condition en2( en.value(), en.category() );
 
         BOOST_TEST_EQ( en2.value(), 0 );
         BOOST_TEST( en2.category() == sys::generic_category() );
+
         BOOST_TEST_EQ( en2.message(), en2.category().message( en2.value() ) );
-        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.category().message( en2.value(), buffer, sizeof( buffer ) ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.category().message( en2.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.message().c_str() );
+
+        {
+            char const* msg = en2.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, en2.message().c_str() );
+            }
+        }
+
         BOOST_TEST( !en2.failed() );
         BOOST_TEST( !en2 );
 
@@ -61,34 +101,124 @@ int main()
 
         BOOST_TEST_EQ( en2.value(), 5 );
         BOOST_TEST( en2.category() == sys::generic_category() );
+
         BOOST_TEST_EQ( en2.message(), en2.category().message( en2.value() ) );
-        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.category().message( en2.value(), buffer, sizeof( buffer ) ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.category().message( en2.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.message().c_str() );
+
+        {
+            char const* msg = en2.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, en2.message().c_str() );
+            }
+        }
+
         BOOST_TEST( en2.failed() );
         BOOST_TEST( en2 );
         BOOST_TEST_NOT( !en2 );
 
+        sys::error_condition en;
+
         BOOST_TEST_NE( en, en2 );
         BOOST_TEST_NOT( en == en2 );
 
         BOOST_TEST_EQ( en2.to_string(), std::string( "cond:generic:5" ) );
     }
 
+    {
+        sys::error_condition en2( -4, sys::generic_category() );
+
+        BOOST_TEST_EQ( en2.value(), -4 );
+        BOOST_TEST( en2.category() == sys::generic_category() );
+
+        BOOST_TEST_EQ( en2.message(), en2.category().message( en2.value() ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.category().message( en2.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.message().c_str() );
+
+        {
+            char const* msg = en2.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, en2.message().c_str() );
+            }
+        }
+
+        BOOST_TEST( en2.failed() );
+        BOOST_TEST( en2 );
+        BOOST_TEST_NOT( !en2 );
+
+        sys::error_condition en;
+
+        BOOST_TEST_NE( en, en2 );
+        BOOST_TEST_NOT( en == en2 );
+
+        BOOST_TEST_EQ( en2.to_string(), std::string( "cond:generic:-4" ) );
+    }
+
     {
         sys::error_condition en2( 5, sys::system_category() );
 
         BOOST_TEST_EQ( en2.value(), 5 );
         BOOST_TEST( en2.category() == sys::system_category() );
+
         BOOST_TEST_EQ( en2.message(), en2.category().message( en2.value() ) );
-        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.category().message( en2.value(), buffer, sizeof( buffer ) ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.category().message( en2.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.message().c_str() );
+
+        {
+            char const* msg = en2.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, en2.message().c_str() );
+            }
+        }
+
         BOOST_TEST( en2.failed() );
         BOOST_TEST( en2 );
         BOOST_TEST_NOT( !en2 );
 
+        sys::error_condition en;
+
         BOOST_TEST_NE( en, en2 );
         BOOST_TEST_NOT( en == en2 );
 
         BOOST_TEST_EQ( en2.to_string(), std::string( "cond:system:5" ) );
     }
 
+    {
+        sys::error_condition en2( -4, sys::system_category() );
+
+        BOOST_TEST_EQ( en2.value(), -4 );
+        BOOST_TEST( en2.category() == sys::system_category() );
+
+        BOOST_TEST_EQ( en2.message(), en2.category().message( en2.value() ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.category().message( en2.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.message().c_str() );
+
+        {
+            char const* msg = en2.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, en2.message().c_str() );
+            }
+        }
+
+        BOOST_TEST( en2.failed() );
+        BOOST_TEST( en2 );
+        BOOST_TEST_NOT( !en2 );
+
+        sys::error_condition en;
+
+        BOOST_TEST_NE( en, en2 );
+        BOOST_TEST_NOT( en == en2 );
+
+        BOOST_TEST_EQ( en2.to_string(), std::string( "cond:system:-4" ) );
+    }
+
     return boost::report_errors();
 }

test/failed_constexpr_test2.cpp

@@ -0,0 +1,54 @@
+// Copyright 2026 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/error_code.hpp>
+#include <boost/system/error_condition.hpp>
+#include <boost/config/pragma_message.hpp>
+#include <boost/static_assert.hpp>
+#include <cstdio>
+
+#if !defined(BOOST_SYSTEM_HAS_CXX20_CONSTEXPR)
+
+BOOST_PRAGMA_MESSAGE("Skipping constexpr test, BOOST_SYSTEM_HAS_CXX20_CONSTEXPR isn't defined")
+int main() {}
+
+#else
+
+namespace sys = boost::system;
+
+class user_category: public sys::error_category
+{
+public:
+
+    constexpr virtual const char* name() const noexcept
+    {
+        return "user";
+    }
+
+    virtual std::string message( int ev ) const
+    {
+        char buffer[ 256 ];
+        std::snprintf( buffer, sizeof( buffer ), "user message %d", ev );
+
+        return buffer;
+    }
+};
+
+static constexpr user_category s_user_cat;
+
+constexpr sys::error_code ec( 1, s_user_cat );
+
+BOOST_STATIC_ASSERT( ec.failed() );
+BOOST_STATIC_ASSERT( ec );
+BOOST_STATIC_ASSERT( !!ec );
+
+constexpr sys::error_condition en( 1, s_user_cat );
+
+BOOST_STATIC_ASSERT( en.failed() );
+BOOST_STATIC_ASSERT( en );
+BOOST_STATIC_ASSERT( !!en );
+
+int main() {}
+
+#endif

test/result_and_eq_fn1r.cpp

@@ -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() );

test/result_and_fn1r.cpp

@@ -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 );
     }
 
     {

test/result_and_mfn1r.cpp

@@ -0,0 +1,230 @@
+// Copyright 2017, 2021, 2022 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>
+
+using namespace boost::system;
+
+struct E
+{
+};
+
+struct E2
+{
+    E2() {}
+    E2( E ) {}
+};
+
+struct X
+{
+    int v_ = 0;
+    mutable int g_called_ = 0;
+
+    X( int v ): v_( v ) {}
+
+    result<int, E2> f() const { return v_; }
+    result<int, E2> f2() const { return E2(); }
+
+    result<int&, E2> g() { return v_; }
+    result<int const&, E2> g2() const { return v_; }
+
+    result<void, E2> h() const { return {}; }
+    result<void, E2> h2() const { return E2(); }
+};
+
+int main()
+{
+    {
+        result<X, E> r( 1 );
+
+        {
+            result<int, E2> r2 = r & &X::f;
+            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2.unsafe_value(), 1 );
+        }
+
+        {
+            result<int, E2> r2 = r & &X::f2;
+            BOOST_TEST( r2.has_error() );
+        }
+
+        {
+            result<int&, E2> r2 = r & &X::g;
+            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.unsafe_value(), &r.unsafe_value().v_ );
+        }
+
+        {
+            result<void, E2> r2 = r & &X::h;
+            BOOST_TEST( r2.has_value() );
+        }
+
+        {
+            result<void, E2> r2 = r & &X::h2;
+            BOOST_TEST( r2.has_error() );
+        }
+    }
+
+    {
+        result<X, E> const r( 1 );
+
+        {
+            result<int, E2> r2 = r & &X::f;
+            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2.unsafe_value(), 1 );
+        }
+
+        {
+            result<int, E2> r2 = r & &X::f2;
+            BOOST_TEST( r2.has_error() );
+        }
+
+        {
+            result<int const&, E2> r2 = r & &X::g2;
+            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &r2.unsafe_value(), &r.unsafe_value().v_ );
+        }
+
+        {
+            result<void, E2> r2 = r & &X::h;
+            BOOST_TEST( r2.has_value() );
+        }
+
+        {
+            result<void, E2> r2 = r & &X::h2;
+            BOOST_TEST( r2.has_error() );
+        }
+    }
+
+    {
+        {
+            result<int, E2> r2 = result<X, E>( 1 ) & &X::f;
+            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2.unsafe_value(), 1 );
+        }
+
+        {
+            result<int, E2> r2 = result<X, E>( 1 ) & &X::f2;
+            BOOST_TEST( r2.has_error() );
+        }
+
+        {
+            result<int&, E2> r2 = result<X, E>( 1 ) & &X::g;
+            BOOST_TEST( r2.has_value() );
+        }
+
+        {
+            result<int const&, E2> r2 = result<X, E>( 1 ) & &X::g2;
+            BOOST_TEST( r2.has_value() );
+        }
+
+        {
+            result<void, E2> r2 = result<X, E>( 1 ) & &X::h;
+            BOOST_TEST( r2.has_value() );
+        }
+
+        {
+            result<void, E2> r2 = result<X, E>( 1 ) & &X::h2;
+            BOOST_TEST( r2.has_error() );
+        }
+    }
+
+    {
+        result<X, E> r( in_place_error );
+
+        {
+            result<int, E2> r2 = r & &X::f;
+            BOOST_TEST( r2.has_error() );
+        }
+
+        {
+            result<int, E2> r2 = r & &X::f2;
+            BOOST_TEST( r2.has_error() );
+        }
+
+        {
+            result<int&, E2> r2 = r & &X::g;
+            BOOST_TEST( r2.has_error() );
+        }
+
+        {
+            result<int const&, E2> r2 = r & &X::g2;
+            BOOST_TEST( r2.has_error() );
+        }
+
+        {
+            result<void, E2> r2 = r & &X::h;
+            BOOST_TEST( r2.has_error() );
+        }
+
+        {
+            result<void, E2> r2 = r & &X::h2;
+            BOOST_TEST( r2.has_error() );
+        }
+    }
+
+    {
+        result<X, E> const r( in_place_error );
+
+        {
+            result<int, E2> r2 = r & &X::f;
+            BOOST_TEST( r2.has_error() );
+        }
+
+        {
+            result<int, E2> r2 = r & &X::f2;
+            BOOST_TEST( r2.has_error() );
+        }
+
+        {
+            result<int const&, E2> r2 = r & &X::g2;
+            BOOST_TEST( r2.has_error() );
+        }
+
+        {
+            result<void, E2> r2 = r & &X::h;
+            BOOST_TEST( r2.has_error() );
+        }
+
+        {
+            result<void, E2> r2 = r & &X::h2;
+            BOOST_TEST( r2.has_error() );
+        }
+    }
+
+    {
+        {
+            result<int, E2> r2 = result<X, E>( in_place_error ) & &X::f;
+            BOOST_TEST( r2.has_error() );
+        }
+
+        {
+            result<int, E2> r2 = result<X, E>( in_place_error ) & &X::f2;
+            BOOST_TEST( r2.has_error() );
+        }
+
+        {
+            result<int&, E2> r2 = result<X, E>( in_place_error ) & &X::g;
+            BOOST_TEST( r2.has_error() );
+        }
+
+        {
+            result<int const&, E2> r2 = result<X, E>( in_place_error ) & &X::g2;
+            BOOST_TEST( r2.has_error() );
+        }
+
+        {
+            result<void, E2> r2 = result<X, E>( in_place_error ) & &X::h;
+            BOOST_TEST( r2.has_error() );
+        }
+
+        {
+            result<void, E2> r2 = result<X, E>( in_place_error ) & &X::h2;
+            BOOST_TEST( r2.has_error() );
+        }
+    }
+
+    return boost::report_errors();
+}

test/result_and_mfn1v.cpp

@@ -0,0 +1,254 @@
+// Copyright 2017, 2021, 2022 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>
+
+using namespace boost::system;
+
+struct X
+{
+    int v_ = 0;
+    mutable int g_called_ = 0;
+
+    X( int v ): v_( v ) {}
+
+    int f() const { return v_; }
+
+    void g() const { ++g_called_; }
+
+    int& h() { return v_; }
+    int const& h2() const { return v_; }
+};
+
+struct E
+{
+};
+
+int main()
+{
+    {
+        result<X> r( 1 );
+        result<int> r2 = r & &X::f;
+
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 1 );
+    }
+
+    {
+        result<X> const r( 1 );
+        result<int> r2 = r & &X::f;
+
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 1 );
+    }
+
+    {
+        result<int> r2 = result<X>( 1 ) & &X::f;
+
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 1 );
+    }
+
+    {
+        result<X, E> r( in_place_error );
+        result<int, E> r2 = r & &X::f;
+
+        BOOST_TEST( r2.has_error() );
+    }
+
+    {
+        result<X, E> const r( in_place_error );
+        result<int, E> r2 = r & &X::f;
+
+        BOOST_TEST( r2.has_error() );
+    }
+
+    {
+        result<int, E> r2 = result<X, E>( in_place_error ) & &X::f;
+
+        BOOST_TEST( r2.has_error() );
+    }
+
+    {
+        result<X> r( 1 );
+        result<int&> r2 = r & &X::v_;
+
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &*r2, &r->v_ );
+    }
+
+    {
+        result<X> const r( 1 );
+        result<int const&> r2 = r & &X::v_;
+
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &*r2, &r->v_ );
+    }
+
+    {
+        result<int> r2 = result<X>( 1 ) & &X::v_;
+
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 1 );
+    }
+
+    {
+        result<X, E> r( in_place_error );
+        result<int&, E> r2 = r & &X::v_;
+
+        BOOST_TEST( r2.has_error() );
+    }
+
+    {
+        result<X, E> const r( in_place_error );
+        result<int const&, E> r2 = r & &X::v_;
+
+        BOOST_TEST( r2.has_error() );
+    }
+
+    {
+        result<int, E> r2 = result<X, E>( in_place_error ) & &X::v_;
+
+        BOOST_TEST( r2.has_error() );
+    }
+
+    {
+        X x( 1 );
+
+        result<X&> r( x );
+        result<int&> r2 = r & &X::v_;
+
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &*r2, &x.v_ );
+    }
+
+    {
+        X const x( 1 );
+
+        result<X const&> r( x );
+        result<int const&> r2 = r & &X::v_;
+
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &*r2, &x.v_ );
+    }
+
+    {
+        X x( 1 );
+
+        result<int&> r2 = result<X&>( x ) & &X::v_;
+
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &*r2, &x.v_ );
+    }
+
+    {
+        X const x( 1 );
+
+        result<int const&> r2 = result<X const&>( x ) & &X::v_;
+
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &*r2, &x.v_ );
+    }
+
+    {
+        result<X&, E> r( in_place_error );
+        result<int&, E> r2 = r & &X::v_;
+
+        BOOST_TEST( r2.has_error() );
+    }
+
+    {
+        result<X const&, E> const r( in_place_error );
+        result<int const&, E> r2 = r & &X::v_;
+
+        BOOST_TEST( r2.has_error() );
+    }
+
+    {
+        result<int&, E> r2 = result<X&, E>( in_place_error ) & &X::v_;
+
+        BOOST_TEST( r2.has_error() );
+    }
+
+    {
+        result<int const&, E> r2 = result<X const&, E>( in_place_error ) & &X::v_;
+
+        BOOST_TEST( r2.has_error() );
+    }
+
+    {
+        result<X> r( 1 );
+        result<void> r2 = r & &X::g;
+
+        BOOST_TEST( r2.has_value() );
+        BOOST_TEST_EQ( r->g_called_, 1 );
+    }
+
+    {
+        result<X> const r( 1 );
+        result<void> r2 = r & &X::g;
+
+        BOOST_TEST( r2.has_value() );
+        BOOST_TEST_EQ( r->g_called_, 1 );
+    }
+
+    {
+        result<void> r2 = result<X>( 1 ) & &X::g;
+
+        BOOST_TEST( r2.has_value() );
+    }
+
+    {
+        result<X, E> r( in_place_error );
+        result<void, E> r2 = r & &X::g;
+
+        BOOST_TEST( r2.has_error() );
+    }
+
+    {
+        result<X, E> const r( in_place_error );
+        result<void, E> r2 = r & &X::g;
+
+        BOOST_TEST( r2.has_error() );
+    }
+
+    {
+        result<void, E> r2 = result<X, E>( in_place_error ) & &X::g;
+
+        BOOST_TEST( r2.has_error() );
+    }
+
+    {
+        result<X> r( 1 );
+        result<int&> r2 = r & &X::h;
+
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 1 );
+    }
+
+    {
+        result<X> const r( 1 );
+        result<int const&> r2 = r & &X::h2;
+
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 1 );
+    }
+
+    {
+        result<int> r2 = result<X>( 1 ) & &X::h2;
+
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 1 );
+    }
+
+    {
+        result<X, E> r( in_place_error );
+        result<int&, E> r2 = r & &X::h;
+
+        BOOST_TEST( r2.has_error() );
+    }
+
+    {
+        result<X, E> const r( in_place_error );
+        result<int const&, E> r2 = r & &X::h2;
+
+        BOOST_TEST( r2.has_error() );
+    }
+
+    {
+        result<int, E> r2 = result<X, E>( in_place_error ) & &X::h2;
+
+        BOOST_TEST( r2.has_error() );
+    }
+
+    return boost::report_errors();
+}

test/result_convert_construct.cpp

@@ -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 );
     }
 

test/result_emplace.cpp

@@ -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()
 {
     {

test/result_error_construct_cx.cpp

@@ -0,0 +1,96 @@
+// Copyright 2017, 2021, 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/config/pragma_message.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/config.hpp>
+
+#if !defined(BOOST_SYSTEM_HAS_CONSTEXPR)
+
+BOOST_PRAGMA_MESSAGE("Skipping constexpr test, BOOST_SYSTEM_HAS_CONSTEXPR isn't defined")
+
+#elif defined(BOOST_CLANG_VERSION) && BOOST_CLANG_VERSION < 60000
+
+BOOST_PRAGMA_MESSAGE("Skipping constexpr test, BOOST_CLANG_VERSION < 60000")
+
+#else
+
+using namespace boost::system;
+
+int main()
+{
+    {
+        constexpr auto ec = make_error_code( errc::invalid_argument );
+
+        constexpr result<int> r( ec );
+
+        BOOST_STATIC_ASSERT( !r.has_value() );
+        BOOST_STATIC_ASSERT( r.has_error() );
+
+        BOOST_STATIC_ASSERT( r.error() == ec );
+    }
+
+    {
+        constexpr result<int> r( EINVAL, generic_category() );
+
+        BOOST_STATIC_ASSERT( !r.has_value() );
+        BOOST_STATIC_ASSERT( r.has_error() );
+
+        BOOST_STATIC_ASSERT( r.error() == error_code( EINVAL, generic_category() ) );
+    }
+
+    {
+        constexpr auto ec = make_error_code( errc::invalid_argument );
+
+        constexpr result<error_code> r( in_place_error, ec );
+
+        BOOST_STATIC_ASSERT( !r.has_value() );
+        BOOST_STATIC_ASSERT( r.has_error() );
+
+        BOOST_STATIC_ASSERT( r.error() == ec );
+    }
+
+    {
+        constexpr result<error_code> r( in_place_error, EINVAL, generic_category() );
+
+        BOOST_STATIC_ASSERT( !r.has_value() );
+        BOOST_STATIC_ASSERT( r.has_error() );
+
+        BOOST_STATIC_ASSERT( r.error() == error_code( EINVAL, generic_category() ) );
+    }
+
+    {
+        constexpr auto ec = make_error_code( errc::invalid_argument );
+
+        constexpr result<void> r( ec );
+
+        BOOST_STATIC_ASSERT( !r.has_value() );
+        BOOST_STATIC_ASSERT( r.has_error() );
+
+        BOOST_STATIC_ASSERT( r.error() == ec );
+    }
+
+    {
+        constexpr auto ec = make_error_code( errc::invalid_argument );
+
+        constexpr result<void> r = ec;
+
+        BOOST_STATIC_ASSERT( !r.has_value() );
+        BOOST_STATIC_ASSERT( r.has_error() );
+
+        BOOST_STATIC_ASSERT( r.error() == ec );
+    }
+
+    {
+        constexpr result<void> r( EINVAL, generic_category() );
+
+        BOOST_STATIC_ASSERT( !r.has_value() );
+        BOOST_STATIC_ASSERT( r.has_error() );
+
+        BOOST_STATIC_ASSERT( r.error() == error_code( EINVAL, generic_category() ) );
+    }
+}
+
+#endif

test/result_error_construct_cx2.cpp

@@ -0,0 +1,77 @@
+// Copyright 2017, 2021, 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/config/pragma_message.hpp>
+#include <boost/static_assert.hpp>
+#include <cstdio>
+
+#if !defined(BOOST_SYSTEM_HAS_CXX20_CONSTEXPR)
+
+BOOST_PRAGMA_MESSAGE("Skipping constexpr test, BOOST_SYSTEM_HAS_CXX20_CONSTEXPR isn't defined")
+
+#else
+
+using namespace boost::system;
+
+class user_category: public error_category
+{
+public:
+
+    constexpr virtual const char* name() const noexcept
+    {
+        return "user";
+    }
+
+    virtual std::string message( int ev ) const
+    {
+        char buffer[ 256 ];
+        std::snprintf( buffer, sizeof( buffer ), "user message %d", ev );
+
+        return buffer;
+    }
+};
+
+static constexpr user_category s_user_cat;
+
+int main()
+{
+    {
+        constexpr result<int> r( 1, s_user_cat );
+
+        BOOST_STATIC_ASSERT( !r.has_value() );
+        BOOST_STATIC_ASSERT( r.has_error() );
+
+        BOOST_STATIC_ASSERT( r.error() == error_code( 1, s_user_cat ) );
+    }
+
+    {
+        constexpr result<error_code> r( in_place_error, 2, s_user_cat );
+
+        BOOST_STATIC_ASSERT( !r.has_value() );
+        BOOST_STATIC_ASSERT( r.has_error() );
+
+        BOOST_STATIC_ASSERT( r.error() == error_code( 2, s_user_cat ) );
+    }
+
+    {
+        constexpr result<void> r( 3, s_user_cat );
+
+        BOOST_STATIC_ASSERT( !r.has_value() );
+        BOOST_STATIC_ASSERT( r.has_error() );
+
+        BOOST_STATIC_ASSERT( r.error() == error_code( 3, s_user_cat ) );
+    }
+
+    {
+        constexpr result<void> r( in_place_error, 4, s_user_cat );
+
+        BOOST_STATIC_ASSERT( !r.has_value() );
+        BOOST_STATIC_ASSERT( r.has_error() );
+
+        BOOST_STATIC_ASSERT( r.error() == error_code( 4, s_user_cat ) );
+    }
+}
+
+#endif

test/result_or_eq_fn0r.cpp

@@ -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();

test/result_or_eq_fn0v.cpp

@@ -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();

test/result_or_eq_value.cpp

@@ -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();

test/result_or_fn0r.cpp

@@ -191,120 +191,102 @@ int main()
 
     {
         int x1 = 1;
-        int x3 = 3;
 
         result<int&> r( x1 );
 
-        int& x = r | fri | x3;
+        auto r2 = r | fri;
 
-        BOOST_TEST_EQ( &x, &x1 );
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &r2.unsafe_value(), &x1 );
     }
 
     {
         int x1 = 1;
-        int x3 = 3;
 
         result<int&> const r( x1 );
 
-        int& x = r | fri | x3;
+        auto r2 = r | fri;
 
-        BOOST_TEST_EQ( &x, &x1 );
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &r2.unsafe_value(), &x1 );
     }
 
     {
         int x1 = 1;
-        int x3 = 3;
 
-        int& x = result<int&>( x1 ) | fri | x3;
+        auto r2 = result<int&>( x1 ) | fri;
 
-        BOOST_TEST_EQ( &x, &x1 );
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &r2.unsafe_value(), &x1 );
     }
 
     {
         int x1 = 1;
-        int x3 = 3;
 
         result<int&> r( x1 );
 
-        int& x = r | fri2 | x3;
+        auto r2 = r | fri2;
 
-        BOOST_TEST_EQ( &x, &x1 );
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &r2.unsafe_value(), &x1 );
     }
 
     {
         int x1 = 1;
-        int x3 = 3;
 
         result<int&> const r( x1 );
 
-        int& x = r | fri2 | x3;
+        auto r2 = r | fri2;
 
-        BOOST_TEST_EQ( &x, &x1 );
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &r2.unsafe_value(), &x1 );
     }
 
     {
         int x1 = 1;
-        int x3 = 3;
 
-        int& x = result<int&>( x1 ) | fri2 | x3;
+        auto r2 = result<int&>( x1 ) | fri2;
 
-        BOOST_TEST_EQ( &x, &x1 );
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &r2.unsafe_value(), &x1 );
     }
 
     {
-        int x3 = 3;
-
         result<int&, E> r( in_place_error );
 
-        int& x = r | fri | x3;
+        auto r2 = r | fri;
 
-        BOOST_TEST_EQ( &x, &*fri() );
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &r2.unsafe_value(), &fri().unsafe_value() );
     }
 
     {
-        int x3 = 3;
-
         result<int&, E> const r( in_place_error );
 
-        int& x = r | fri | x3;
+        auto r2 = r | fri;
 
-        BOOST_TEST_EQ( &x, &*fri() );
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &r2.unsafe_value(), &fri().unsafe_value() );
     }
 
     {
-        int x3 = 3;
+        auto r2 = result<int&, E>( in_place_error ) | fri;
 
-        int& x = result<int&, E>( in_place_error ) | fri | x3;
-
-        BOOST_TEST_EQ( &x, &*fri() );
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &r2.unsafe_value(), &fri().unsafe_value() );
     }
 
     {
-        int x3 = 3;
-
         result<int&, E> r( in_place_error );
 
-        int& x = r | fri2 | x3;
+        auto r2 = r | fri2;
 
-        BOOST_TEST_EQ( &x, &x3 );
+        BOOST_TEST( r2.has_error() );
     }
 
     {
-        int x3 = 3;
-
         result<int&, E> const r( in_place_error );
 
-        int& x = r | fri2 | x3;
+        auto r2 = r | fri2;
 
-        BOOST_TEST_EQ( &x, &x3 );
+        BOOST_TEST( r2.has_error() );
     }
 
     {
-        int x3 = 3;
+        auto r2 = result<int&, E>( in_place_error ) | fri2;
 
-        int& x = result<int&, E>( in_place_error ) | fri2 | x3;
-
-        BOOST_TEST_EQ( &x, &x3 );
+        BOOST_TEST( r2.has_error() );
     }
 
     {

test/result_or_fn0v.cpp

@@ -4,6 +4,8 @@
 
 #include <boost/system/result.hpp>
 #include <boost/core/lightweight_test.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
 
 using namespace boost::system;
 
@@ -108,6 +110,71 @@ int main()
         BOOST_TEST_EQ( y.v_, 2 );
     }
 
+    {
+        int x1 = 1;
+
+        result<int&> r( x1 );
+
+        auto&& x2 = r | f;
+
+        BOOST_TEST_TRAIT_FALSE(( std::is_lvalue_reference<decltype(x2)> ));
+
+        BOOST_TEST_EQ( x2, x1 );
+        BOOST_TEST_NE( &x2, &x1 );
+    }
+
+    {
+        int x1 = 1;
+
+        result<int&> const r( x1 );
+
+        auto&& x2 = r | f;
+
+        BOOST_TEST_TRAIT_FALSE(( std::is_lvalue_reference<decltype(x2)> ));
+
+        BOOST_TEST_EQ( x2, x1 );
+        BOOST_TEST_NE( &x2, &x1 );
+    }
+
+    {
+        int x1 = 1;
+
+        auto&& x2 = result<int&>( x1 ) | f;
+
+        BOOST_TEST_TRAIT_FALSE(( std::is_lvalue_reference<decltype(x2)> ));
+
+        BOOST_TEST_EQ( x2, x1 );
+        BOOST_TEST_NE( &x2, &x1 );
+    }
+
+    {
+        result<int&, E> r( in_place_error );
+
+        auto&& x2 = r | f;
+
+        BOOST_TEST_TRAIT_FALSE(( std::is_lvalue_reference<decltype(x2)> ));
+
+        BOOST_TEST_EQ( x2, f() );
+    }
+
+    {
+        result<int&, E> const r( in_place_error );
+
+        auto&& x2 = r | f;
+
+        BOOST_TEST_TRAIT_FALSE(( std::is_lvalue_reference<decltype(x2)> ));
+
+        BOOST_TEST_EQ( x2, f() );
+    }
+
+    {
+        auto&& x2 = result<int&, E>( in_place_error ) | f;
+
+        BOOST_TEST_TRAIT_FALSE(( std::is_lvalue_reference<decltype(x2)> ));
+
+        BOOST_TEST_EQ( x2, f() );
+    }
+
     {
         int x1 = 1;
 

test/result_or_value.cpp

@@ -4,6 +4,8 @@
 
 #include <boost/system/result.hpp>
 #include <boost/core/lightweight_test.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
 
 using namespace boost::system;
 
@@ -110,9 +112,22 @@ int main()
 
         result<int&> r( x1 );
 
-        int& x = r | x2;
+        {
+            auto&& x3 = r | x2;
 
-        BOOST_TEST_EQ( &x, &x1 );
+            BOOST_TEST_TRAIT_FALSE(( std::is_lvalue_reference<decltype(x3)> ));
+
+            BOOST_TEST_EQ( x3, x1 );
+            BOOST_TEST_NE( &x3, &x1 );
+        }
+
+        {
+            auto&& x4 = r | 3;
+
+            BOOST_TEST_TRAIT_FALSE(( std::is_lvalue_reference<decltype( x4 )> ));
+
+            BOOST_TEST_EQ( x4, x1 );
+        }
     }
 
     {
@@ -121,18 +136,44 @@ int main()
 
         result<int&> const r( x1 );
 
-        int& x = r | x2;
+        {
+            auto&& x3 = r | x2;
 
-        BOOST_TEST_EQ( &x, &x1 );
+            BOOST_TEST_TRAIT_FALSE(( std::is_lvalue_reference<decltype(x3)> ));
+
+            BOOST_TEST_EQ( x3, x1 );
+            BOOST_TEST_NE( &x3, &x1 );
+        }
+
+        {
+            auto&& x4 = r | 3;
+
+            BOOST_TEST_TRAIT_FALSE(( std::is_lvalue_reference<decltype( x4 )> ));
+
+            BOOST_TEST_EQ( x4, x1 );
+        }
     }
 
     {
         int x1 = 1;
         int x2 = 2;
 
-        int& x = result<int&>( x1 ) | x2;
+        {
+            auto&& x3 = result<int&>( x1 ) | x2;
 
-        BOOST_TEST_EQ( &x, &x1 );
+            BOOST_TEST_TRAIT_FALSE(( std::is_lvalue_reference<decltype(x3)> ));
+
+            BOOST_TEST_EQ( x3, x1 );
+            BOOST_TEST_NE( &x3, &x1 );
+        }
+
+        {
+            auto&& x4 = result<int&>( x1 ) | 3;
+
+            BOOST_TEST_TRAIT_FALSE(( std::is_lvalue_reference<decltype( x4 )> ));
+
+            BOOST_TEST_EQ( x4, x1 );
+        }
     }
 
     {
@@ -140,9 +181,22 @@ int main()
 
         result<int&, E> r( in_place_error );
 
-        int& x = r | x2;
+        {
+            auto&& x3 = r | x2;
 
-        BOOST_TEST_EQ( &x, &x2 );
+            BOOST_TEST_TRAIT_FALSE(( std::is_lvalue_reference<decltype(x3)> ));
+
+            BOOST_TEST_EQ( x3, x2 );
+            BOOST_TEST_NE( &x3, &x2 );
+        }
+
+        {
+            auto&& x4 = r | 3;
+
+            BOOST_TEST_TRAIT_FALSE(( std::is_lvalue_reference<decltype( x4 )> ));
+
+            BOOST_TEST_EQ( x4, 3 );
+        }
     }
 
     {
@@ -150,17 +204,43 @@ int main()
 
         result<int&, E> const r( in_place_error );
 
-        int& x = r | x2;
+        {
+            auto&& x3 = r | x2;
 
-        BOOST_TEST_EQ( &x, &x2 );
+            BOOST_TEST_TRAIT_FALSE(( std::is_lvalue_reference<decltype(x3)> ));
+
+            BOOST_TEST_EQ( x3, x2 );
+            BOOST_TEST_NE( &x3, &x2 );
+        }
+
+        {
+            auto&& x4 = r | 3;
+
+            BOOST_TEST_TRAIT_FALSE(( std::is_lvalue_reference<decltype( x4 )> ));
+
+            BOOST_TEST_EQ( x4, 3 );
+        }
     }
 
     {
         int x2 = 2;
 
-        int& x = result<int&, E>( in_place_error ) | x2;
+        {
+            auto&& x3 = result<int&, E>( in_place_error ) | x2;
 
-        BOOST_TEST_EQ( &x, &x2 );
+            BOOST_TEST_TRAIT_FALSE(( std::is_lvalue_reference<decltype(x3)> ));
+
+            BOOST_TEST_EQ( x3, x2 );
+            BOOST_TEST_NE( &x3, &x2 );
+        }
+
+        {
+            auto&& x4 = result<int&, E>( in_place_error ) | 3;
+
+            BOOST_TEST_TRAIT_FALSE(( std::is_lvalue_reference<decltype( x4 )> ));
+
+            BOOST_TEST_EQ( x4, 3 );
+        }
     }
 
     return boost::report_errors();

test/result_or_value_fail.cpp

@@ -1,14 +0,0 @@
-// Copyright 2017, 2021, 2022 Peter Dimov.
-// Distributed under the Boost Software License, Version 1.0.
-// https://www.boost.org/LICENSE_1_0.txt
-
-#include <boost/system/result.hpp>
-
-using namespace boost::system;
-
-int main()
-{
-    int x = 1;
-    result<int const&> r( x );
-    r | 2;
-}

test/result_or_value_fail2.cpp

@@ -1,13 +0,0 @@
-// Copyright 2017, 2021, 2022 Peter Dimov.
-// Distributed under the Boost Software License, Version 1.0.
-// https://www.boost.org/LICENSE_1_0.txt
-
-#include <boost/system/result.hpp>
-
-using namespace boost::system;
-
-int main()
-{
-    int x = 1;
-    result<int const&>( x ) | 2;
-}

test/result_unsafe_value_access.cpp

@@ -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();
+}

test/result_unsafe_value_access2.cpp

@@ -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();
+}

test/result_value_access.cpp

@@ -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 );
     }
 
     //

test/result_value_construct.cpp

@@ -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 );

test/result_value_construct2.cpp

@@ -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()
 {
     {

test/result_value_construct3.cpp

@@ -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();

test/result_value_construct6.cpp

@@ -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 );

test/result_value_construct7.cpp

@@ -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 );

test/result_value_construct_cx.cpp

@@ -0,0 +1,47 @@
+// Copyright 2017, 2021, 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/config/pragma_message.hpp>
+#include <boost/static_assert.hpp>
+
+#if !defined(BOOST_SYSTEM_HAS_CONSTEXPR)
+
+BOOST_PRAGMA_MESSAGE("Skipping constexpr test, BOOST_SYSTEM_HAS_CONSTEXPR isn't defined")
+
+#else
+
+using namespace boost::system;
+
+int main()
+{
+    {
+        constexpr result<int> r( 0 );
+
+        BOOST_STATIC_ASSERT( r.has_value() );
+        BOOST_STATIC_ASSERT( !r.has_error() );
+
+        BOOST_STATIC_ASSERT( r.value() == 0 );
+        BOOST_STATIC_ASSERT( *r == 0 );
+    }
+
+    {
+        constexpr result<int> r( in_place_value, 1 );
+
+        BOOST_STATIC_ASSERT( r.has_value() );
+        BOOST_STATIC_ASSERT( !r.has_error() );
+
+        BOOST_STATIC_ASSERT( r.value() == 1 );
+        BOOST_STATIC_ASSERT( *r == 1 );
+    }
+
+    {
+        constexpr result<void> r( in_place_value );
+
+        BOOST_STATIC_ASSERT( r.has_value() );
+        BOOST_STATIC_ASSERT( !r.has_error() );
+    }
+}
+
+#endif

test/snprintf_test.cpp

@@ -6,6 +6,12 @@
 # pragma GCC diagnostic ignored "-Wformat-truncation"
 #endif
 
+#if defined(__clang__) && defined(__has_warning)
+# if __has_warning( "-Wformat-truncation" )
+#  pragma clang diagnostic ignored "-Wformat-truncation"
+# endif
+#endif
+
 #include <boost/system/detail/snprintf.hpp>
 #include <boost/core/lightweight_test.hpp>
 

test/unwrap_and_construct.cpp

@@ -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();
+}

test/unwrap_and_construct2.cpp

@@ -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

test/unwrap_and_invoke.cpp

@@ -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();
+}

test/unwrap_and_invoke2.cpp

@@ -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();
+}