Remove local implementation of invoke; use Compat

chore: natvis uses correct layout for std::error_code

.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,59 @@ 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",
     ),
 
     macos_pipeline(

.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,24 @@
+# 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/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
+    ;

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,24 @@ 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.
+
+## 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

@@ -2518,8 +2518,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 +2530,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 +2545,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 +2557,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: ::
 +
 ```

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/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/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>
@@ -332,40 +333,28 @@ public:
 
     BOOST_CXX14_CONSTEXPR T& operator*() noexcept
     {
-        T* p = operator->();
-
-        BOOST_ASSERT( p != 0 );
-
-        return *p;
+        BOOST_ASSERT( has_value() );
+        return *operator->();
     }
 
     BOOST_CXX14_CONSTEXPR T const& operator*() const noexcept
     {
-        T const* p = operator->();
-
-        BOOST_ASSERT( p != 0 );
-
-        return *p;
+        BOOST_ASSERT( has_value() );
+        return *operator->();
     }
 
 #else
 
     BOOST_CXX14_CONSTEXPR T& operator*() & noexcept
     {
-        T* p = operator->();
-
-        BOOST_ASSERT( p != 0 );
-
-        return *p;
+        BOOST_ASSERT( has_value() );
+        return *operator->();
     }
 
     BOOST_CXX14_CONSTEXPR T const& operator*() const & noexcept
     {
-        T const* p = operator->();
-
-        BOOST_ASSERT( p != 0 );
-
-        return *p;
+        BOOST_ASSERT( has_value() );
+        return *operator->();
     }
 
     template<class U = T>
@@ -838,11 +827,8 @@ public:
 
     BOOST_CXX14_CONSTEXPR U& operator*() const noexcept
     {
-        U* p = operator->();
-
-        BOOST_ASSERT( p != 0 );
-
-        return *p;
+        BOOST_ASSERT( has_value() );
+        return *operator->();
     }
 
     // error access
@@ -934,9 +920,10 @@ 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 )
     {
@@ -949,9 +936,10 @@ 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 )
     {
@@ -997,6 +985,26 @@ T operator|( result<T, E>&& r, 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;
+    }
+    else
+    {
+        return std::forward<F>( f )();
+    }
+}
+
 // result | nullary-returning-result
 
 template<class T, class E, class F,
@@ -1123,7 +1131,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 );
+    }
+}
+
+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 +1160,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 );
     }
 }
 
 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 +1177,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 ) );
     }
 }
 
 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 ) );
+    }
+}
+
+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 +1210,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 );
         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 +1227,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 ) );
         return {};
     }
 }
@@ -1227,7 +1269,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 );
+    }
+}
+
+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 +1298,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 );
     }
 }
 
 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 +1315,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 ) );
     }
 }
 

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

@@ -165,8 +165,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 +175,6 @@ 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)

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
@@ -195,8 +198,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 +208,6 @@ 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 ;

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,6 +8,7 @@ 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)
@@ -23,4 +24,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/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/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, 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, &r->v_ );
+        }
+
+        {
+            result<int const&, E2> r2 = r & &X::g2;
+            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &*r2, &r->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, 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, &r->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, 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_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, &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, &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, &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, &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, &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, &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, &*fri() );
     }
 
     {
-        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, &*fri() );
     }
 
     {
-        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, &*fri() );
     }
 
     {
-        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/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>