glob headers

2026-06-11 19:51:11 +02:00 · 2022-07-05 10:48:40 +02:00
120 changed files with 1176 additions and 9240 deletions
@@ -32,8 +32,7 @@ local linux_pipeline(name, image, environment, packages = "", sources = [], arch
            commands:
            [
                'set -e',
-                'uname -a',
-                'echo $DRONE_STAGE_MACHINE',
+                'wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | apt-key add -',
            ] +
            (if sources != [] then [ ('apt-add-repository "' + source + '"') for source in sources ] else []) +
            (if packages != "" then [ 'apt-get update', 'apt-get -y install ' + packages ] else []) +
@@ -98,298 +97,140 @@ local windows_pipeline(name, image, environment, arch = "amd64") =

 [
    linux_pipeline(
-        "Linux 16.04 GCC 4.8",
-        "cppalliance/droneubuntu1604:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++-4.8', CXXSTD: '11' },
-        "g++-4.8",
+        "Linux 14.04 GCC 4.4",
+        "cppalliance/droneubuntu1404:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-4.4', CXXSTD: '98,0x' },
+        "g++-4.4",
+        [ "ppa:ubuntu-toolchain-r/test" ],
    ),

    linux_pipeline(
-        "Linux 16.04 GCC 4.9",
-        "cppalliance/droneubuntu1604:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++-4.9', CXXSTD: '11' },
+        "Linux 14.04 GCC 4.6",
+        "cppalliance/droneubuntu1404:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-4.6', CXXSTD: '98,0x' },
+        "g++-4.6",
+        [ "ppa:ubuntu-toolchain-r/test" ],
+    ),
+
+    linux_pipeline(
+        "Linux 14.04 GCC 4.7",
+        "cppalliance/droneubuntu1404:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-4.7', CXXSTD: '98,0x' },
+        "g++-4.7",
+        [ "ppa:ubuntu-toolchain-r/test" ],
+    ),
+
+    linux_pipeline(
+        "Linux 14.04 GCC 4.8*",
+        "cppalliance/droneubuntu1404:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11' },
+    ),
+
+    linux_pipeline(
+        "Linux 14.04 GCC 4.9",
+        "cppalliance/droneubuntu1404:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-4.9', CXXSTD: '03,11' },
        "g++-4.9",
+        [ "ppa:ubuntu-toolchain-r/test" ],
    ),

    linux_pipeline(
        "Linux 16.04 GCC 5*",
        "cppalliance/droneubuntu1604:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '11,14' },
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14' },
    ),

    linux_pipeline(
        "Linux 18.04 GCC 6",
        "cppalliance/droneubuntu1804:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++-6', CXXSTD: '11,14' },
+        { TOOLSET: 'gcc', COMPILER: 'g++-6', CXXSTD: '03,11,14' },
        "g++-6",
    ),

    linux_pipeline(
        "Linux 18.04 GCC 7* 32/64",
        "cppalliance/droneubuntu1804:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '11,14,17', ADDRMD: '32,64' },
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17', ADDRMD: '32,64' },
    ),

    linux_pipeline(
        "Linux 18.04 GCC 8",
        "cppalliance/droneubuntu1804:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++-8', CXXSTD: '11,14,17' },
+        { TOOLSET: 'gcc', COMPILER: 'g++-8', CXXSTD: '03,11,14,17' },
        "g++-8",
    ),

    linux_pipeline(
        "Linux 20.04 GCC 9* 32",
        "cppalliance/droneubuntu2004:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '11,14,17,2a', ADDRMD: '32' },
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17,2a', ADDRMD: '32' },
    ),

    linux_pipeline(
        "Linux 20.04 GCC 9* 64",
        "cppalliance/droneubuntu2004:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '11,14,17,2a', ADDRMD: '64' },
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17,2a', ADDRMD: '64' },
    ),

    linux_pipeline(
-        "Linux 20.04 GCC 9* ARM64",
+        "Linux 20.04 GCC 9 ARM64 32/64",
        "cppalliance/droneubuntu2004:multiarch",
-        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '11,14,17,2a' },
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17,2a', ADDRMD: '32,64' },
        arch="arm64",
    ),

    linux_pipeline(
-        "Linux 20.04 GCC 9* S390x",
-        "cppalliance/droneubuntu2004:multiarch",
-        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '11,14,17,2a' },
-        arch="s390x",
-    ),
-
-    linux_pipeline(
-        "Linux 20.04 GCC 10 32",
+        "Linux 20.04 GCC 10 32 ASAN",
        "cppalliance/droneubuntu2004:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++-10', CXXSTD: '11,14,17,20', ADDRMD: '32' },
+        { TOOLSET: 'gcc', COMPILER: 'g++-10', CXXSTD: '03,11,14,17,20', ADDRMD: '32' } + asan,
        "g++-10-multilib",
    ),

    linux_pipeline(
-        "Linux 20.04 GCC 10 64",
+        "Linux 20.04 GCC 10 64 ASAN",
        "cppalliance/droneubuntu2004:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++-10', CXXSTD: '11,14,17,20', ADDRMD: '64' },
+        { TOOLSET: 'gcc', COMPILER: 'g++-10', CXXSTD: '03,11,14,17,20', ADDRMD: '64' } + asan,
        "g++-10-multilib",
    ),

    linux_pipeline(
-        "Linux 22.04 GCC 11* 32",
-        "cppalliance/droneubuntu2204:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '11,14,17,2a', ADDRMD: '32' },
-    ),
-
-    linux_pipeline(
-        "Linux 22.04 GCC 11* 64",
-        "cppalliance/droneubuntu2204:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '11,14,17,2a', ADDRMD: '64' },
-    ),
-
-    linux_pipeline(
-        "Linux 22.04 GCC 12 32",
-        "cppalliance/droneubuntu2204:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++-12', CXXSTD: '11,14,17,20,2b', ADDRMD: '32' },
-        "g++-12-multilib",
-    ),
-
-    linux_pipeline(
-        "Linux 22.04 GCC 12 64",
-        "cppalliance/droneubuntu2204:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++-12', CXXSTD: '11,14,17,20,2b', ADDRMD: '64' },
-        "g++-12-multilib",
-    ),
-
-    linux_pipeline(
-        "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 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",
-        { TOOLSET: 'clang', COMPILER: 'clang++-3.5', CXXSTD: '11' },
-        "clang-3.5",
-    ),
-
-    linux_pipeline(
-        "Linux 16.04 Clang 3.6",
-        "cppalliance/droneubuntu1604:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-3.6', CXXSTD: '11,14' },
-        "clang-3.6",
-    ),
-
-    linux_pipeline(
-        "Linux 16.04 Clang 3.7",
-        "cppalliance/droneubuntu1604:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-3.7', CXXSTD: '11,14' },
-        "clang-3.7",
-    ),
-
-    linux_pipeline(
-        "Linux 16.04 Clang 3.8",
-        "cppalliance/droneubuntu1604:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-3.8', CXXSTD: '11,14' },
-        "clang-3.8",
-    ),
-
-    linux_pipeline(
-        "Linux 22.04 Clang 13",
-        "cppalliance/droneubuntu2204:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-13', CXXSTD: '11,14,17,20' },
+        "Linux 20.04 Clang 13",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-13', CXXSTD: '03,11,14,17,20' },
        "clang-13",
+        ["deb http://apt.llvm.org/focal/ llvm-toolchain-focal-13 main"],
    ),

    linux_pipeline(
-        "Linux 22.04 Clang 14",
-        "cppalliance/droneubuntu2204:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-14', CXXSTD: '11,14,17,20' },
+        "Linux 20.04 Clang 14 UBSAN",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-14', CXXSTD: '03,11,14,17,20' } + ubsan,
        "clang-14",
+        ["deb http://apt.llvm.org/focal/ llvm-toolchain-focal-14 main"],
    ),

    linux_pipeline(
-        "Linux 22.04 Clang 15",
-        "cppalliance/droneubuntu2204:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-15', CXXSTD: '11,14,17,20,2b' },
-        "clang-15",
-    ),
-
-    linux_pipeline(
-        "Linux 24.04 Clang 16",
-        "cppalliance/droneubuntu2404:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-16', CXXSTD: '11,14,17,20,2b' },
-        "clang-16",
-    ),
-
-    linux_pipeline(
-        "Linux 24.04 Clang 17",
-        "cppalliance/droneubuntu2404:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-17', CXXSTD: '11,14,17,20,2b' },
-        "clang-17",
-    ),
-
-    linux_pipeline(
-        "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",
+        "Linux 20.04 Clang 14 ASAN",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-14', CXXSTD: '03,11,14,17,20' } + asan,
+        "clang-14",
+        ["deb http://apt.llvm.org/focal/ llvm-toolchain-focal-14 main"],
    ),

    macos_pipeline(
        "MacOS 10.15 Xcode 12.2 UBSAN",
-        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '11,14,1z' } + ubsan,
+        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '03,11,14,1z' } + ubsan,
    ),

    macos_pipeline(
        "MacOS 10.15 Xcode 12.2 ASAN",
-        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '11,14,1z' } + asan,
-    ),
-
-    macos_pipeline(
-        "MacOS 12.4 Xcode 13.4.1 UBSAN",
-        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '11,14,17,20,2b' } + ubsan,
-        xcode_version = "13.4.1", osx_version = "monterey", arch = "arm64",
-    ),
-
-    macos_pipeline(
-        "MacOS 12.4 Xcode 13.4.1 ASAN",
-        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '11,14,17,20,2b' } + asan,
-        xcode_version = "13.4.1", osx_version = "monterey", arch = "arm64",
+        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '03,11,14,1z' } + asan,
    ),

    windows_pipeline(
        "Windows VS2015 msvc-14.0",
        "cppalliance/dronevs2015",
-        { TOOLSET: 'msvc-14.0', CXXSTD: '14,latest', B2_DONT_EMBED_MANIFEST: '1' },
+        { TOOLSET: 'msvc-14.0', CXXSTD: '14,latest' },
    ),

    windows_pipeline(
@@ -409,10 +250,4 @@ 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' },
-    ),
 ]
@@ -5,7 +5,6 @@
 # https://www.boost.org/LICENSE_1_0.txt

 set -ex
-export PATH=~/.local/bin:/usr/local/bin:$PATH

 DRONE_BUILD_DIR=$(pwd)

@@ -18,232 +18,108 @@ jobs:
      matrix:
        include:
          - toolset: gcc-4.8
-            cxxstd: "11"
-            container: ubuntu:18.04
-            os: ubuntu-latest
+            cxxstd: "03,11"
+            os: ubuntu-18.04
            install: g++-4.8
          - toolset: gcc-5
-            cxxstd: "11,14,1z"
-            container: ubuntu:18.04
-            os: ubuntu-latest
+            cxxstd: "03,11,14,1z"
+            os: ubuntu-18.04
            install: g++-5
          - toolset: gcc-6
-            cxxstd: "11,14,1z"
-            container: ubuntu:18.04
-            os: ubuntu-latest
+            cxxstd: "03,11,14,1z"
+            os: ubuntu-18.04
            install: g++-6
          - toolset: gcc-7
-            cxxstd: "11,14,17"
-            container: ubuntu:18.04
-            os: ubuntu-latest
+            cxxstd: "03,11,14,17"
+            os: ubuntu-18.04
          - toolset: gcc-8
-            cxxstd: "11,14,17,2a"
-            container: ubuntu:20.04
-            os: ubuntu-latest
+            cxxstd: "03,11,14,17,2a"
+            os: ubuntu-18.04
            install: g++-8
          - toolset: gcc-9
-            cxxstd: "11,14,17,2a"
-            container: ubuntu:20.04
-            os: ubuntu-latest
+            cxxstd: "03,11,14,17,2a"
+            os: ubuntu-20.04
          - toolset: gcc-10
-            cxxstd: "11,14,17,2a"
-            container: ubuntu:20.04
-            os: ubuntu-latest
+            cxxstd: "03,11,14,17,2a"
+            os: ubuntu-20.04
            install: g++-10
          - toolset: gcc-11
-            cxxstd: "11,14,17,2a"
-            os: ubuntu-22.04
+            cxxstd: "03,11,14,17,2a"
+            os: ubuntu-20.04
+            install: g++-11
          - toolset: gcc-12
-            cxxstd: "11,14,17,20,2b"
+            cxxstd: "03,11,14,17,20"
            os: ubuntu-22.04
            install: g++-12
-          - toolset: gcc-13
-            cxxstd: "11,14,17,20,2b"
-            container: ubuntu:24.04
-            os: ubuntu-latest
-            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"
-            container: ubuntu:18.04
-            os: ubuntu-latest
+            cxxstd: "03,11,14"
+            os: ubuntu-18.04
            install: clang-3.9
          - toolset: clang
            compiler: clang++-4.0
-            cxxstd: "11,14"
-            container: ubuntu:18.04
-            os: ubuntu-latest
+            cxxstd: "03,11,14"
+            os: ubuntu-18.04
            install: clang-4.0
          - toolset: clang
            compiler: clang++-5.0
-            cxxstd: "11,14,1z"
-            container: ubuntu:18.04
-            os: ubuntu-latest
+            cxxstd: "03,11,14,1z"
+            os: ubuntu-18.04
            install: clang-5.0
          - toolset: clang
            compiler: clang++-6.0
-            cxxstd: "11,14,17"
-            container: ubuntu:20.04
-            os: ubuntu-latest
+            cxxstd: "03,11,14,17"
+            os: ubuntu-18.04
            install: clang-6.0
          - toolset: clang
            compiler: clang++-7
-            cxxstd: "11,14,17"
-            stdlib: "native,libc++"
-            container: ubuntu:20.04
-            os: ubuntu-latest
-            install: clang-7 libc++-7-dev libc++abi-7-dev
+            cxxstd: "03,11,14,17"
+            os: ubuntu-18.04
+            install: clang-7
          - toolset: clang
            compiler: clang++-8
-            cxxstd: "11,14,17"
-            stdlib: "native,libc++"
-            container: ubuntu:20.04
-            os: ubuntu-latest
-            install: clang-8 libc++-8-dev libc++abi-8-dev
+            cxxstd: "03,11,14,17"
+            os: ubuntu-20.04
+            install: clang-8
          - toolset: clang
            compiler: clang++-9
-            cxxstd: "11,14,17"
-            stdlib: "native,libc++"
-            container: ubuntu:20.04
-            os: ubuntu-latest
-            install: clang-9 libc++-9-dev libc++abi-9-dev
+            cxxstd: "03,11,14,17"
+            os: ubuntu-20.04
+            install: clang-9
          - toolset: clang
            compiler: clang++-10
-            cxxstd: "11,14,17,2a"
-            stdlib: "native,libc++"
-            container: ubuntu:20.04
-            os: ubuntu-latest
-            install: clang-10 libc++-10-dev libc++abi-10-dev
+            cxxstd: "03,11,14,17,2a"
+            os: ubuntu-20.04
          - toolset: clang
            compiler: clang++-11
-            cxxstd: "11,14,17,2a"
-            stdlib: "native,libc++"
-            container: ubuntu:20.04
-            os: ubuntu-latest
-            install: clang-11 libc++-11-dev libc++abi-11-dev
+            cxxstd: "03,11,14,17,2a"
+            os: ubuntu-20.04
          - toolset: clang
            compiler: clang++-12
-            cxxstd: "11,14,17,20"
-            stdlib: "native,libc++"
-            container: ubuntu:20.04
-            os: ubuntu-latest
-            install: clang-12 libc++-12-dev libc++abi-12-dev
+            cxxstd: "03,11,14,17,20"
+            os: ubuntu-20.04
          - toolset: clang
            compiler: clang++-13
-            cxxstd: "11,14,17,20,2b"
-            stdlib: "native,libc++"
-            container: ubuntu:22.04
-            os: ubuntu-latest
-            install: clang-13 libc++-13-dev libc++abi-13-dev
+            cxxstd: "03,11,14,17,20"
+            os: ubuntu-22.04
+            install: clang-13
          - toolset: clang
            compiler: clang++-14
-            cxxstd: "11,14,17,20,2b"
-            stdlib: "native,libc++"
-            container: ubuntu:22.04
-            os: ubuntu-latest
-            install: clang-14 libc++-14-dev libc++abi-14-dev
+            cxxstd: "03,11,14,17,20"
+            os: ubuntu-22.04
+            install: clang-14
          - toolset: clang
-            compiler: clang++-15
-            cxxstd: "11,14,17,20,2b"
-            container: ubuntu:22.04
-            stdlib: "native,libc++"
-            os: ubuntu-latest
-            install: clang-15 libc++-15-dev libc++abi-15-dev
-          - toolset: clang
-            compiler: clang++-16
-            cxxstd: "11,14,17,20,2b"
-            stdlib: "native,libc++"
-            container: ubuntu:24.04
-            os: ubuntu-latest
-            install: clang-16 libc++-16-dev libc++abi-16-dev
-          - toolset: clang
-            compiler: clang++-17
-            cxxstd: "11,14,17,20,2b"
-            stdlib: "native,libc++"
-            container: ubuntu:24.04
-            os: ubuntu-latest
-            install: clang-17 libc++-17-dev libc++abi-17-dev
-          - toolset: clang
-            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-14
-          - toolset: clang
-            cxxstd: "11,14,17,20,2b"
-            os: macos-15
-          - toolset: clang
-            cxxstd: "11,14,17,20,23,2c"
-            os: macos-26
+            cxxstd: "03,11,14,17,2a"
+            os: macos-10.15

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

-    container:
-      image: ${{matrix.container}}
-      volumes:
-        - /node20217:/node20217:rw,rshared
-        - ${{ startsWith(matrix.container, 'ubuntu:1') && '/node20217:/__e/node20:ro,rshared' || ' ' }}
-
-    defaults:
-      run:
-        shell: bash
-
    steps:
-      - name: Setup container environment
-        if: matrix.container
-        run: |
-          apt-get update
-          apt-get -y install sudo python3 git g++ curl xz-utils
-
-      - name: Install nodejs20glibc2.17
-        if: ${{ startsWith( matrix.container, 'ubuntu:1' ) }}
-        run: |
-          curl -LO https://archives.boost.io/misc/node/node-v20.9.0-linux-x64-glibc-217.tar.xz
-          tar -xf node-v20.9.0-linux-x64-glibc-217.tar.xz --strip-components 1 -C /node20217
-          ldd /__e/node20/bin/node
-
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v2

      - name: Install packages
        if: matrix.install
-        run: |
-          sudo apt-get update
-          sudo apt-get -y install ${{matrix.install}}
+        run: sudo apt install ${{matrix.install}}

      - name: Setup Boost
        run: |
@@ -263,7 +139,7 @@ jobs:
          cd boost-root
          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
          git submodule update --init tools/boostdep
-          python3 tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
          ./bootstrap.sh
          ./b2 -d0 headers

@@ -275,30 +151,38 @@ jobs:
      - name: Run tests
        run: |
          cd ../boost-root
-          ./b2 -j3 libs/$LIBRARY/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} variant=debug,release ${{ matrix.stdlib && format('stdlib={0}', matrix.stdlib) }}
+          ./b2 -j3 libs/$LIBRARY/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} variant=debug,release

  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
            os: windows-2022
          - toolset: clang-win
-            cxxstd: "14,17,20,latest"
+            cxxstd: "14,17,latest"
            addrmd: 32,64
            os: windows-2022
          - toolset: gcc
-            cxxstd: "11,14,17,2a"
+            cxxstd: "03,11,14,17,2a"
            addrmd: 64
-            os: windows-2022
+            os: windows-2019

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

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

      - name: Setup Boost
        shell: cmd
@@ -333,17 +217,19 @@ jobs:
      fail-fast: false
      matrix:
        include:
-          - os: ubuntu-latest
-          - os: macos-latest
+          - os: ubuntu-18.04
+          - os: ubuntu-20.04
+          - os: ubuntu-22.04
+          - os: macos-10.15

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

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

      - name: Install packages
        if: matrix.install
-        run: sudo apt-get -y install ${{matrix.install}}
+        run: sudo apt install ${{matrix.install}}

      - name: Setup Boost
        run: |
@@ -378,17 +264,19 @@ jobs:
      fail-fast: false
      matrix:
        include:
-          - os: ubuntu-latest
-          - os: macos-latest
+          - os: ubuntu-18.04
+          - os: ubuntu-20.04
+          - os: ubuntu-22.04
+          - os: macos-10.15

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

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

      - name: Install packages
        if: matrix.install
-        run: sudo apt-get -y install ${{matrix.install}}
+        run: sudo apt install ${{matrix.install}}

      - name: Setup Boost
        run: |
@@ -433,17 +321,19 @@ jobs:
      fail-fast: false
      matrix:
        include:
-          - os: ubuntu-latest
-          - os: macos-latest
+          - os: ubuntu-18.04
+          - os: ubuntu-20.04
+          - os: ubuntu-22.04
+          - os: macos-10.15

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

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

      - name: Install packages
        if: matrix.install
-        run: sudo apt-get -y install ${{matrix.install}}
+        run: sudo apt install ${{matrix.install}}

      - name: Setup Boost
        run: |
@@ -480,180 +370,3 @@ jobs:
        run: |
          cd ../boost-root/__build__
          ctest --output-on-failure --no-tests=error
-
-  windows-cmake-subdir:
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - os: windows-latest
-
-    runs-on: ${{matrix.os}}
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Setup Boost
-        shell: cmd
-        run: |
-          echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
-          for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
-          echo LIBRARY: %LIBRARY%
-          echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
-          echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
-          echo GITHUB_REF: %GITHUB_REF%
-          if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
-          set BOOST_BRANCH=develop
-          for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
-          echo BOOST_BRANCH: %BOOST_BRANCH%
-          cd ..
-          git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
-          cd boost-root
-          xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\
-          git submodule update --init tools/boostdep
-          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" %LIBRARY%
-
-      - name: Use library with add_subdirectory (Debug)
-        shell: cmd
-        run: |
-          cd ../boost-root/libs/%LIBRARY%/test/cmake_subdir_test
-          mkdir __build__ && cd __build__
-          cmake ..
-          cmake --build . --config Debug
-          ctest --output-on-failure --no-tests=error -C Debug
-
-      - name: Use library with add_subdirectory (Release)
-        shell: cmd
-        run: |
-          cd ../boost-root/libs/%LIBRARY%/test/cmake_subdir_test/__build__
-          cmake --build . --config Release
-          ctest --output-on-failure --no-tests=error -C Release
-
-  windows-cmake-install:
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - os: windows-latest
-
-    runs-on: ${{matrix.os}}
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Setup Boost
-        shell: cmd
-        run: |
-          echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
-          for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
-          echo LIBRARY: %LIBRARY%
-          echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
-          echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
-          echo GITHUB_REF: %GITHUB_REF%
-          if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
-          set BOOST_BRANCH=develop
-          for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
-          echo BOOST_BRANCH: %BOOST_BRANCH%
-          cd ..
-          git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
-          cd boost-root
-          xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\
-          git submodule update --init tools/boostdep
-          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" %LIBRARY%
-
-      - name: Configure
-        shell: cmd
-        run: |
-          cd ../boost-root
-          mkdir __build__ && cd __build__
-          cmake -DBOOST_INCLUDE_LIBRARIES=%LIBRARY% -DCMAKE_INSTALL_PREFIX=C:/cmake-prefix ..
-
-      - name: Install (Debug)
-        shell: cmd
-        run: |
-          cd ../boost-root/__build__
-          cmake --build . --target install --config Debug
-
-      - name: Install (Release)
-        shell: cmd
-        run: |
-          cd ../boost-root/__build__
-          cmake --build . --target install --config Release
-
-      - name: Use the installed library (Debug)
-        shell: cmd
-        run: |
-          cd ../boost-root/libs/%LIBRARY%/test/cmake_install_test && mkdir __build__ && cd __build__
-          cmake -DCMAKE_INSTALL_PREFIX=C:/cmake-prefix ..
-          cmake --build . --config Debug
-          ctest --output-on-failure --no-tests=error -C Debug
-
-      - name: Use the installed library (Release)
-        shell: cmd
-        run: |
-          cd ../boost-root/libs/%LIBRARY%/test/cmake_install_test/__build__
-          cmake --build . --config Release
-          ctest --output-on-failure --no-tests=error -C Release
-
-  windows-cmake-test:
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - os: windows-latest
-
-    runs-on: ${{matrix.os}}
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Setup Boost
-        shell: cmd
-        run: |
-          echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
-          for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
-          echo LIBRARY: %LIBRARY%
-          echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
-          echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
-          echo GITHUB_REF: %GITHUB_REF%
-          if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
-          set BOOST_BRANCH=develop
-          for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
-          echo BOOST_BRANCH: %BOOST_BRANCH%
-          cd ..
-          git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
-          cd boost-root
-          xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\
-          git submodule update --init tools/boostdep
-          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" %LIBRARY%
-
-      - name: Configure
-        shell: cmd
-        run: |
-          cd ../boost-root
-          mkdir __build__ && cd __build__
-          cmake -DBOOST_INCLUDE_LIBRARIES=%LIBRARY% -DBUILD_TESTING=ON ..
-
-      - name: Build tests (Debug)
-        shell: cmd
-        run: |
-          cd ../boost-root/__build__
-          cmake --build . --target tests --config Debug
-
-      - name: Run tests (Debug)
-        shell: cmd
-        run: |
-          cd ../boost-root/__build__
-          ctest --output-on-failure --no-tests=error -C Debug
-
-      - name: Build tests (Release)
-        shell: cmd
-        run: |
-          cd ../boost-root/__build__
-          cmake --build . --target tests --config Release
-
-      - name: Run tests (Release)
-        shell: cmd
-        run: |
-          cd ../boost-root/__build__
-          ctest --output-on-failure --no-tests=error -C Release
@@ -1,8 +1,10 @@
 # Copyright 2018-2021 Peter Dimov
 # Distributed under the Boost Software License, Version 1.0.
-# https://www.boost.org/LICENSE_1_0.txt
+# See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt

-cmake_minimum_required(VERSION 3.8...3.31)
+if(NOT DEFINED IDF_TARGET)
+
+cmake_minimum_required(VERSION 3.5...3.16)

 project(boost_system VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX)

@@ -14,26 +16,34 @@ target_include_directories(boost_system INTERFACE include)
 target_link_libraries(boost_system
  INTERFACE
    Boost::assert
-    Boost::compat
    Boost::config
    Boost::throw_exception
    Boost::variant2
    Boost::winapi
 )

-target_compile_features(boost_system INTERFACE cxx_std_11)
-
-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")
-  list(APPEND boost_system_IDEFILES extra/boost_system.natvis)
-  target_sources(boost_system PRIVATE ${boost_system_IDEFILES})
-
-endif()
-
-if(BUILD_TESTING AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/CMakeLists.txt")
+if(BUILD_TESTING)

  add_subdirectory(test)

 endif()
+
+else()
+
+FILE(GLOB_RECURSE headers include/*.h include/*.hpp)
+
+idf_component_register(
+    SRCS
+        ${headers}
+    INCLUDE_DIRS
+        include
+    REQUIRES
+      boost_assert
+      boost_config
+      boost_throw_exception
+      boost_variant2
+#      boost_winapi
+)
+
+endif()
+
@@ -14,27 +14,32 @@ branches:

 environment:
  matrix:
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      TOOLSET: msvc-14.1
-      CXXSTD: 14,17,latest
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      TOOLSET: msvc-9.0,msvc-10.0,msvc-11.0
      ADDRMD: 32
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      TOOLSET: msvc-12.0,msvc-14.0
+      ADDRMD: 32,64
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
      TOOLSET: msvc-14.1
      CXXSTD: 14,17,latest
-      ADDRMD: 64
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
+      ADDRMD: 32,64
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      ADDPATH: C:\cygwin\bin;
+      TOOLSET: gcc
+      CXXSTD: 03,11,14,1z
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
      ADDPATH: C:\cygwin64\bin;
      TOOLSET: gcc
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
-      ADDPATH: C:\mingw-w64\i686-8.1.0-posix-dwarf-rt_v6-rev0\mingw32\bin;
-      TOOLSET: gcc
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
-      ADDPATH: C:\mingw-w64\x86_64-8.1.0-posix-seh-rt_v6-rev0\mingw64\bin;
-      TOOLSET: gcc
+      CXXSTD: 03,11,14,1z
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      CMAKE_SUBDIR: 1
+      ADDPATH: C:\mingw\bin;
+      TOOLSET: gcc
+      CXXSTD: 03,11,14,1z
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      CMAKE_INSTALL: 1
+      ADDPATH: C:\mingw-w64\x86_64-6.3.0-posix-seh-rt_v5-rev1\mingw64\bin;
+      TOOLSET: gcc
+      CXXSTD: 03,11,14,1z

 install:
  - set BOOST_BRANCH=develop
@@ -54,27 +59,4 @@ test_script:
  - PATH=%ADDPATH%%PATH%
  - if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
  - if not "%ADDRMD%" == "" set ADDRMD=address-model=%ADDRMD%
-  - if "%CMAKE%%CMAKE_SUBDIR%%CMAKE_INSTALL%" == ""  b2 -j3 libs/system/test toolset=%TOOLSET% %CXXSTD% %ADDRMD% variant=debug,release embed-manifest-via=linker
-
-  - if not "%CMAKE%" == ""  mkdir __build__ && cd __build__
-  - if not "%CMAKE%" == ""  cmake -DBUILD_TESTING=ON -DBOOST_INCLUDE_LIBRARIES=system -DBoost_VERBOSE=ON ..
-  - if not "%CMAKE%" == ""  cmake --build . --target tests -j 3 --config Debug & ctest --output-on-failure --no-tests=error -j 3 -C Debug
-  - if not "%CMAKE%" == ""  cmake --build . --target tests -j 3 --config Release & ctest --output-on-failure --no-tests=error -j 3 -C Release
-  - if not "%CMAKE%" == ""  cmake --build . --target tests -j 3 --config MinSizeRel & ctest --output-on-failure --no-tests=error -j 3 -C MinSizeRel
-  - if not "%CMAKE%" == ""  cmake --build . --target tests -j 3 --config RelWithDebInfo & ctest --output-on-failure --no-tests=error -j 3 -C RelWithDebInfo
-
-  - if not "%CMAKE_SUBDIR%" == ""  cd libs/system/test/cmake_subdir_test && mkdir __build__ && cd __build__
-  - if not "%CMAKE_SUBDIR%" == ""  cmake ..
-  - if not "%CMAKE_SUBDIR%" == ""  cmake --build . --config Debug && cmake --build . --target check --config Debug
-  - if not "%CMAKE_SUBDIR%" == ""  cmake --build . --config Release && cmake --build . --target check --config Release
-  - if not "%CMAKE_SUBDIR%" == ""  cmake --build . --config MinSizeRel && cmake --build . --target check --config MinSizeRel
-  - if not "%CMAKE_SUBDIR%" == ""  cmake --build . --config RelWithDebInfo && cmake --build . --target check --config RelWithDebInfo
-
-  - if not "%CMAKE_INSTALL%" == ""  mkdir __build__ && cd __build__
-  - if not "%CMAKE_INSTALL%" == ""  cmake -DBOOST_INCLUDE_LIBRARIES=system -DCMAKE_INSTALL_PREFIX=C:/cmake-prefix ..
-  - if not "%CMAKE_INSTALL%" == ""  cmake --build . --target install --config Debug
-  - if not "%CMAKE_INSTALL%" == ""  cmake --build . --target install --config Release
-  - if not "%CMAKE_INSTALL%" == ""  cd ../libs/system/test/cmake_install_test && mkdir __build__ && cd __build__
-  - if not "%CMAKE_INSTALL%" == ""  cmake -DCMAKE_INSTALL_PREFIX=C:/cmake-prefix ..
-  - if not "%CMAKE_INSTALL%" == ""  cmake --build . --config Debug && cmake --build . --target check --config Debug
-  - if not "%CMAKE_INSTALL%" == ""  cmake --build . --config Release && cmake --build . --target check --config Release
+  - b2 -j3 libs/system/test toolset=%TOOLSET% %CXXSTD% %ADDRMD% variant=debug,release embed-manifest-via=linker
@@ -1,26 +0,0 @@
-# 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
-    ;
@@ -0,0 +1,25 @@
+# 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 ;
@@ -1,5 +1,5 @@
 ////
-Copyright 2018-2025 Peter Dimov
+Copyright 2018-2022 Peter Dimov
 Distributed under the Boost Software License, Version 1.0.
 https://www.boost.org/LICENSE_1_0.txt
 ////
@@ -8,51 +8,6 @@ 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 ...)`.
-
-## 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.)
-* The deprecated header `boost/system/cygwin_error.hpp` has been removed.
-* The original and obsolete (32 bit) MinGW is no longer supported. MinGW-w64 (both 64 and 32 bit) is still supported.
-* `operator&` now works for `result<void>` (by way of taking a nullary function.)
-* Added `operator|=` for `result`.
-
-## Changes in Boost 1.84
-
-* Added support for `result<U&, E>`.
-* Added `operator|` for `result`.
-* Added `operator&` for `result`.
-* Added `operator&=` for `result`.
-
-## Changes in Boost 1.81
-
-* The macro `BOOST_SYSTEM_DISABLE_THREADS` can now be defined to disable
-  the use of `<mutex>` (e.g. on single-threaded libstdc++).
-* Added `value_type`, `error_type`, `in_place_value`, `in_place_error`
-  to `result<>`.
-* Added `emplace` to `result<>`.
-
 ## Changes in Boost 1.80

 * When an `error_code` is converted to `std::error_code` and then back
@@ -12,6 +12,13 @@ http://www.boost.org/LICENSE_1_0.txt
 # Reference
 :idprefix: ref_

+## Use of {cpp}11 and {cpp}14 Features
+
+The library is documented to use several {cpp}11 and {cpp}14 features,
+including `noexcept`, explicit conversion operators and `constexpr`. The
+actual implementation uses {cpp}11 and {cpp}14 features only when they are
+available, and otherwise falls back on {cpp}03 features.
+
 ## Macros

 When `BOOST_SYSTEM_ENABLE_DEPRECATED` is defined, the library provides
@@ -22,11 +29,6 @@ When `BOOST_SYSTEM_USE_UTF8` is defined, on Windows the library returns
 UTF-8 messages using code page `CP_UTF8` instead of the default `CP_ACP`.
 This macro has no effect on POSIX.

-When `BOOST_SYSTEM_DISABLE_THREADS` is defined, the library assumes that
-the current platform doesn't support multiple threads and disables the use
-of the standard header `<mutex>`, eliminating the mutex locks. The single
-threaded `libstdc++` is one such platform.
-
 ## Deprecated Names

 In the process of adding Boost.System to the {cpp}11 standard library, the
@@ -1510,38 +1512,6 @@ constexpr in_place_error_t in_place_error{};

 template<class T, class E = error_code> class result;
 template<class E> class result<void, E>;
-template<class U, class E> class result<U&, E>;
-
-// 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 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, class R = ...> R operator|( result<T, E> const& r, F&& f );
-template<class T, class E, class F, class R = ...> R operator|( result<T, E>&& r, F&& f );
-template<class E, class F, class R = ...> R operator|( result<void, E> const& r, F&& f );
-template<class E, class F, class R = ...> R operator|( result<void, E>&& r, F&& f );
-
-// operator&
-
-template<class T, class E, class F, class U = ...>
-  result<U, E> operator&( result<T, E> const& r, F&& f );
-template<class T, class E, class F, class U = ...>
-  result<U, E> operator&( result<T, E>&& r, F&& f );
-
-template<class T, class E, class F, class R = ...> R operator&( result<T, E> const& r, F&& f );
-template<class T, class E, class F, class R = ...> R operator&( result<T, E>&& r, F&& f );
-
-// operator&=
-
-template<class T, class E, class F, class U = ...>
-  result<T, E>& operator&=( result<T, E>& r, F&& f );
-
-template<class T, class E, class F, class R = ...>
-  result<T, E>& operator&=( result<T, E>& r, F&& f );

 } // namespace system
 } // namespace boost
@@ -1625,12 +1595,6 @@ template<class T, class E = error_code> class result
 {
 public:

-    using value_type = T;
-    using error_type = E;
-
-    static constexpr in_place_value_t in_place_value{};
-    static constexpr in_place_error_t in_place_error{};
-
    // constructors

    constexpr result();
@@ -1682,13 +1646,7 @@ public:

    // error access

-    constexpr E error() const &;
-    constexpr E error() &&;
-
-    // emplace
-
-    template<class... A>
-      constexpr T& emplace( A&&... a );
+    constexpr E error() const;

    // swap

@@ -1738,7 +1696,7 @@ Effects: ::
    ensures that `*this` holds the error `E( std::forward<A>(a)... )`.
  - Otherwise, this constructor does not participate in overload resolution.
 Remarks: ::
-  This constructor is only enabled when `sizeof...(A) > 0`.
+  This constructor is only enabled when `sizeof...(T) > 0`.

 ```
 template<class... A>
@@ -1772,7 +1730,7 @@ template<class T2, class E2>
 * {blank}
 +
 Ensures: ::
-  If `r2.has_value()` is `true`, `*this` holds the value `T( *r2 )`, otherwise `*this` holds the error `E( r2.error() )`.
+  If `r2.has_value()` is `true`, `*this` holds the value `T( *r2 )`, otherwise `*this` holds the value `E( r2.error() )`.
 Remarks: ::
  This constructor is only enabled when `std::is_convertible<T2, T>::value && std::is_convertible<E2, E>::value` is `true`.

@@ -1784,7 +1742,7 @@ template<class T2, class E2>
 * {blank}
 +
 Ensures: ::
-  If `r2.has_value()` is `true`, `*this` holds the value `T( std::move( *r2 ) )`, otherwise `*this` holds the error `E( r2.error() )`.
+  If `r2.has_value()` is `true`, `*this` holds the value `T( std::move( *r2 ) )`, otherwise `*this` holds the value `E( r2.error() )`.
 Remarks: ::
  This constructor is only enabled when `std::is_convertible<T2, T>::value && std::is_convertible<E2, E>::value` is `true`.

@@ -1877,8 +1835,7 @@ Returns: ::
 #### Error Access

 ```
-constexpr E error() const &;
-constexpr E error() &&;
+constexpr E error() const;
 ```
 [none]
 * {blank}
@@ -1886,20 +1843,6 @@ constexpr E error() &&;
 Effects: ::
  If `*this` holds an error, returns it. Otherwise, returns `E()`.

-#### emplace
-
-```
-template<class... A>
-  constexpr T& emplace( A&&... a );
-```
-[none]
-* {blank}
-+
-Ensures: ::
-  `*this` holds the value `T( std::forward<A>(a)... )`.
-Returns: ::
-  A reference to the contained value.
-
 #### swap

 ```
@@ -1968,12 +1911,6 @@ template<class E> class result<void, E>
 {
 public:

-    using value_type = void;
-    using error_type = E;
-
-    static constexpr in_place_value_t in_place_value{};
-    static constexpr in_place_error_t in_place_error{};
-
    // constructors

    constexpr result() noexcept;
@@ -1986,9 +1923,6 @@ public:
    template<class... A>
      constexpr result( in_place_error_t, A&&... a );

-    template<class E2>
-      constexpr result( result<void, E2> const& r2 );
-
    // queries

    constexpr bool has_value() const noexcept;
@@ -2009,12 +1943,7 @@ public:

    // error access

-    constexpr E error() const &;
-    constexpr E error() &&;
-
-    // emplace
-
-    constexpr void emplace();
+    constexpr E error() const;

    // swap

@@ -2060,7 +1989,7 @@ Effects: ::
    ensures that `*this` holds the error `E( std::forward<A>(a)... )`.
  - Otherwise, this constructor does not participate in overload resolution.
 Remarks: ::
-  This constructor is only enabled when `sizeof...(A) > 0`.
+  This constructor is only enabled when `sizeof...(T) > 0`.

 ```
 template<class... A>
@@ -2084,18 +2013,6 @@ Ensures: ::
 Remarks: ::
  This constructor is only enabled when `std::is_constructible<E, A...>::value` is `true`.

-```
-template<class E2>
-  constexpr result( result<void, E2> const& r2 );
-```
-[none]
-* {blank}
-+
-Ensures: ::
-  If `r2.has_value()` is `true`, `*this` holds an unspecified value, otherwise `*this` holds the error `E( r2.error() )`.
-Remarks: ::
-  This constructor is only enabled when `std::is_convertible<E2, E>::value` is `true`.
-
 #### Queries

 ```
@@ -2163,8 +2080,7 @@ Effects: ::
 #### Error Access

 ```
-constexpr E error() const &;
-constexpr E error() &&;
+constexpr E error() const;
 ```
 [none]
 * {blank}
@@ -2172,17 +2088,6 @@ constexpr E error() &&;
 Effects: ::
  If `*this` holds an error, returns it. Otherwise, returns `E()`.

-#### emplace
-
-```
-constexpr void emplace();
-```
-[none]
-* {blank}
-+
-Ensures: ::
-  `*this` holds an unspecified value.
-
 #### swap

 ```
@@ -2241,638 +2146,6 @@ Effects: ::
 Returns: ::
  `os`.

-### result<U&, E>
-
-```
-namespace boost {
-namespace system {
-
-template<class U, class E> class result<U&, E>
-{
-public:
-
-    using value_type = U&;
-    using error_type = E;
-
-    static constexpr in_place_value_t in_place_value{};
-    static constexpr in_place_error_t in_place_error{};
-
-    // constructors
-
-    template<class A>
-      constexpr result( A&& a ) noexcept;
-
-    template<class... A>
-      constexpr result( A&&... a );
-
-    template<class A>
-      constexpr result( in_place_value_t, A&& a ) noexcept;
-
-    template<class... A>
-      constexpr result( in_place_error_t, A&&... a );
-
-    template<class U2, class E2>
-      constexpr result( result<U2&, E2> const& r2 );
-
-    // queries
-
-    constexpr bool has_value() const noexcept;
-    constexpr bool has_error() const noexcept;
-    constexpr explicit operator bool() const noexcept;
-
-    // checked value access
-
-    constexpr U& value( boost::source_location const & loc =
-      BOOST_CURRENT_LOCATION ) const;
-
-    // unchecked value access
-
-    constexpr U* operator->() const noexcept;
-    constexpr U& operator*() const noexcept;
-
-    // error access
-
-    constexpr E error() const &;
-    constexpr E error() &&;
-
-    // emplace
-
-    template<class A>
-      constexpr U& emplace( A&& a ) noexcept;
-
-    // swap
-
-    constexpr void swap( result& r );
-    friend constexpr void swap( result & r1, result & r2 );
-
-    // equality
-
-    friend constexpr bool operator==( result const & r1, result const & r2 );
-    friend constexpr bool operator!=( result const & r1, result const & r2 );
-};
-
-} // namespace system
-} // namespace boost
-```
-
-#### Constructors
-
-```
-template<class A>
-  constexpr result( A&& a ) noexcept;
-```
-[none]
-* {blank}
-+
-Ensures: ::
-  `*this` holds the reference `static_cast<U&>( std::forward<A>(a) )`.
-Remarks: ::
-  This constructor is only enabled when `A` is `B&` and `std::is_convertible<B*, U*>::value` is `true`.
-
-```
-template<class... A>
-  constexpr result( A&&... a );
-```
-[none]
-* {blank}
-+
-Effects: ::
-  - If `std::is_constructible<E, A...>::value && !std::is_constructible<U&, A...>::value`,
-    ensures that `*this` holds the error `E( std::forward<A>(a)... )`.
-  - Otherwise, this constructor does not participate in overload resolution.
-Remarks: ::
-  This constructor is only enabled when `sizeof...(A) > 0`.
-
-```
-template<class A>
-  constexpr result( in_place_value_t, A&& a ) noexcept;
-```
-[none]
-* {blank}
-+
-Ensures: ::
-  `*this` holds the reference `static_cast<U&>( std::forward<A>(a) )`.
-Remarks: ::
-  This constructor is only enabled when `A` is `B&` and `std::is_convertible<B*, U*>::value` is `true`.
-
-```
-template<class... A>
-  constexpr result( in_place_error_t, A&&... a );
-```
-[none]
-* {blank}
-+
-Ensures: ::
-  `*this` holds the error `E( std::forward<A>(a)... )`.
-Remarks: ::
-  This constructor is only enabled when `std::is_constructible<E, A...>::value` is `true`.
-
-```
-template<class U2, class E2>
-  constexpr result( result<U2&, E2> const& r2 );
-```
-[none]
-* {blank}
-+
-Ensures: ::
-  If `r2.has_value()` is `true`, `*this` holds the reference `static_cast<U&>( *r2 )`, otherwise `*this` holds the error `E( r2.error() )`.
-Remarks: ::
-  This constructor is only enabled when `std::is_convertible<U2*, U*>::value && std::is_convertible<E2, E>::value` is `true`.
-
-#### Queries
-
-```
-constexpr bool has_value() const noexcept;
-```
-[none]
-* {blank}
-+
-Returns: ::
-  `true` when `*this` holds a value, `false` otherwise.
-
-```
-constexpr bool has_error() const noexcept;
-```
-[none]
-* {blank}
-+
-Returns: ::
-  `!has_value()`.
-
-```
-constexpr explicit operator bool() const noexcept;
-```
-[none]
-* {blank}
-+
-Returns: ::
-  `has_value()`.
-
-#### Checked Value Access
-
-```
-constexpr U& value(
-  boost::source_location const & loc = BOOST_CURRENT_LOCATION ) const;
-```
-[none]
-* {blank}
-+
-Effects: ::
-  If `*this` holds a reference, returns it. Otherwise,
-  calls `throw_exception_from_error`, passing it a reference to
-  the held error, and `loc`.
-
-#### Unchecked Value Access
-
-```
-constexpr U* operator->() const noexcept;
-```
-[none]
-* {blank}
-+
-Returns: ::
-  If `*this` holds a reference, a pointer to its referent. Otherwise, `nullptr`.
-
-```
-constexpr U& operator*() const noexcept;
-```
-[none]
-* {blank}
-+
-Requires: :: `*this` holds a reference.
-Returns: ::
-  `*operator\->()`.
-
-#### Error Access
-
-```
-constexpr E error() const &;
-constexpr E error() &&;
-```
-[none]
-* {blank}
-+
-Effects: ::
-  If `*this` holds an error, returns it. Otherwise, returns `E()`.
-
-#### emplace
-
-```
-template<class A>
-  constexpr U& emplace( A&& a ) noexcept;
-```
-[none]
-* {blank}
-+
-Ensures: ::
-  `*this` holds the reference `static_cast<U&>( std::forward<A>(a)... )`.
-Returns: ::
-  The contained reference.
-Remarks: ::
-  This function is only enabled when `A` is `B&` and `std::is_convertible<B*, U*>::value` is `true`.
-
-#### swap
-
-```
-constexpr void swap( result& r );
-```
-[none]
-* {blank}
-+
-Effects: ::
-  Exchanges the contents of `*this` and `r`.
-
-```
-friend constexpr void swap( result & r1, result & r2 );
-```
-[none]
-* {blank}
-+
-Effects: ::
-  Exchanges the contents of `r1` and `r2`.
-
-#### Equality
-
-```
-friend constexpr bool operator==( result const & r1, result const & r2 );
-```
-[none]
-* {blank}
-+
-Effects: ::
-  - If `r1` holds a reference `t1` and `r2` holds a reference `t2`, returns `t1 == t2`.
-  - If `r1` holds an error `e1` and `r2` holds an error `e2`, returns `e1 == e2`.
-  - Otherwise, returns `false`.
-
-```
-friend constexpr bool operator!=( result const & r1, result const & r2 );
-```
-[none]
-* {blank}
-+
-Returns: ::
-  `!( r1 == r2 )`.
-
-### Chaining
-
-#### operator|
-
-```
-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}
-+
-Returns the value in `r`, or if `r` contains an error, a default value `u`.
-+
-Effects: ::
-  - If `r.has_value()` is `true`, returns `*r`.
-  - Otherwise, returns `u`.
-Remarks: ::
-  Only enabled when `U` is convertible to `std::decay_t<T>`.
-Example: ::
-+
-```
-result<int> get_server_port(); // can fail
-
-int get_port()
-{
-    return get_server_port() | 443;
-}
-```
-
-```
-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}
-+
-Returns the value in `r`, or if `r` contains an error, a default value obtained
-by invoking the function `f`.
-+
-Effects: ::
-  - If `r.has_value()` is `true`, returns `*r`.
-  - Otherwise, returns `f()`.
-Remarks: ::
-  Only enabled when `f()` is convertible to `T`, or, when `T` is a reference, to `std::decay_t<T>`.
-Example: ::
-+
-```
-result<int> get_server_port(); // can fail
-int get_default_port();
-
-int get_port()
-{
-    return get_server_port() | get_default_port;
-}
-```
-+
-Note that the right hand side is `get_default_port` and not `get_default_port()`.
-This is important; spelled this way, the function `get_default_port` is called
-only when `get_server_port_impl()` fails. If it were
-+
-```
-    return get_server_port() | get_default_port();
-```
-+
-the function would have been called unconditionally.
-+
-Another, equivalent, way is to use a lambda
-+
-```
-    return get_server_port() | []{ return get_default_port(); };
-```
-+
-which isn't necessary here, but would be needed for more complex expressions.
-
-```
-template<class T, class E, class F, class R = ...> R operator|( result<T, E> const& r, F&& f );
-template<class T, class E, class F, class R = ...> R operator|( result<T, E>&& r, F&& f );
-template<class E, class F, class R = ...> R operator|( result<void, E> const& r, F&& f );
-template<class E, class F, class R = ...> R operator|( result<void, E>&& r, F&& f );
-```
-[none]
-* {blank}
-+
-Returns the value in `r`, or if `r` contains an error, another `result` obtained
-by invoking the function `f`.
-+
-Let `R` be the type of `f()`.
-+
-Effects: ::
-  - If `r.has_value()` is `true`, returns `*r`.
-  - Otherwise, returns `f()`.
-Remarks: ::
-  Only enabled when `R` is an instance of `result` and `T` is convertible to `R::value_type`.
-Example: ::
-+
-```
-result<int> get_server_port(); // can fail
-result<int> get_default_port(); // can fail
-
-int get_port()
-{
-    return get_server_port() | get_default_port | 443;
-}
-```
-
-#### operator|=
-
-```
-template<class T, class E, class U> result<T, E>& operator|=( result<T, E>& r, U&& u );
-```
-[none]
-* {blank}
-+
-If `r` contains an error, assigns a value to it, constructed from `u`.
-+
-Effects: ::
-  If `r.has_value()` is `false`, assigns `u` to `r`.
-Returns: ::
-  `r`.
-Remarks: ::
-  Only enabled when `U` is convertible to `T`.
-
-```
-template<class T, class E, class F> result<T, E>& operator|=( result<T, E>& r, F&& f );
-```
-[none]
-* {blank}
-+
-If `r` contains an error, assigns `f()` to it.
-+
-Effects: ::
-  If `r.has_value()` is `false`, assigns `f()` to `r`.
-Returns: ::
-  `r`.
-Remarks: ::
-  Only enabled when the type of `f()` is either
-  - convertible to `T` or
-  - an instance of `result` convertible to `result<T, E>`.
-Example: ::
-+
-```
-result<response> query_impl( std::string_view server, request const& req );
-
-result<response> query( std::vector<std::string_view> const& servers, request const& req )
-{
-    result<response> r = make_error_code( errc::invalid_argument );
-
-    for( auto const& server: servers )
-    {
-        r |= std::bind( query_impl, server, std::ref( req ) );
-    }
-
-    return r;
-}
-```
-
-
-#### operator&
-
-```
-template<class T, class E, class F, class U = ...>
-  result<U, E> operator&( result<T, E> const& r, F&& f );
-
-template<class T, class E, class F, class U = ...>
-  result<U, E> operator&( result<T, E>&& r, F&& f );
-```
-[none]
-* {blank}
-+
-Returns the error in `r`, or if `r` contains a value, transforms the value by calling `f` on it.
-+
-Let `U` be the type of `f(*r)`.
-+
-Effects: ::
-  - If `r.has_value()` is `true`, returns `f(*r)`.
-  - Otherwise, returns `r.error()`.
-Remarks: ::
-  Only enabled when `U` is not an instance of `result`.
-Example: ::
-+
-```
-struct currency_type
-{
-    char code_[ 4 ] = {};
-};
-
-result<double> get_exchange_rate( currency_type from, currency_type to );
-
-result<double> convert( double amount, currency_type from, currency_type to )
-{
-    return get_exchange_rate( from, to ) & [&](double rate){ return rate * amount; };
-}
-```
-
-```
-template<class E, class F, class U = ...>
-  result<U, E> operator&( result<void, E> const& r, F&& f );
-```
-[none]
-* {blank}
-+
-Returns the error in `r`, or if `r` contains a value, replaces it with the result of calling `f`.
-+
-Let `U` be the type of `f()`.
-+
-Effects: ::
-  - If `r.has_value()` is `true`, returns `f()`.
-  - Otherwise, returns `r.error()`.
-Remarks: ::
-  Only enabled when `U` is not an instance of `result`.
-
-
-```
-template<class T, class E, class F, class R = ...> R operator&( result<T, E> const& r, F&& f );
-template<class T, class E, class F, class R = ...> R operator&( result<T, E>&& r, F&& f );
-```
-[none]
-* {blank}
-+
-Returns the error in `r`, or if `r` contains a value, another `result` obtained
-by invoking the function `f` on the value in `r`.
-+
-Let `R` be the type of `f(*r)`.
-+
-Effects: ::
-  - If `r.has_value()` is `true`, returns `f(*r)`.
-  - Otherwise, returns `r.error()`.
-Remarks: ::
-  Only enabled when `R` is an instance of `result` and `E` is convertible to `R::error_type`.
-Example: ::
-+
-```
-struct JsonValue
-{
-    result<JsonValue const&> at( std::size_t i ) const noexcept;
-    result<JsonValue const&> at( std::string_view key ) const noexcept;
-    template<class T> result<T> to_number() const noexcept;
-};
-
-namespace helpers
-{
-
-inline auto at( std::size_t i ) {
-    return [=](JsonValue const& jv){ return jv.at( i ); }; }
-
-inline auto at( std::string_view key ) {
-    return [=](JsonValue const& jv){ return jv.at( key ); }; }
-
-template<class T> inline auto to_number() {
-    return [](JsonValue const& jv){ return jv.to_number<T>(); }; }
-
-} // namespace helpers
-
-int get_port( JsonValue const& config, int def )
-{
-    using namespace helpers;
-    return config.at( "servers" ) & at( 0 ) & at( "port" ) & to_number<int>() | def;
-}
-```
-
-```
-template<class E, class F, class R = ...> R operator&( result<void, E> const& r, F&& f );
-```
-[none]
-* {blank}
-+
-Returns the error in `r`, or if `r` contains a value, another `result` obtained
-by invoking the function `f`.
-+
-Let `R` be the type of `f()`.
-+
-Effects: ::
-  - If `r.has_value()` is `true`, returns `f()`.
-  - Otherwise, returns `r.error()`.
-Remarks: ::
-  Only enabled when `R` is an instance of `result` and `E` is convertible to `R::error_type`.
-
-
-#### operator&=
-
-```
-template<class T, class E, class F, class U = ...>
-  result<T, E>& operator&=( result<T, E>& r, F&& f );
-```
-[none]
-* {blank}
-+
-If `r` contains a value, replaces it with the result of invoking the function `f` on the value in `r`.
-+
-Let `U` be the type of `f(*r)`.
-+
-Effects: :: If `r.has_value()` is `true`, assigns `f(*std::move(r))` to `r`.
-Returns: :: `r`.
-Remarks: ::
-  Only enabled when `U` is not an instance of `result` and is convertible to `T`.
-
-```
-template<class T, class E, class F, class R = ...>
-  result<T, E>& operator&=( result<T, E>& r, F&& f );
-```
-[none]
-* {blank}
-+
-If `r` contains a value, replaces `r` with the result of invoking the function `f` on the value in `r`.
-+
-Let `R` be the type of `f(*r)`.
-+
-Effects: :: If `r.has_value()` is `true`, assigns `f(*std::move(r))` to `r`.
-Returns: :: `r`.
-Remarks: ::
-  Only enabled when `R` is an instance of `result` and is convertible to `result<T, E>`.
-Example: ::
-+
-```
-struct JsonValue
-{
-    result<JsonValue const&> at( std::string_view key ) const noexcept;
-};
-
-namespace helpers
-{
-
-inline auto at( std::string_view key ) {
-    return [=](JsonValue const& jv){ return jv.at( key ); }; }
-
-} // namespace helpers
-
-result<JsonValue const&> at_path( JsonValue const& jv,
-    std::initializer_list<std::string_view> path )
-{
-    result<JsonValue const&> r( jv );
-
-    using namespace helpers;
-
-    for( auto key: path )
-    {
-        r &= at( key );
-    }
-
-    return r;
-}
-```
-
-```
-template<class E, class F, class R = ...>
-  result<void, E>& operator&=( result<void, E>& r, F&& f );
-```
-[none]
-* {blank}
-+
-If `r` contains a value, replaces `r` with the result of invoking the function `f`.
-+
-Let `R` be the type of `f()`.
-+
-Effects: :: If `r.has_value()` is `true`, assigns `f()` to `r`.
-Returns: :: `r`.
-Remarks: ::
-  Only enabled when `R` is an instance of `result<void, E2>` and `E2` is convertible to `E`.
-
 ## <boost/system.hpp>

 This convenience header includes all the headers previously described.
@@ -1,53 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">
-
-    <Type Name="boost::system::error_category">
-        <DisplayString Condition="id_ == 0xb2ab117a257edfd0">[generic]</DisplayString>
-        <DisplayString Condition="id_ == 0xb2ab117a257edfd1">[system]</DisplayString>
-        <DisplayString Condition="id_ == 0xb2ab117a257edfd2">[interop]</DisplayString>
-        <DisplayString Condition="id_ != 0">[{id_,x}]</DisplayString>
-        <DisplayString>@{((uintptr_t)this),x}</DisplayString>
-    </Type>
-
-    <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._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;
-            (lc_flags_ == 2 || (lc_flags_ &gt; 3 &amp;&amp; ( lc_flags_ % 2 == 0 )))">{d1_.val_} [generic] ✓</DisplayString>
-        <DisplayString Condition="d1_.cat_->id_ == 0xb2ab117a257edfd1 &amp;&amp;
-            (lc_flags_ == 2 || (lc_flags_ &gt; 3 &amp;&amp; ( lc_flags_ % 2 == 0 )))">{d1_.val_} [system] ✓</DisplayString>
-        <DisplayString Condition="d1_.cat_->id_ == 0xb2ab117a257edfd2 &amp;&amp;
-            (lc_flags_ == 2 || (lc_flags_ &gt; 3 &amp;&amp; ( lc_flags_ % 2 == 0 )))">{d1_.val_} [interop] ✓</DisplayString>
-        <DisplayString Condition="d1_.cat_->id_ != 0 &amp;&amp;
-            (lc_flags_ == 2 || (lc_flags_ &gt; 3 &amp;&amp; ( lc_flags_ % 2 == 0 )))">{d1_.val_} [{d1_.cat_->id_,x}] ✓</DisplayString>
-        <DisplayString Condition=
-            "lc_flags_ == 2 || (lc_flags_ &gt; 3 &amp;&amp; ( lc_flags_ % 2 == 0 ))">{d1_.val_} @{((uintptr_t)d1_.cat_),x} ✓</DisplayString>
-
-        <DisplayString Condition="d1_.cat_->id_ == 0xb2ab117a257edfd0 &amp;&amp;
-            (lc_flags_ &gt;= 3 &amp;&amp; ( lc_flags_ % 2 == 1 ))">{d1_.val_} [generic]</DisplayString>
-        <DisplayString Condition="d1_.cat_->id_ == 0xb2ab117a257edfd1 &amp;&amp;
-            (lc_flags_ &gt;= 3 &amp;&amp; ( lc_flags_ % 2 == 1 ))">{d1_.val_} [system]</DisplayString>
-        <DisplayString Condition="d1_.cat_->id_ == 0xb2ab117a257edfd2 &amp;&amp;
-            (lc_flags_ &gt;= 3 &amp;&amp; ( lc_flags_ % 2 == 1 ))">{d1_.val_} [interop]</DisplayString>
-        <DisplayString Condition="d1_.cat_->id_ != 0 &amp;&amp;
-            (lc_flags_ &gt;= 3 &amp;&amp; ( lc_flags_ % 2 == 1 ))">{d1_.val_} [{d1_.cat_->id_,x}]</DisplayString>
-        <DisplayString Condition=
-            "lc_flags_ &gt;= 3 &amp;&amp; ( lc_flags_ % 2 == 1 )">{d1_.val_} @{((uintptr_t)d1_.cat_),x}</DisplayString>
-
-        <Expand>
-            <Item Name="std::error_code" Condition="lc_flags_ == 1">(std::error_code*)d2_</Item>
-            <Item Name="[location]" Condition="lc_flags_ &gt; 3">*((boost::source_location*)(lc_flags_ &amp; ~1))</Item>
-        </Expand>
-    </Type>
-
-    <Type Name="boost::system::result&lt;*,*&gt;">
-        <DisplayString>{v_}</DisplayString>
-    </Type>
-
-</AutoVisualizer>
@@ -9,6 +9,10 @@

 #include <boost/system/error_code.hpp>
 #include <boost/system/system_error.hpp>
-#include <boost/system/result.hpp>
+#include <boost/config.hpp>
+
+#if (__cplusplus >= 201103L) && !(defined(BOOST_GCC) && BOOST_GCC < 40800) || (defined(_MSC_VER) && _MSC_VER >= 1900)
+# include <boost/system/result.hpp>
+#endif

 #endif // #ifndef BOOST_SYSTEM_HPP_INCLUDED
@@ -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) // Windows default, including MinGW
+# if defined(_WIN32) || defined(__CYGWIN__) // Windows default, including MinGW and Cygwin
 #   define BOOST_WINDOWS_API
 # else
 #   define BOOST_POSIX_API 
@@ -0,0 +1,63 @@
+//  boost/system/cygwin_error.hpp  -------------------------------------------//
+
+//  Copyright Beman Dawes 2007
+
+//  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
+
+#ifndef BOOST_SYSTEM_CYGWIN_ERROR_HPP
+#define BOOST_SYSTEM_CYGWIN_ERROR_HPP
+
+#include <boost/config/pragma_message.hpp>
+
+#if !defined(BOOST_ALLOW_DEPRECATED_HEADERS)
+  BOOST_PRAGMA_MESSAGE("This header is deprecated and is slated for removal."
+  " If you want it retained, please open an issue in github.com/boostorg/system.")
+#endif
+
+//  This header is effectively empty for compiles on operating systems where
+//  it is not applicable.
+
+# ifdef __CYGWIN__
+
+#include <boost/system/error_code.hpp>
+
+namespace boost
+{
+  namespace system
+  {
+    //  To construct an error_code after a API error:
+    //
+    //      error_code( errno, system_category() )
+
+    //  User code should use the portable "posix" enums for POSIX errors; this
+    //  allows such code to be portable to non-POSIX systems. For the non-POSIX
+    //  errno values that POSIX-based systems typically provide in addition to 
+    //  POSIX values, use the system specific enums below.
+
+   namespace cygwin_error
+    {
+      enum cygwin_errno
+      {
+        no_net = ENONET,
+        no_package = ENOPKG,
+        no_share = ENOSHARE
+      };
+    }  // namespace cygwin_error
+
+    template<> struct is_error_code_enum<cygwin_error::cygwin_errno>
+      { static const bool value = true; };
+
+    namespace cygwin_error
+    {
+      inline error_code make_error_code( cygwin_errno e )
+        { return error_code( e, system_category() ); }
+    }
+  }
+}
+
+#endif  // __CYGWIN__
+
+#endif  // BOOST_SYSTEM_CYGWIN_ERROR_HPP
@@ -11,16 +11,16 @@
 #include <boost/config.hpp>
 #include <boost/config/workaround.hpp>

-// The macro BOOST_SYSTEM_DISABLE_THREADS can be defined on configurations
-// that provide <system_error> and <atomic>, but not <mutex>, such as the
-// single-threaded libstdc++.
-//
-// https://github.com/boostorg/system/issues/92
+// BOOST_SYSTEM_HAS_SYSTEM_ERROR
+
+#if !defined(BOOST_NO_CXX11_HDR_SYSTEM_ERROR) && !defined(BOOST_NO_CXX11_HDR_ATOMIC) && !defined(BOOST_NO_CXX11_HDR_MUTEX)
+# define BOOST_SYSTEM_HAS_SYSTEM_ERROR
+#endif

 // BOOST_SYSTEM_NOEXCEPT
 // Retained for backward compatibility

-#define BOOST_SYSTEM_NOEXCEPT noexcept
+#define BOOST_SYSTEM_NOEXCEPT BOOST_NOEXCEPT

 // BOOST_SYSTEM_HAS_CONSTEXPR

@@ -38,22 +38,6 @@
 # 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__)
@@ -74,9 +58,7 @@

 // BOOST_SYSTEM_CLANG_6

-// Android NDK r18b has Clang 7.0.2 that still needs the workaround
-// https://github.com/boostorg/system/issues/100
-#if defined(__clang__) && (__clang_major__ < 7 || (defined(__APPLE__) && __clang_major__ < 11) || (defined(__ANDROID__) && __clang_major__ == 7))
+#if defined(__clang__) && (__clang_major__ < 7 || (defined(__APPLE__) && __clang_major__ < 11))
 # define BOOST_SYSTEM_CLANG_6
 #endif

@@ -5,19 +5,28 @@
 // Distributed under the Boost Software License, Version 1.0
 // http://www.boost.org/LICENSE_1_0.txt

-#include <type_traits>
-
 namespace boost
 {
+
 namespace system
 {
+
 namespace detail
 {

-using std::enable_if;
+template<bool C, class T = void> struct enable_if
+{
+    typedef T type;
+};
+
+template<class T> struct enable_if<false, T>
+{
+};

 } // namespace detail
+
 } // namespace system
+
 } // namespace boost

 #endif // #ifndef BOOST_SYSTEM_DETAIL_ENABLE_IF_HPP_INCLUDED
@@ -13,12 +13,14 @@
 #include <boost/system/detail/config.hpp>
 #include <boost/cstdint.hpp>
 #include <boost/config.hpp>
-#include <boost/config/workaround.hpp>
 #include <string>
 #include <functional>
 #include <cstddef>
-#include <system_error>
-#include <atomic>
+
+#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
+# include <system_error>
+# include <atomic>
+#endif

 namespace boost
 {
@@ -46,7 +48,7 @@ class std_category;
 #pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
 #endif

-#if defined(BOOST_MSVC) && BOOST_MSVC < 1900
+#if defined(BOOST_MSVC)
 #pragma warning(push)
 #pragma warning(disable: 4351) //  new behavior: elements of array will be default initialized
 #endif
@@ -61,11 +63,20 @@ private:
    friend class error_code;
    friend class error_condition;

+#if !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS)
 public:

    error_category( error_category const & ) = delete;
    error_category& operator=( error_category const & ) = delete;

+#else
+private:
+
+    error_category( error_category const & );
+    error_category& operator=( error_category const & );
+
+#endif
+
 private:

    boost::ulong_long_type id_;
@@ -78,47 +89,68 @@ private:
        void const* stdcat_align_;
    };

+#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
+
    mutable std::atomic< unsigned > sc_init_;

+#else
+
+    unsigned sc_init_;
+
+#endif
+
 protected:

+#if !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) && !defined(BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS)
+
    ~error_category() = default;

-    constexpr error_category() noexcept: id_( 0 ), stdcat_(), sc_init_()
+#else
+
+    // We'd like to make the destructor protected, to make code that deletes
+    // an error_category* not compile; unfortunately, doing the below makes
+    // the destructor user-provided and hence breaks use after main, as the
+    // categories may get destroyed before code that uses them
+
+    // ~error_category() {}
+
+#endif
+
+    BOOST_SYSTEM_CONSTEXPR error_category() BOOST_NOEXCEPT: id_( 0 ), stdcat_(), sc_init_()
    {
    }

-    explicit constexpr error_category( boost::ulong_long_type id ) noexcept: id_( id ), stdcat_(), sc_init_()
+    explicit BOOST_SYSTEM_CONSTEXPR error_category( boost::ulong_long_type id ) BOOST_NOEXCEPT: id_( id ), stdcat_(), sc_init_()
    {
    }

 public:

-    virtual const char* name() const noexcept = 0;
+    virtual const char * name() const BOOST_NOEXCEPT = 0;

-    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 error_condition default_error_condition( int ev ) const BOOST_NOEXCEPT;
+    virtual bool equivalent( int code, const error_condition & condition ) const BOOST_NOEXCEPT;
+    virtual bool equivalent( const error_code & code, int condition ) const BOOST_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 BOOST_NOEXCEPT;

-    BOOST_SYSTEM_CXX20_CONSTEXPR virtual bool failed( int ev ) const noexcept
+    virtual bool failed( int ev ) const BOOST_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 ) BOOST_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 ) BOOST_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 ) BOOST_NOEXCEPT
    {
        if( lhs.id_ < rhs.id_ )
        {
@@ -135,19 +167,23 @@ public:
            return false; // equal
        }

-        return std::less<error_category const*>()( &lhs, &rhs );
+        return std::less<error_category const *>()( &lhs, &rhs );
    }

+#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
+
    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
+
+#endif
 };

-#if defined(BOOST_MSVC) && BOOST_MSVC < 1900
+#if defined(BOOST_MSVC)
 #pragma warning(pop)
 #endif

@@ -162,7 +198,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 )
    {
@@ -26,22 +26,22 @@ namespace system

 // error_category default implementation

-BOOST_SYSTEM_CXX20_CONSTEXPR inline error_condition error_category::default_error_condition( int ev ) const noexcept
+inline error_condition error_category::default_error_condition( int ev ) const BOOST_NOEXCEPT
 {
    return error_condition( ev, *this );
 }

-BOOST_SYSTEM_CXX20_CONSTEXPR inline bool error_category::equivalent( int code, error_condition const& condition ) const noexcept
+inline bool error_category::equivalent( int code, const error_condition & condition ) const BOOST_NOEXCEPT
 {
    return default_error_condition( code ) == condition;
 }

-BOOST_SYSTEM_CXX20_CONSTEXPR inline bool error_category::equivalent( error_code const& code, int condition ) const noexcept
+inline bool error_category::equivalent( const error_code & code, int condition ) const BOOST_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 BOOST_NOEXCEPT
 {
    if( len == 0 )
    {
@@ -58,7 +58,27 @@ inline char const* error_category::message( int ev, char* buffer, std::size_t le
    try
 #endif
    {
-        detail::snprintf( buffer, len, "%s", this->message( ev ).c_str() );
+        std::string m = this->message( ev );
+
+# if defined( BOOST_MSVC )
+#  pragma warning( push )
+#  pragma warning( disable: 4996 )
+# elif defined(__clang__) && defined(__has_warning)
+#  pragma clang diagnostic push
+#  if __has_warning("-Wdeprecated-declarations")
+#   pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#  endif
+# endif
+
+        std::strncpy( buffer, m.c_str(), len - 1 );
+        buffer[ len-1 ] = 0;
+
+# if defined( BOOST_MSVC )
+#  pragma warning( pop )
+# elif defined(__clang__) && defined(__has_warning)
+#  pragma clang diagnostic pop
+# endif
+
        return buffer;
    }
 #if !defined(BOOST_NO_EXCEPTIONS)
@@ -75,8 +95,10 @@ inline char const* error_category::message( int ev, char* buffer, std::size_t le

 // interoperability with std::error_code, std::error_condition

+#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
+
 #include <boost/system/detail/std_category_impl.hpp>
-#include <boost/system/detail/mutex.hpp>
+#include <mutex>
 #include <new>

 namespace boost
@@ -84,6 +106,18 @@ namespace boost
 namespace system
 {

+namespace detail
+{
+
+template<class = void> struct stdcat_mx_holder
+{
+    static std::mutex mx_;
+};
+
+template<class T> std::mutex stdcat_mx_holder<T>::mx_;
+
+} // namespace detail
+
 inline void error_category::init_stdcat() const
 {
    static_assert( sizeof( stdcat_ ) >= sizeof( boost::system::detail::std_category ), "sizeof(stdcat_) is not enough for std_category" );
@@ -96,17 +130,11 @@ inline void error_category::init_stdcat() const

 #endif

-    // detail::mutex has a constexpr default constructor,
-    // and therefore guarantees static initialization, on
-    // everything except VS 2013 (msvc-12.0)
-
-    static system::detail::mutex mx_;
-
-    system::detail::lock_guard<system::detail::mutex> lk( mx_ );
+    std::lock_guard<std::mutex> lk( boost::system::detail::stdcat_mx_holder<>::mx_ );

    if( sc_init_.load( std::memory_order_acquire ) == 0 )
    {
-        ::new( static_cast<void*>( stdcat_ ) ) boost::system::detail::std_category( this, system::detail::id_wrapper<0>() );
+        ::new( static_cast<void*>( stdcat_ ) ) boost::system::detail::std_category( this, 0 );
        sc_init_.store( 1, std::memory_order_release );
    }
 }
@@ -116,14 +144,14 @@ 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 )
    {
 // This condition must be the same as the one in error_condition.hpp
 #if defined(BOOST_SYSTEM_AVOID_STD_GENERIC_CATEGORY)

-        static const boost::system::detail::std_category generic_instance( this, system::detail::id_wrapper<0x1F4D3>() );
+        static const boost::system::detail::std_category generic_instance( this, 0x1F4D3 );
        return generic_instance;

 #else
@@ -138,7 +166,7 @@ inline BOOST_NOINLINE error_category::operator std::error_category const& () con
 // This condition must be the same as the one in error_code.hpp
 #if defined(BOOST_SYSTEM_AVOID_STD_SYSTEM_CATEGORY)

-        static const boost::system::detail::std_category system_instance( this, system::detail::id_wrapper<0x1F4D7>() );
+        static const boost::system::detail::std_category system_instance( this, 0x1F4D7 );
        return system_instance;

 #else
@@ -163,4 +191,6 @@ inline BOOST_NOINLINE error_category::operator std::error_category const& () con
 } // namespace system
 } // namespace boost

+#endif // #if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
+
 #endif // #ifndef BOOST_SYSTEM_DETAIL_ERROR_CATEGORY_IMPL_HPP_INCLUDED
@@ -21,15 +21,21 @@
 #include <boost/system/detail/append_int.hpp>
 #include <boost/system/detail/snprintf.hpp>
 #include <boost/system/detail/config.hpp>
-#include <boost/system/detail/std_category.hpp>
+
+#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
+# include <boost/system/detail/std_category.hpp>
+#endif
+
 #include <boost/assert/source_location.hpp>
 #include <boost/cstdint.hpp>
 #include <boost/config.hpp>
-#include <boost/config/workaround.hpp>
 #include <ostream>
 #include <new>
 #include <cstdio>
-#include <system_error>
+
+#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
+# include <system_error>
+#endif

 #if defined(BOOST_GCC) && BOOST_GCC >= 40600 && BOOST_GCC < 70000
 # pragma GCC diagnostic push
@@ -51,14 +57,12 @@ namespace system
 //  and error_code containing a pointer to an object of a type derived
 //  from error_category.

-bool operator==( const error_code & code, const error_condition & condition ) noexcept;
 std::size_t hash_value( error_code const & ec );

 class error_code
 {
 private:

-    friend bool operator==( const error_code & code, const error_condition & condition ) noexcept;
    friend std::size_t hash_value( error_code const & ec );

 private:
@@ -72,7 +76,9 @@ private:
    union
    {
        data d1_;
+#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
        unsigned char d2_[ sizeof(std::error_code) ];
+#endif
    };

    // 0: default constructed, d1_ value initialized
@@ -84,7 +90,7 @@ private:

 private:

-    char const* category_name() const noexcept
+    char const* category_name() const BOOST_NOEXCEPT
    {
        // return category().name();

@@ -108,19 +114,19 @@ public:

    // constructors:

-    constexpr error_code() noexcept:
+    BOOST_SYSTEM_CONSTEXPR error_code() BOOST_NOEXCEPT:
        d1_(), lc_flags_( 0 )
    {
    }

-    BOOST_SYSTEM_CONSTEXPR error_code( int val, const error_category & cat ) noexcept:
+    BOOST_SYSTEM_CONSTEXPR error_code( int val, const error_category & cat ) BOOST_NOEXCEPT:
        d1_(), lc_flags_( 2 + detail::failed_impl( val, cat ) )
    {
        d1_.val_ = val;
        d1_.cat_ = &cat;
    }

-    error_code( int val, const error_category & cat, source_location const * loc ) noexcept:
+    error_code( int val, const error_category & cat, source_location const * loc ) BOOST_NOEXCEPT:
        d1_(), lc_flags_( ( loc? reinterpret_cast<boost::uintptr_t>( loc ): 2 ) | +detail::failed_impl( val, cat ) )
    {
        d1_.val_ = val;
@@ -130,13 +136,15 @@ public:
    template<class ErrorCodeEnum> BOOST_SYSTEM_CONSTEXPR error_code( ErrorCodeEnum e,
        typename detail::enable_if<
            is_error_code_enum<ErrorCodeEnum>::value
+#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
            || std::is_error_code_enum<ErrorCodeEnum>::value
-        >::type* = 0 ) noexcept: d1_(), lc_flags_( 0 )
+#endif
+        >::type* = 0 ) BOOST_NOEXCEPT: d1_(), lc_flags_( 0 )
    {
        *this = make_error_code( e );
    }

-    error_code( error_code const& ec, source_location const * loc ) noexcept:
+    error_code( error_code const& ec, source_location const * loc ) BOOST_NOEXCEPT:
        d1_(), lc_flags_( 0 )
    {
        *this = ec;
@@ -147,7 +155,9 @@ public:
        }
    }

-    error_code( std::error_code const& ec ) noexcept:
+#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
+
+    error_code( std::error_code const& ec ) BOOST_NOEXCEPT:
        d1_(), lc_flags_( 0 )
    {
 #ifndef BOOST_NO_RTTI
@@ -165,39 +175,41 @@ public:
        }
    }

+#endif
+
    // modifiers:

-    BOOST_SYSTEM_CONSTEXPR void assign( int val, const error_category & cat ) noexcept
+    BOOST_SYSTEM_CONSTEXPR void assign( int val, const error_category & cat ) BOOST_NOEXCEPT
    {
        *this = error_code( val, cat );
    }

-    void assign( int val, const error_category & cat, source_location const * loc ) noexcept
+    void assign( int val, const error_category & cat, source_location const * loc ) BOOST_NOEXCEPT
    {
        *this = error_code( val, cat, loc );
    }

-    void assign( error_code const& ec, source_location const * loc ) noexcept
+    void assign( error_code const& ec, source_location const * loc ) BOOST_NOEXCEPT
    {
        *this = error_code( ec, loc );
    }

    template<typename ErrorCodeEnum>
        BOOST_SYSTEM_CONSTEXPR typename detail::enable_if<is_error_code_enum<ErrorCodeEnum>::value, error_code>::type &
-        operator=( ErrorCodeEnum val ) noexcept
+        operator=( ErrorCodeEnum val ) BOOST_NOEXCEPT
    {
        *this = make_error_code( val );
        return *this;
    }

-    BOOST_SYSTEM_CONSTEXPR void clear() noexcept
+    BOOST_SYSTEM_CONSTEXPR void clear() BOOST_NOEXCEPT
    {
        *this = error_code();
    }

    // observers:

-    BOOST_SYSTEM_CONSTEXPR int value() const noexcept
+    BOOST_SYSTEM_CONSTEXPR int value() const BOOST_NOEXCEPT
    {
        if( lc_flags_ != 1 )
        {
@@ -205,16 +217,22 @@ public:
        }
        else
        {
+#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
+
            std::error_code const& ec = *reinterpret_cast<std::error_code const*>( d2_ );

            unsigned cv = static_cast<unsigned>( ec.value() );
            unsigned ch = static_cast<unsigned>( reinterpret_cast<boost::uintptr_t>( &ec.category() ) % 2097143 ); // 2^21-9, prime

            return static_cast<int>( cv + 1000 * ch );
+#else
+
+            return -1;
+#endif
        }
    }

-    BOOST_SYSTEM_CONSTEXPR const error_category & category() const noexcept
+    BOOST_SYSTEM_CONSTEXPR const error_category & category() const BOOST_NOEXCEPT
    {
        if( lc_flags_ == 0 )
        {
@@ -231,19 +249,24 @@ public:
    }

    // deprecated?
-    error_condition default_error_condition() const noexcept
+    error_condition default_error_condition() const BOOST_NOEXCEPT
    {
        return category().default_error_condition( value() );
    }

    std::string message() const
    {
+#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
+
        if( lc_flags_ == 1 )
        {
            std::error_code const& ec = *reinterpret_cast<std::error_code const*>( d2_ );
            return ec.message();
        }
-        else if( lc_flags_ == 0 )
+
+#endif
+
+        if( lc_flags_ == 0 )
        {
            return detail::system_error_category_message( value() );
        }
@@ -253,8 +276,9 @@ public:
        }
    }

-    char const * message( char * buffer, std::size_t len ) const noexcept
+    char const * message( char * buffer, std::size_t len ) const BOOST_NOEXCEPT
    {
+#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
        if( lc_flags_ == 1 )
        {
            std::error_code const& ec = *reinterpret_cast<std::error_code const*>( d2_ );
@@ -274,7 +298,9 @@ public:
            }
 #endif
        }
-        else if( lc_flags_ == 0 )
+#endif
+
+        if( lc_flags_ == 0 )
        {
            return detail::system_error_category_message( value(), buffer, len );
        }
@@ -284,16 +310,17 @@ public:
        }
    }

-    BOOST_SYSTEM_CONSTEXPR bool failed() const noexcept
+    BOOST_SYSTEM_CONSTEXPR bool failed() const BOOST_NOEXCEPT
    {
        if( lc_flags_ & 1 )
        {
+#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
            if( lc_flags_ == 1 )
            {
                std::error_code const& ec = *reinterpret_cast<std::error_code const*>( d2_ );
                return ec.value() != 0;
            }
-
+#endif
            return true;
        }
        else
@@ -302,17 +329,36 @@ public:
        }
    }

-    BOOST_SYSTEM_CONSTEXPR explicit operator bool() const noexcept  // true if error
+#if !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
+
+    BOOST_SYSTEM_CONSTEXPR explicit operator bool() const BOOST_NOEXCEPT  // true if error
    {
        return failed();
    }

-    bool has_location() const noexcept
+#else
+
+    typedef void (*unspecified_bool_type)();
+    static void unspecified_bool_true() {}
+
+    BOOST_SYSTEM_CONSTEXPR operator unspecified_bool_type() const  BOOST_NOEXCEPT // true if error
+    {
+        return failed()? unspecified_bool_true: 0;
+    }
+
+    BOOST_SYSTEM_CONSTEXPR bool operator!() const BOOST_NOEXCEPT // true if no error
+    {
+        return !failed();
+    }
+
+#endif
+
+    bool has_location() const BOOST_NOEXCEPT
    {
        return lc_flags_ >= 4;
    }

-    source_location const & location() const noexcept
+    source_location const & location() const BOOST_NOEXCEPT
    {
        BOOST_STATIC_CONSTEXPR source_location loc;
        return lc_flags_ >= 4? *reinterpret_cast<source_location const*>( lc_flags_ &~ static_cast<boost::uintptr_t>( 1 ) ): loc;
@@ -326,7 +372,7 @@ private:

    friend class error_category;

-    BOOST_SYSTEM_CONSTEXPR bool equals( int val, error_category const& cat ) const noexcept
+    BOOST_SYSTEM_CONSTEXPR bool equals( int val, error_category const& cat ) const BOOST_NOEXCEPT
    {
        if( lc_flags_ == 0 )
        {
@@ -347,14 +393,11 @@ public:
    //  the more symmetrical non-member syntax allows enum
    //  conversions work for both rhs and lhs.

-    BOOST_SYSTEM_CONSTEXPR inline friend bool operator==( const error_code & lhs, const error_code & rhs ) noexcept
+    BOOST_SYSTEM_CONSTEXPR inline friend bool operator==( const error_code & lhs, const error_code & rhs ) BOOST_NOEXCEPT
    {
-        bool s1 = lhs.lc_flags_ == 1;
-        bool s2 = rhs.lc_flags_ == 1;
+#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)

-        if( s1 != s2 ) return false;
-
-        if( s1 && s2 )
+        if( lhs.lc_flags_ == 1 && rhs.lc_flags_ == 1 )
        {
            std::error_code const& e1 = *reinterpret_cast<std::error_code const*>( lhs.d2_ );
            std::error_code const& e2 = *reinterpret_cast<std::error_code const*>( rhs.d2_ );
@@ -362,20 +405,17 @@ public:
            return e1 == e2;
        }
        else
+#endif
        {
            return lhs.value() == rhs.value() && lhs.category() == rhs.category();
        }
    }

-    BOOST_SYSTEM_CONSTEXPR inline friend bool operator<( const error_code & lhs, const error_code & rhs ) noexcept
+    BOOST_SYSTEM_CONSTEXPR inline friend bool operator<( const error_code & lhs, const error_code & rhs ) BOOST_NOEXCEPT
    {
-        bool s1 = lhs.lc_flags_ == 1;
-        bool s2 = rhs.lc_flags_ == 1;
+#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)

-        if( s1 < s2 ) return true;
-        if( s2 < s1 ) return false;
-
-        if( s1 && s2 )
+        if( lhs.lc_flags_ == 1 && rhs.lc_flags_ == 1 )
        {
            std::error_code const& e1 = *reinterpret_cast<std::error_code const*>( lhs.d2_ );
            std::error_code const& e2 = *reinterpret_cast<std::error_code const*>( rhs.d2_ );
@@ -383,32 +423,77 @@ public:
            return e1 < e2;
        }
        else
+#endif
        {
            return lhs.category() < rhs.category() || (lhs.category() == rhs.category() && lhs.value() < rhs.value());
        }
    }

-    BOOST_SYSTEM_CONSTEXPR inline friend bool operator!=( const error_code & lhs, const error_code & rhs ) noexcept
+    BOOST_SYSTEM_CONSTEXPR inline friend bool operator!=( const error_code & lhs, const error_code & rhs ) BOOST_NOEXCEPT
    {
        return !( lhs == rhs );
    }

-    inline friend bool operator==( std::error_code const & lhs, error_code const & rhs ) noexcept
+    inline friend bool operator==( const error_code & code, const error_condition & condition ) BOOST_NOEXCEPT
+    {
+#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
+
+        if( code.lc_flags_ == 1 )
+        {
+            return static_cast<std::error_code>( code ) == static_cast<std::error_condition>( condition );
+        }
+        else
+
+#endif
+        {
+            return code.category().equivalent( code.value(), condition ) || condition.category().equivalent( code, condition.value() );
+        }
+    }
+
+    inline friend bool operator==( const error_condition & condition, const error_code & code ) BOOST_NOEXCEPT
+    {
+#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
+
+        if( code.lc_flags_ == 1 )
+        {
+            return static_cast<std::error_code>( code ) == static_cast<std::error_condition>( condition );
+        }
+        else
+
+#endif
+        {
+            return code.category().equivalent( code.value(), condition ) || condition.category().equivalent( code, condition.value() );
+        }
+    }
+
+    inline friend bool operator!=( const error_code & lhs, const error_condition & rhs ) BOOST_NOEXCEPT
+    {
+        return !( lhs == rhs );
+    }
+
+    inline friend bool operator!=( const error_condition & lhs, const error_code & rhs ) BOOST_NOEXCEPT
+    {
+        return !( lhs == rhs );
+    }
+
+#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
+
+    inline friend bool operator==( std::error_code const & lhs, error_code const & rhs ) BOOST_NOEXCEPT
    {
        return lhs == static_cast< std::error_code >( rhs );
    }

-    inline friend bool operator==( error_code const & lhs, std::error_code const & rhs ) noexcept
+    inline friend bool operator==( error_code const & lhs, std::error_code const & rhs ) BOOST_NOEXCEPT
    {
        return static_cast< std::error_code >( lhs ) == rhs;
    }

-    inline friend bool operator!=( std::error_code const & lhs, error_code const & rhs ) noexcept
+    inline friend bool operator!=( std::error_code const & lhs, error_code const & rhs ) BOOST_NOEXCEPT
    {
        return !( lhs == rhs );
    }

-    inline friend bool operator!=( error_code const & lhs, std::error_code const & rhs ) noexcept
+    inline friend bool operator!=( error_code const & lhs, std::error_code const & rhs ) BOOST_NOEXCEPT
    {
        return !( lhs == rhs );
    }
@@ -416,25 +501,25 @@ public:
    //

    template<class E, class N = typename detail::enable_if<std::is_error_condition_enum<E>::value>::type>
-    inline friend bool operator==( error_code const & lhs, E rhs ) noexcept
+    inline friend bool operator==( error_code const & lhs, E rhs ) BOOST_NOEXCEPT
    {
        return lhs == make_error_condition( rhs );
    }

    template<class E, class N = typename detail::enable_if<std::is_error_condition_enum<E>::value>::type>
-    inline friend bool operator==( E lhs, error_code const & rhs ) noexcept
+    inline friend bool operator==( E lhs, error_code const & rhs ) BOOST_NOEXCEPT
    {
        return make_error_condition( lhs ) == rhs;
    }

    template<class E, class N = typename detail::enable_if<std::is_error_condition_enum<E>::value>::type>
-    inline friend bool operator!=( error_code const & lhs, E rhs ) noexcept
+    inline friend bool operator!=( error_code const & lhs, E rhs ) BOOST_NOEXCEPT
    {
        return !( lhs == rhs );
    }

    template<class E, class N = typename detail::enable_if<std::is_error_condition_enum<E>::value>::type>
-    inline friend bool operator!=( E lhs, error_code const & rhs ) noexcept
+    inline friend bool operator!=( E lhs, error_code const & rhs ) BOOST_NOEXCEPT
    {
        return !( lhs == rhs );
    }
@@ -442,47 +527,47 @@ public:
    //

    template<class E, class N1 = void, class N2 = typename detail::enable_if<std::is_error_code_enum<E>::value>::type>
-    BOOST_SYSTEM_CONSTEXPR inline friend bool operator==( error_code const & lhs, E rhs ) noexcept
+    BOOST_SYSTEM_CONSTEXPR inline friend bool operator==( error_code const & lhs, E rhs ) BOOST_NOEXCEPT
    {
        return lhs == make_error_code( rhs );
    }

    template<class E, class N1 = void, class N2 = typename detail::enable_if<std::is_error_code_enum<E>::value>::type>
-    BOOST_SYSTEM_CONSTEXPR inline friend bool operator==( E lhs, error_code const & rhs ) noexcept
+    BOOST_SYSTEM_CONSTEXPR inline friend bool operator==( E lhs, error_code const & rhs ) BOOST_NOEXCEPT
    {
        return make_error_code( lhs ) == rhs;
    }

    template<class E, class N1 = void, class N2 = typename detail::enable_if<std::is_error_code_enum<E>::value>::type>
-    BOOST_SYSTEM_CONSTEXPR inline friend bool operator!=( error_code const & lhs, E rhs ) noexcept
+    BOOST_SYSTEM_CONSTEXPR inline friend bool operator!=( error_code const & lhs, E rhs ) BOOST_NOEXCEPT
    {
        return !( lhs == rhs );
    }

    template<class E, class N1 = void, class N2 = typename detail::enable_if<std::is_error_code_enum<E>::value>::type>
-    BOOST_SYSTEM_CONSTEXPR inline friend bool operator!=( E lhs, error_code const & rhs ) noexcept
+    BOOST_SYSTEM_CONSTEXPR inline friend bool operator!=( E lhs, error_code const & rhs ) BOOST_NOEXCEPT
    {
        return !( lhs == rhs );
    }

 #if defined(BOOST_SYSTEM_CLANG_6)

-    inline friend bool operator==( error_code const & lhs, std::error_condition const & rhs ) noexcept
+    inline friend bool operator==( error_code const & lhs, std::error_condition const & rhs ) BOOST_NOEXCEPT
    {
        return static_cast< std::error_code >( lhs ) == rhs;
    }

-    inline friend bool operator==( std::error_condition const & lhs, error_code const & rhs ) noexcept
+    inline friend bool operator==( std::error_condition const & lhs, error_code const & rhs ) BOOST_NOEXCEPT
    {
        return lhs == static_cast< std::error_code >( rhs );
    }

-    inline friend bool operator!=( error_code const & lhs, std::error_condition const & rhs ) noexcept
+    inline friend bool operator!=( error_code const & lhs, std::error_condition const & rhs ) BOOST_NOEXCEPT
    {
        return !( lhs == rhs );
    }

-    inline friend bool operator!=( std::error_condition const & lhs, error_code const & rhs ) noexcept
+    inline friend bool operator!=( std::error_condition const & lhs, error_code const & rhs ) BOOST_NOEXCEPT
    {
        return !( lhs == rhs );
    }
@@ -541,10 +626,14 @@ public:
      class E = typename std::enable_if<std::is_same<T, std::error_code>::value>::type>
      operator T const& () = delete;

+#endif
+
 #endif

    std::string to_string() const
    {
+#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
+
        if( lc_flags_ == 1 )
        {
            std::error_code const& e2 = *reinterpret_cast<std::error_code const*>( d2_ );
@@ -556,6 +645,7 @@ public:
            return r;
        }
        else
+#endif
        {
            std::string r = category_name();
            detail::append_int( r, value() );
@@ -588,41 +678,18 @@ public:
    }
 };

-inline bool operator==( const error_code & code, const error_condition & condition ) noexcept
-{
-    if( code.lc_flags_ == 1 )
-    {
-        return static_cast<std::error_code>( code ) == static_cast<std::error_condition>( condition );
-    }
-    else
-    {
-        return code.category().equivalent( code.value(), condition ) || condition.category().equivalent( code, condition.value() );
-    }
-}
-
-inline bool operator==( const error_condition & condition, const error_code & code ) noexcept
-{
-    return code == condition;
-}
-
-inline bool operator!=( const error_code & lhs, const error_condition & rhs ) noexcept
-{
-    return !( lhs == rhs );
-}
-
-inline bool operator!=( const error_condition & lhs, const error_code & rhs ) noexcept
-{
-    return !( lhs == rhs );
-}
-
 inline std::size_t hash_value( error_code const & ec )
 {
+#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
+
    if( ec.lc_flags_ == 1 )
    {
        std::error_code const& e2 = *reinterpret_cast<std::error_code const*>( ec.d2_ );
        return std::hash<std::error_code>()( e2 );
    }

+#endif
+
    error_category const & cat = ec.category();

    boost::ulong_long_type id_ = cat.id_;
@@ -50,7 +50,7 @@ private:

 private:

-    boost::ulong_long_type cat_id() const noexcept
+    boost::ulong_long_type cat_id() const BOOST_NOEXCEPT
    {
        return cat_? cat_->id_: detail::generic_category_id;
    }
@@ -59,17 +59,17 @@ public:

    // constructors:

-    BOOST_SYSTEM_CONSTEXPR error_condition() noexcept:
+    BOOST_SYSTEM_CONSTEXPR error_condition() BOOST_NOEXCEPT:
        val_( 0 ), cat_( 0 )
    {
    }

-    BOOST_SYSTEM_CONSTEXPR error_condition( int val, const error_category & cat ) noexcept:
+    BOOST_SYSTEM_CONSTEXPR error_condition( int val, const error_category & cat ) BOOST_NOEXCEPT:
        val_( val ), cat_( &cat )
    {
    }

-    BOOST_SYSTEM_CONSTEXPR explicit error_condition( boost::system::detail::generic_value_tag vt ) noexcept:
+    BOOST_SYSTEM_CONSTEXPR explicit error_condition( boost::system::detail::generic_value_tag vt ) BOOST_NOEXCEPT:
        val_( vt.value ), cat_( 0 )
    {
    }
@@ -77,20 +77,20 @@ public:
    template<class ErrorConditionEnum> BOOST_SYSTEM_CONSTEXPR error_condition( ErrorConditionEnum e,
      typename detail::enable_if<
        is_error_condition_enum<ErrorConditionEnum>::value && !boost::system::detail::is_same<ErrorConditionEnum, errc::errc_t>::value
-      >::type* = 0) noexcept
+      >::type* = 0) BOOST_NOEXCEPT
    {
        *this = make_error_condition( e );
    }

    template<class ErrorConditionEnum> BOOST_SYSTEM_CONSTEXPR error_condition( ErrorConditionEnum e,
-      typename detail::enable_if<boost::system::detail::is_same<ErrorConditionEnum, errc::errc_t>::value>::type* = 0) noexcept:
+      typename detail::enable_if<boost::system::detail::is_same<ErrorConditionEnum, errc::errc_t>::value>::type* = 0) BOOST_NOEXCEPT:
        val_( e ), cat_( 0 )
    {
    }

    // modifiers:

-    BOOST_SYSTEM_CONSTEXPR void assign( int val, const error_category & cat ) noexcept
+    BOOST_SYSTEM_CONSTEXPR void assign( int val, const error_category & cat ) BOOST_NOEXCEPT
    {
        val_ = val;
        cat_ = &cat;
@@ -98,13 +98,13 @@ public:

    template<typename ErrorConditionEnum>
        BOOST_SYSTEM_CONSTEXPR typename detail::enable_if<is_error_condition_enum<ErrorConditionEnum>::value, error_condition>::type &
-        operator=( ErrorConditionEnum val ) noexcept
+        operator=( ErrorConditionEnum val ) BOOST_NOEXCEPT
    {
        *this = error_condition( val );
        return *this;
    }

-    BOOST_SYSTEM_CONSTEXPR void clear() noexcept
+    BOOST_SYSTEM_CONSTEXPR void clear() BOOST_NOEXCEPT
    {
        val_ = 0;
        cat_ = 0;
@@ -112,12 +112,12 @@ public:

    // observers:

-    BOOST_SYSTEM_CONSTEXPR int value() const noexcept
+    BOOST_SYSTEM_CONSTEXPR int value() const BOOST_NOEXCEPT
    {
        return val_;
    }

-    BOOST_SYSTEM_CONSTEXPR const error_category & category() const noexcept
+    BOOST_SYSTEM_CONSTEXPR const error_category & category() const BOOST_NOEXCEPT
    {
        return cat_? *cat_: generic_category();
    }
@@ -134,7 +134,7 @@ public:
        }
    }

-    char const * message( char * buffer, std::size_t len ) const noexcept
+    char const * message( char * buffer, std::size_t len ) const BOOST_NOEXCEPT
    {
        if( cat_ )
        {
@@ -146,7 +146,7 @@ public:
        }
    }

-    BOOST_SYSTEM_CONSTEXPR bool failed() const noexcept
+    BOOST_SYSTEM_CONSTEXPR bool failed() const BOOST_NOEXCEPT
    {
        if( cat_ )
        {
@@ -158,16 +158,35 @@ public:
        }
    }

-    BOOST_SYSTEM_CONSTEXPR explicit operator bool() const noexcept  // true if error
+#if !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
+
+    BOOST_SYSTEM_CONSTEXPR explicit operator bool() const BOOST_NOEXCEPT  // true if error
    {
        return failed();
    }

+#else
+
+    typedef void (*unspecified_bool_type)();
+    static void unspecified_bool_true() {}
+
+    BOOST_SYSTEM_CONSTEXPR operator unspecified_bool_type() const BOOST_NOEXCEPT  // true if error
+    {
+        return failed()? unspecified_bool_true: 0;
+    }
+
+    BOOST_SYSTEM_CONSTEXPR bool operator!() const BOOST_NOEXCEPT  // true if no error
+    {
+        return !failed();
+    }
+
+#endif
+
    // relationals:
    //  the more symmetrical non-member syntax allows enum
    //  conversions work for both rhs and lhs.

-    BOOST_SYSTEM_CONSTEXPR inline friend bool operator==( const error_condition & lhs, const error_condition & rhs ) noexcept
+    BOOST_SYSTEM_CONSTEXPR inline friend bool operator==( const error_condition & lhs, const error_condition & rhs ) BOOST_NOEXCEPT
    {
        if( lhs.val_ != rhs.val_ )
        {
@@ -187,18 +206,20 @@ public:
        }
    }

-    BOOST_SYSTEM_CONSTEXPR inline friend bool operator<( const error_condition & lhs, const error_condition & rhs ) noexcept
+    BOOST_SYSTEM_CONSTEXPR inline friend bool operator<( const error_condition & lhs, const error_condition & rhs ) BOOST_NOEXCEPT
    {
        error_category const& lcat = lhs.category();
        error_category const& rcat = rhs.category();
        return lcat < rcat || ( lcat == rcat && lhs.val_ < rhs.val_ );
    }

-    BOOST_SYSTEM_CONSTEXPR inline friend bool operator!=( const error_condition & lhs, const error_condition & rhs ) noexcept
+    BOOST_SYSTEM_CONSTEXPR inline friend bool operator!=( const error_condition & lhs, const error_condition & rhs ) BOOST_NOEXCEPT
    {
        return !( lhs == rhs );
    }

+#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
+
    operator std::error_condition () const
    {
 // This condition must be the same as the one in error_category_impl.hpp
@@ -220,77 +241,27 @@ public:
 #endif
    }

-    inline friend bool operator==( std::error_code const & lhs, error_condition const & rhs ) noexcept
+    inline friend bool operator==( std::error_code const & lhs, error_condition const & rhs ) BOOST_NOEXCEPT
    {
        return lhs == static_cast< std::error_condition >( rhs );
    }

-    inline friend bool operator==( error_condition const & lhs, std::error_code const & rhs ) noexcept
+    inline friend bool operator==( error_condition const & lhs, std::error_code const & rhs ) BOOST_NOEXCEPT
    {
        return static_cast< std::error_condition >( lhs ) == rhs;
    }

-    inline friend bool operator!=( std::error_code const & lhs, error_condition const & rhs ) noexcept
+    inline friend bool operator!=( std::error_code const & lhs, error_condition const & rhs ) BOOST_NOEXCEPT
    {
        return !( lhs == rhs );
    }

-    inline friend bool operator!=( error_condition const & lhs, std::error_code const & rhs ) noexcept
+    inline friend bool operator!=( error_condition const & lhs, std::error_code const & rhs ) BOOST_NOEXCEPT
    {
        return !( lhs == rhs );
    }

-    //
-
-    template<class E, class N = typename detail::enable_if<std::is_error_condition_enum<E>::value>::type>
-    BOOST_SYSTEM_CONSTEXPR inline friend bool operator==( error_condition const & lhs, E rhs ) noexcept
-    {
-        return lhs == make_error_condition( rhs );
-    }
-
-    template<class E, class N = typename detail::enable_if<std::is_error_condition_enum<E>::value>::type>
-    BOOST_SYSTEM_CONSTEXPR inline friend bool operator==( E lhs, error_condition const & rhs ) noexcept
-    {
-        return make_error_condition( lhs ) == rhs;
-    }
-
-    template<class E, class N = typename detail::enable_if<std::is_error_condition_enum<E>::value>::type>
-    BOOST_SYSTEM_CONSTEXPR inline friend bool operator!=( error_condition const & lhs, E rhs ) noexcept
-    {
-        return !( lhs == rhs );
-    }
-
-    template<class E, class N = typename detail::enable_if<std::is_error_condition_enum<E>::value>::type>
-    BOOST_SYSTEM_CONSTEXPR inline friend bool operator!=( E lhs, error_condition const & rhs ) noexcept
-    {
-        return !( lhs == rhs );
-    }
-
-    //
-
-    template<class E, class N1 = void, class N2 = typename detail::enable_if<std::is_error_code_enum<E>::value>::type>
-    inline friend bool operator==( error_condition const & lhs, E rhs ) noexcept
-    {
-        return lhs == make_error_code( rhs );
-    }
-
-    template<class E, class N1 = void, class N2 = typename detail::enable_if<std::is_error_code_enum<E>::value>::type>
-    inline friend bool operator==( E lhs, error_condition const & rhs ) noexcept
-    {
-        return make_error_code( lhs ) == rhs;
-    }
-
-    template<class E, class N1 = void, class N2 = typename detail::enable_if<std::is_error_code_enum<E>::value>::type>
-    inline friend bool operator!=( error_condition const & lhs, E rhs ) noexcept
-    {
-        return !( lhs == rhs );
-    }
-
-    template<class E, class N1 = void, class N2 = typename detail::enable_if<std::is_error_code_enum<E>::value>::type>
-    inline friend bool operator!=( E lhs, error_condition const & rhs ) noexcept
-    {
-        return !( lhs == rhs );
-    }
+#endif

    std::string to_string() const
    {
@@ -35,18 +35,18 @@ class BOOST_SYMBOL_VISIBLE generic_error_category: public error_category
 {
 public:

-    BOOST_SYSTEM_CONSTEXPR generic_error_category() noexcept:
+    BOOST_SYSTEM_CONSTEXPR generic_error_category() BOOST_NOEXCEPT:
        error_category( detail::generic_category_id )
    {
    }

-    const char * name() const noexcept BOOST_OVERRIDE
+    const char * name() const BOOST_NOEXCEPT BOOST_OVERRIDE
    {
        return "generic";
    }

    std::string message( int ev ) const BOOST_OVERRIDE;
-    char const * message( int ev, char * buffer, std::size_t len ) const noexcept BOOST_OVERRIDE;
+    char const * message( int ev, char * buffer, std::size_t len ) const BOOST_NOEXCEPT BOOST_OVERRIDE;
 };

 #if ( defined( BOOST_GCC ) && BOOST_GCC >= 40600 ) || defined( BOOST_CLANG )
@@ -55,7 +55,7 @@ public:

 // generic_error_category::message

-inline char const * generic_error_category::message( int ev, char * buffer, std::size_t len ) const noexcept
+inline char const * generic_error_category::message( int ev, char * buffer, std::size_t len ) const BOOST_NOEXCEPT
 {
    return generic_error_category_message( ev, buffer, len );
 }
@@ -86,7 +86,7 @@ template<class T> constexpr generic_error_category generic_cat_holder<T>::instan

 } // namespace detail

-constexpr error_category const & generic_category() noexcept
+constexpr error_category const & generic_category() BOOST_NOEXCEPT
 {
    return detail::generic_cat_holder<void>::instance;
 }
@@ -94,10 +94,10 @@ constexpr error_category const & generic_category() noexcept
 #else // #if defined(BOOST_SYSTEM_HAS_CONSTEXPR)

 #if !defined(__SUNPRO_CC) // trailing __global is not supported
-inline error_category const & generic_category() noexcept BOOST_SYMBOL_VISIBLE;
+inline error_category const & generic_category() BOOST_NOEXCEPT BOOST_SYMBOL_VISIBLE;
 #endif

-inline error_category const & generic_category() noexcept
+inline error_category const & generic_category() BOOST_NOEXCEPT
 {
    static const detail::generic_error_category instance;
    return instance;
@@ -27,31 +27,19 @@ namespace detail

 // glibc has two incompatible strerror_r definitions

-inline char const * strerror_r_helper( char const * r, char const * ) noexcept
+inline char const * strerror_r_helper( char const * r, char const * ) BOOST_NOEXCEPT
 {
    return r;
 }

-inline char const * strerror_r_helper( int r, char const * buffer ) noexcept
+inline char const * strerror_r_helper( int r, char const * buffer ) BOOST_NOEXCEPT
 {
    return r == 0? buffer: "Unknown error";
 }

-inline char const * generic_error_category_message( int ev, char * buffer, std::size_t len ) noexcept
+inline char const * generic_error_category_message( int ev, char * buffer, std::size_t len ) BOOST_NOEXCEPT
 {
-    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;
-    }
+    return strerror_r_helper( strerror_r( ev, buffer, len ), buffer );
 }

 inline std::string generic_error_category_message( int ev )
@@ -80,7 +68,7 @@ inline std::string generic_error_category_message( int ev )
    return m? m: "Unknown error";
 }

-inline char const * generic_error_category_message( int ev, char * buffer, std::size_t len ) noexcept
+inline char const * generic_error_category_message( int ev, char * buffer, std::size_t len ) BOOST_NOEXCEPT
 {
    if( len == 0 )
    {
@@ -35,25 +35,25 @@ class BOOST_SYMBOL_VISIBLE interop_error_category: public error_category
 {
 public:

-    BOOST_SYSTEM_CONSTEXPR interop_error_category() noexcept:
+    BOOST_SYSTEM_CONSTEXPR interop_error_category() BOOST_NOEXCEPT:
        error_category( detail::interop_category_id )
    {
    }

-    const char * name() const noexcept BOOST_OVERRIDE
+    const char * name() const BOOST_NOEXCEPT BOOST_OVERRIDE
    {
        return "std:unknown";
    }

    std::string message( int ev ) const BOOST_OVERRIDE;
-    char const * message( int ev, char * buffer, std::size_t len ) const noexcept BOOST_OVERRIDE;
+    char const * message( int ev, char * buffer, std::size_t len ) const BOOST_NOEXCEPT BOOST_OVERRIDE;
 };

 #if ( defined( BOOST_GCC ) && BOOST_GCC >= 40600 ) || defined( BOOST_CLANG )
 #pragma GCC diagnostic pop
 #endif

-inline char const * interop_error_category::message( int ev, char * buffer, std::size_t len ) const noexcept
+inline char const * interop_error_category::message( int ev, char * buffer, std::size_t len ) const BOOST_NOEXCEPT
 {
    detail::snprintf( buffer, len, "Unknown interop error %d", ev );
    return buffer;
@@ -79,7 +79,7 @@ template<class T> struct BOOST_SYMBOL_VISIBLE interop_cat_holder
 template<class T> constexpr interop_error_category interop_cat_holder<T>::instance;
 #endif

-constexpr error_category const & interop_category() noexcept
+constexpr error_category const & interop_category() BOOST_NOEXCEPT
 {
    return interop_cat_holder<void>::instance;
 }
@@ -87,10 +87,10 @@ constexpr error_category const & interop_category() noexcept
 #else // #if defined(BOOST_SYSTEM_HAS_CONSTEXPR)

 #if !defined(__SUNPRO_CC) // trailing __global is not supported
-inline error_category const & interop_category() noexcept BOOST_SYMBOL_VISIBLE;
+inline error_category const & interop_category() BOOST_NOEXCEPT BOOST_SYMBOL_VISIBLE;
 #endif

-inline error_category const & interop_category() noexcept
+inline error_category const & interop_category() BOOST_NOEXCEPT
 {
    static const detail::interop_error_category instance;
    return instance;
@@ -5,19 +5,29 @@
 // Distributed under the Boost Software License, Version 1.0
 // http://www.boost.org/LICENSE_1_0.txt

-#include <type_traits>
-
 namespace boost
 {
+
 namespace system
 {
+
 namespace detail
 {

-using std::is_same;
+template<class T1, class T2> struct is_same
+{
+    enum _vt { value = 0 };
+};
+
+template<class T> struct is_same<T, T>
+{
+    enum _vt { value = 1 };
+};

 } // namespace detail
+
 } // namespace system
+
 } // namespace boost

 #endif // #ifndef BOOST_SYSTEM_DETAIL_IS_SAME_HPP_INCLUDED
@@ -1,128 +0,0 @@
-#ifndef BOOST_SYSTEM_DETAIL_MUTEX_HPP_INCLUDED
-#define BOOST_SYSTEM_DETAIL_MUTEX_HPP_INCLUDED
-
-// Copyright 2023 Peter Dimov
-// Distributed under the Boost Software License, Version 1.0.
-// https://www.boost.org/LICENSE_1_0.txt)
-
-#include <boost/config.hpp>
-
-#if defined(BOOST_SYSTEM_DISABLE_THREADS)
-
-namespace boost
-{
-namespace system
-{
-namespace detail
-{
-
-struct mutex
-{
-    void lock()
-    {
-    }
-
-    void unlock()
-    {
-    }
-};
-
-} // namespace detail
-} // namespace system
-} // namespace boost
-
-#else // defined(BOOST_SYSTEM_DISABLE_THREADS)
-
-#if defined(BOOST_MSSTL_VERSION) && BOOST_MSSTL_VERSION >= 140
-
-// Under the MS STL, std::mutex::mutex() is not constexpr, as is
-// required by the standard, which leads to initialization order
-// issues. However, shared_mutex is based on SRWLock and its
-// default constructor is constexpr, so we use that instead.
-
-#include <boost/winapi/config.hpp>
-
-// SRWLOCK is not available when targeting Windows XP
-#if BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_WIN6
-
-#include <shared_mutex>
-
-#if BOOST_MSSTL_VERSION >= 142 || _HAS_SHARED_MUTEX
-# define BOOST_SYSTEM_HAS_MSSTL_SHARED_MUTEX
-#endif
-
-#endif // BOOST_MSSTL_VERSION >= 142 || _HAS_SHARED_MUTEX
-
-#endif // BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_WIN6
-
-#if defined(BOOST_SYSTEM_HAS_MSSTL_SHARED_MUTEX)
-
-namespace boost
-{
-namespace system
-{
-namespace detail
-{
-
-typedef std::shared_mutex mutex;
-
-} // namespace detail
-} // namespace system
-} // namespace boost
-
-#else // defined(BOOST_SYSTEM_HAS_MSSTL_SHARED_MUTEX)
-
-#include <mutex>
-
-namespace boost
-{
-namespace system
-{
-namespace detail
-{
-
-using std::mutex;
-
-} // namespace detail
-} // namespace system
-} // namespace boost
-
-#endif // defined(BOOST_SYSTEM_HAS_MSSTL_SHARED_MUTEX)
-#endif // defined(BOOST_SYSTEM_DISABLE_THREADS)
-
-namespace boost
-{
-namespace system
-{
-namespace detail
-{
-
-template<class Mtx> class lock_guard
-{
-private:
-
-    Mtx& mtx_;
-
-private:
-
-    lock_guard( lock_guard const& );
-    lock_guard& operator=( lock_guard const& );
-
-public:
-
-    explicit lock_guard( Mtx& mtx ): mtx_( mtx )
-    {
-        mtx_.lock();
-    }
-
-    ~lock_guard()
-    {
-        mtx_.unlock();
-    }
-};
-
-} // namespace detail
-} // namespace system
-} // namespace boost
-
-#endif // #ifndef BOOST_SYSTEM_DETAIL_MUTEX_HPP_INCLUDED
@@ -8,21 +8,66 @@
 //
 // See library home page at http://www.boost.org/libs/system

+#include <boost/config.hpp>
 #include <cstdio>
+#include <cstdarg>

 //

 namespace boost
 {
+
 namespace system
 {
+
 namespace detail
 {

-using std::snprintf;
+#if ( defined(_MSC_VER) && _MSC_VER < 1900 ) || ( defined(__MINGW32__) && !defined(__MINGW64_VERSION_MAJOR) )
+
+inline void snprintf( char * buffer, std::size_t len, char const * format, ... )
+{
+# if defined( BOOST_MSVC )
+#  pragma warning( push )
+#  pragma warning( disable: 4996 )
+# endif
+
+    if( len == 0 ) return;
+
+    va_list args;
+    va_start( args, format );
+
+    _vsnprintf( buffer, len - 1, format, args );
+    buffer[ len - 1 ] = 0;
+
+    va_end( args );
+
+# if defined( BOOST_MSVC )
+#  pragma warning( pop )
+# endif
+}
+
+#else
+
+#if defined(__GNUC__) && __GNUC__ >= 3
+__attribute__((__format__ (__printf__, 3, 4)))
+#endif
+inline void snprintf( char * buffer, std::size_t len, char const * format, ... )
+{
+    va_list args;
+    va_start( args, format );
+
+    std::vsnprintf( buffer, len, format, args );
+
+    va_end( args );
+}
+
+#endif

 } // namespace detail
+
 } // namespace system
+
 } // namespace boost

 #endif // #ifndef BOOST_SYSTEM_DETAIL_SNPRINTF_HPP_INCLUDED
@@ -11,7 +11,6 @@
 // See library home page at http://www.boost.org/libs/system

 #include <boost/system/detail/error_category.hpp>
-#include <boost/config.hpp>
 #include <system_error>

 //
@@ -25,8 +24,6 @@ namespace system
 namespace detail
 {

-template<unsigned Id> struct id_wrapper {};
-
 class BOOST_SYMBOL_VISIBLE std_category: public std::error_category
 {
 private:
@@ -35,28 +32,30 @@ private:

 public:

-    boost::system::error_category const & original_category() const noexcept
+    boost::system::error_category const & original_category() const BOOST_NOEXCEPT
    {
        return *pc_;
    }

 public:

-    template<unsigned Id>
-    explicit std_category( boost::system::error_category const * pc, id_wrapper<Id> ): pc_( pc )
+    explicit std_category( boost::system::error_category const * pc, unsigned id ): pc_( pc )
    {
+        if( id != 0 )
+        {
 #if defined(_MSC_VER) && defined(_CPPLIB_VER) && _MSC_VER >= 1900 && _MSC_VER < 2000

-        // We used to assign to the protected _Addr member of std::error_category
-        // here when Id != 0, but this should never happen now because this code
-        // path is no longer used
+            // Poking into the protected _Addr member of std::error_category
+            // is not a particularly good programming practice, but what can
+            // you do

-        static_assert( Id == 0, "This constructor should only be called with Id == 0 under MS STL 14.0+" );
+            _Addr = id;

 #endif
+        }
    }

-    const char * name() const noexcept BOOST_OVERRIDE
+    const char * name() const BOOST_NOEXCEPT BOOST_OVERRIDE
    {
        return pc_->name();
    }
@@ -66,13 +65,13 @@ public:
        return pc_->message( ev );
    }

-    std::error_condition default_error_condition( int ev ) const noexcept BOOST_OVERRIDE
+    std::error_condition default_error_condition( int ev ) const BOOST_NOEXCEPT BOOST_OVERRIDE
    {
        return pc_->default_error_condition( ev );
    }

-    inline bool equivalent( int code, const std::error_condition & condition ) const noexcept BOOST_OVERRIDE;
-    inline bool equivalent( const std::error_code & code, int condition ) const noexcept BOOST_OVERRIDE;
+    inline bool equivalent( int code, const std::error_condition & condition ) const BOOST_NOEXCEPT BOOST_OVERRIDE;
+    inline bool equivalent( const std::error_code & code, int condition ) const BOOST_NOEXCEPT BOOST_OVERRIDE;
 };

 } // namespace detail
@@ -26,7 +26,7 @@ namespace system
 namespace detail
 {

-inline bool std_category::equivalent( int code, const std::error_condition & condition ) const noexcept
+inline bool std_category::equivalent( int code, const std::error_condition & condition ) const BOOST_NOEXCEPT
 {
    if( condition.category() == *this )
    {
@@ -55,7 +55,7 @@ inline bool std_category::equivalent( int code, const std::error_condition & con
    }
 }

-inline bool std_category::equivalent( const std::error_code & code, int condition ) const noexcept
+inline bool std_category::equivalent( const std::error_code & code, int condition ) const BOOST_NOEXCEPT
 {
    if( code.category() == *this )
    {
@@ -34,20 +34,20 @@ class BOOST_SYMBOL_VISIBLE system_error_category: public error_category
 {
 public:

-    BOOST_SYSTEM_CONSTEXPR system_error_category() noexcept:
+    BOOST_SYSTEM_CONSTEXPR system_error_category() BOOST_NOEXCEPT:
        error_category( detail::system_category_id )
    {
    }

-    const char * name() const noexcept BOOST_OVERRIDE
+    const char * name() const BOOST_NOEXCEPT BOOST_OVERRIDE
    {
        return "system";
    }

-    error_condition default_error_condition( int ev ) const noexcept BOOST_OVERRIDE;
+    error_condition default_error_condition( int ev ) const BOOST_NOEXCEPT BOOST_OVERRIDE;

    std::string message( int ev ) const BOOST_OVERRIDE;
-    char const * message( int ev, char * buffer, std::size_t len ) const noexcept BOOST_OVERRIDE;
+    char const * message( int ev, char * buffer, std::size_t len ) const BOOST_NOEXCEPT BOOST_OVERRIDE;
 };

 #if ( defined( BOOST_GCC ) && BOOST_GCC >= 40600 ) || defined( BOOST_CLANG )
@@ -75,7 +75,7 @@ template<class T> constexpr system_error_category system_cat_holder<T>::instance

 } // namespace detail

-constexpr error_category const & system_category() noexcept
+constexpr error_category const & system_category() BOOST_NOEXCEPT
 {
    return detail::system_cat_holder<void>::instance;
 }
@@ -83,10 +83,10 @@ constexpr error_category const & system_category() noexcept
 #else // #if defined(BOOST_SYSTEM_HAS_CONSTEXPR)

 #if !defined(__SUNPRO_CC) // trailing __global is not supported
-inline error_category const & system_category() noexcept BOOST_SYMBOL_VISIBLE;
+inline error_category const & system_category() BOOST_NOEXCEPT BOOST_SYMBOL_VISIBLE;
 #endif

-inline error_category const & system_category() noexcept
+inline error_category const & system_category() BOOST_NOEXCEPT
 {
    static const detail::system_error_category instance;
    return instance;
@@ -25,7 +25,7 @@ namespace system
 namespace detail
 {

-inline int system_category_condition_win32( int ev ) noexcept
+inline int system_category_condition_win32( int ev ) BOOST_NOEXCEPT
 {
    // When using the Windows Runtime, most system errors are reported as HRESULTs.
    // We want to map the common Win32 errors to their equivalent error condition,
@@ -59,7 +59,6 @@ inline int system_category_condition_win32( int ev ) noexcept
    case ERROR_ACCESS_DENIED_: return permission_denied;
    case ERROR_ALREADY_EXISTS_: return file_exists;
    case ERROR_BAD_NETPATH_: return no_such_file_or_directory;
-    case ERROR_BAD_NET_NAME_: return no_such_file_or_directory;
    case ERROR_BAD_UNIT_: return no_such_device;
    case ERROR_BROKEN_PIPE_: return broken_pipe;
    case ERROR_BUFFER_OVERFLOW_: return filename_too_long;
@@ -76,7 +75,6 @@ inline int system_category_condition_win32( int ev ) noexcept
    case ERROR_DIR_NOT_EMPTY_: return directory_not_empty;
    case ERROR_DIRECTORY_: return invalid_argument; // WinError.h: "The directory name is invalid"
    case ERROR_DISK_FULL_: return no_space_on_device;
-    case ERROR_FILENAME_EXCED_RANGE_: return filename_too_long;
    case ERROR_FILE_EXISTS_: return file_exists;
    case ERROR_FILE_NOT_FOUND_: return no_such_file_or_directory;
    case ERROR_HANDLE_DISK_FULL_: return no_space_on_device;
@@ -102,16 +100,12 @@ inline int system_category_condition_win32( int ev ) noexcept
    case ERROR_REPARSE_TAG_INVALID_: return invalid_argument;
    case ERROR_RETRY_: return resource_unavailable_try_again;
    case ERROR_SEEK_: return io_error;
-    case ERROR_SEM_TIMEOUT_: return timed_out;
    case ERROR_SHARING_VIOLATION_: return permission_denied;
    case ERROR_NOT_SUPPORTED_: return not_supported; // WinError.h: "The request is not supported."
-    case ERROR_TIMEOUT_: return timed_out;
    case ERROR_TOO_MANY_OPEN_FILES_: return too_many_files_open;
    case ERROR_WRITE_FAULT_: return io_error;
    case ERROR_WRITE_PROTECT_: return permission_denied;

-    case 258: return timed_out; // WAIT_TIMEOUT
-
    case WSAEACCES_: return permission_denied;
    case WSAEADDRINUSE_: return address_in_use;
    case WSAEADDRNOTAVAIL_: return address_not_available;
@@ -25,7 +25,7 @@

 #include <boost/system/detail/system_category_condition_win32.hpp>

-inline boost::system::error_condition boost::system::detail::system_error_category::default_error_condition( int ev ) const noexcept
+inline boost::system::error_condition boost::system::detail::system_error_category::default_error_condition( int ev ) const BOOST_NOEXCEPT
 {
    int e2 = system_category_condition_win32( ev );

@@ -41,7 +41,7 @@ inline boost::system::error_condition boost::system::detail::system_error_catego

 #else // #if defined(BOOST_WINDOWS_API)

-inline boost::system::error_condition boost::system::detail::system_error_category::default_error_condition( int ev ) const noexcept
+inline boost::system::error_condition boost::system::detail::system_error_category::default_error_condition( int ev ) const BOOST_NOEXCEPT
 {
    return error_condition( boost::system::detail::generic_value_tag( ev ) );
 }
@@ -53,7 +53,7 @@ inline std::string boost::system::detail::system_error_category::message( int ev
    return system_error_category_message( ev );
 }

-inline char const * boost::system::detail::system_error_category::message( int ev, char * buffer, std::size_t len ) const noexcept
+inline char const * boost::system::detail::system_error_category::message( int ev, char * buffer, std::size_t len ) const BOOST_NOEXCEPT
 {
    return system_error_category_message( ev, buffer, len );
 }
@@ -32,7 +32,7 @@ inline std::string system_error_category_message( int ev )
    return system_category_message_win32( ev );
 }

-inline char const * system_error_category_message( int ev, char * buffer, std::size_t len ) noexcept
+inline char const * system_error_category_message( int ev, char * buffer, std::size_t len ) BOOST_NOEXCEPT
 {
    return system_category_message_win32( ev, buffer, len );
 }
@@ -57,7 +57,7 @@ inline std::string system_error_category_message( int ev )
    return generic_error_category_message( ev );
 }

-inline char const * system_error_category_message( int ev, char * buffer, std::size_t len ) noexcept
+inline char const * system_error_category_message( int ev, char * buffer, std::size_t len ) BOOST_NOEXCEPT
 {
    return generic_error_category_message( ev, buffer, len );
 }
@@ -47,7 +47,7 @@ inline boost::winapi::UINT_ message_cp_win32()
 #endif
 }

-inline char const * system_category_message_win32( int ev, char * buffer, std::size_t len ) noexcept
+inline char const * system_category_message_win32( int ev, char * buffer, std::size_t len ) BOOST_NOEXCEPT
 {
    if( len == 0 )
    {
@@ -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,
-            static_cast<DWORD_>(ev),
+            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,
-            static_cast<DWORD_>(ev),
+            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,
-        static_cast<DWORD_>(ev),
+        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( static_cast<std::size_t>(r), char() );
+    std::string buffer( 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[ static_cast<std::size_t>(r)-1 ] == '\n' || buffer[ static_cast<std::size_t>(r)-1 ] == '\r' ) )
+    while( r > 0 && ( buffer[ r-1 ] == '\n' || buffer[ r-1 ] == '\r' ) )
    {
        --r;
    }

-    if( r > 0 && buffer[ static_cast<std::size_t>(r)-1 ] == '.' )
+    if( r > 0 && buffer[ r-1 ] == '.' )
    {
        --r;
    }
@@ -31,19 +31,19 @@ namespace errc
 {

 // explicit conversion:
-BOOST_SYSTEM_CONSTEXPR inline error_code make_error_code( errc_t e ) noexcept
+BOOST_SYSTEM_CONSTEXPR inline error_code make_error_code( errc_t e ) BOOST_NOEXCEPT
 {
    return error_code( e, generic_category() );
 }

 // explicit conversion:
-inline error_code make_error_code( errc_t e, boost::source_location const * loc ) noexcept
+inline error_code make_error_code( errc_t e, boost::source_location const * loc ) BOOST_NOEXCEPT
 {
    return error_code( e, generic_category(), loc );
 }

 // implicit conversion:
-BOOST_SYSTEM_CONSTEXPR inline error_condition make_error_condition( errc_t e ) noexcept
+BOOST_SYSTEM_CONSTEXPR inline error_condition make_error_condition( errc_t e ) BOOST_NOEXCEPT
 {
    return error_condition( e, generic_category() );
 }
@@ -43,7 +43,7 @@ public:
    system_error( int ev, error_category const & ecat, char const * prefix ):
        std::runtime_error( std::string( prefix ) + ": " + error_code( ev, ecat ).what() ), code_( ev, ecat ) {}

-    error_code code() const noexcept
+    error_code code() const BOOST_NOEXCEPT
    {
        return code_;
    }
@@ -13,5 +13,5 @@
        "Error-handling",
        "Programming"
    ],
-    "cxxstd": "11"
+    "cxxstd": "03"
 }
@@ -0,0 +1,31 @@
+//  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
@@ -15,7 +15,6 @@ macro(system_run s1)
  boost_test(SOURCES ${s1} ${ARGN})
  boost_test(SOURCES ${s1} ${ARGN} COMPILE_DEFINITIONS BOOST_NO_ANSI_APIS NAME ${n1}_no_ansi)
  boost_test(SOURCES ${s1} ${ARGN} COMPILE_DEFINITIONS BOOST_SYSTEM_USE_UTF8 NAME ${n1}_utf8)
-  boost_test(SOURCES ${s1} ${ARGN} COMPILE_DEFINITIONS BOOST_SYSTEM_DISABLE_THREADS NAME ${n1}_nthr)

 endmacro()

@@ -27,7 +26,7 @@ macro(lib name macro)

 endmacro()

-set(BOOST_TEST_LINK_LIBRARIES Boost::system Boost::config Boost::core)
+set(BOOST_TEST_LINK_LIBRARIES Boost::system Boost::core Boost::static_assert)

 boost_test(SOURCES quick.cpp)

@@ -84,6 +83,7 @@ boost_test(TYPE run SOURCES system_category_test2.cpp)
 boost_test(TYPE run SOURCES system_category_test3.cpp)

 boost_test(TYPE run SOURCES windows_error_test.cpp)
+boost_test(TYPE run SOURCES cygwin_error_test.cpp)
 boost_test(TYPE run SOURCES linux_error_test.cpp)

 boost_test(TYPE link SOURCES errc_test3.cpp)
@@ -124,21 +124,10 @@ boost_test(TYPE run SOURCES std_interop_test14.cpp)
 boost_test(TYPE run SOURCES ec_location_test3.cpp)
 boost_test(TYPE run SOURCES ec_location_test4.cpp)

-boost_test(TYPE compile SOURCES constexpr_test2.cpp)
-
-boost_test(TYPE run SOURCES error_code_test3.cpp)
-boost_test(TYPE run SOURCES std_interop_test15.cpp)
-
-boost_test(TYPE run SOURCES win32_generic_test.cpp)
-
-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

+set(BOOST_TEST_COMPILE_FEATURES cxx_std_11)
+
 boost_test(TYPE run SOURCES result_default_construct.cpp)
 boost_test(TYPE run SOURCES result_value_construct.cpp)
 boost_test(TYPE run SOURCES result_error_construct.cpp)
@@ -153,34 +142,4 @@ boost_test(TYPE run SOURCES result_eq.cpp)
 boost_test(TYPE run SOURCES result_range_for.cpp)
 boost_test(TYPE run SOURCES result_value_construct2.cpp)
 boost_test(TYPE run SOURCES result_error_construct2.cpp)
-boost_test(TYPE run SOURCES result_errc_construct.cpp)
 boost_test(TYPE run SOURCES result_convert_construct.cpp)
-boost_test(TYPE run SOURCES result_typedefs.cpp)
-boost_test(TYPE run SOURCES result_value_construct3.cpp)
-boost_test(TYPE run SOURCES result_error_construct3.cpp)
-boost_test(TYPE run SOURCES result_emplace.cpp)
-boost_test(TYPE run SOURCES result_error_construct4.cpp)
-boost_test(TYPE run SOURCES result_value_construct4.cpp)
-boost_test(TYPE run SOURCES result_value_construct5.cpp)
-boost_test(TYPE run SOURCES result_error_move.cpp)
-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 run SOURCES result_or_fn0v.cpp)
-boost_test(TYPE run SOURCES result_or_fn0r.cpp)
-boost_test(TYPE run SOURCES result_and_fn1v.cpp)
-boost_test(TYPE run SOURCES result_and_fn1r.cpp)
-boost_test(TYPE run SOURCES result_and_eq_fn1v.cpp)
-boost_test(TYPE run SOURCES result_and_eq_fn1r.cpp)
-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)
@@ -17,9 +17,6 @@ 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
@@ -36,7 +33,6 @@ rule system-run ( sources + )
    result += [ run $(sources) : : : <library>/boost/system//boost_system <link>shared : $(sources[1]:B)_shared ] ;
    result += [ run $(sources) : : : <define>BOOST_NO_ANSI_APIS : $(sources[1]:B)_no_ansi ] ;
    result += [ run $(sources) : : : <define>BOOST_SYSTEM_USE_UTF8 : $(sources[1]:B)_utf8 ] ;
-    result += [ run $(sources) : : : <define>BOOST_SYSTEM_DISABLE_THREADS : $(sources[1]:B)_nthr ] ;

    return $(result) ;
 }
@@ -78,9 +74,7 @@ system-run generic_category_test.cpp ;
 system-run system_category_test.cpp ;
 system-run after_main_test.cpp ;
 system-run failed_test.cpp ;
-run failed_constexpr_test.cpp : : :
-    # GCC w/ UBSAN doesn't consider `cat_ != 0` a constant expression
-    <toolset>gcc,<undefined-sanitizer>norecover:<build>no ;
+system-run failed_constexpr_test.cpp ;

 # Quick (CI) test
 run quick.cpp ;
@@ -111,6 +105,7 @@ run system_category_test2.cpp ;
 run system_category_test3.cpp ;

 run windows_error_test.cpp ;
+run cygwin_error_test.cpp ;
 run linux_error_test.cpp ;

 link errc_test3.cpp ;
@@ -157,63 +152,25 @@ run std_interop_test14.cpp ;
 run ec_location_test3.cpp ;
 run ec_location_test4.cpp ;

-compile constexpr_test2.cpp ;
-
-run error_code_test3.cpp ;
-run std_interop_test15.cpp ;
-
-run win32_generic_test.cpp ;
-
-run ec_hash_value_test.cpp ;
-
-run std_interop_test16.cpp ;
-
-run failed_constexpr_test2.cpp ;
-
 # result

-run result_default_construct.cpp ;
-run result_value_construct.cpp ;
-run result_error_construct.cpp ;
-run result_copy_construct.cpp ;
-run result_move_construct.cpp ;
-run result_copy_assign.cpp ;
-run result_move_assign.cpp ;
-run result_value_access.cpp ;
-run result_error_access.cpp ;
-run result_swap.cpp : : : <toolset>gcc-10:<cxxflags>"-Wno-maybe-uninitialized" ;
-run result_eq.cpp ;
-run result_range_for.cpp ;
-run result_value_construct2.cpp ;
-run result_error_construct2.cpp ;
-run result_errc_construct.cpp ;
-run result_convert_construct.cpp ;
-run result_typedefs.cpp ;
-run result_value_construct3.cpp ;
-run result_error_construct3.cpp ;
-run result_emplace.cpp ;
-run result_error_construct4.cpp ;
-run result_value_construct4.cpp ;
-run result_value_construct5.cpp ;
-run result_error_move.cpp ;
-run result_value_construct6.cpp ;
-run result_value_construct7.cpp ;
-run result_error_construct5.cpp ;
-run result_or_value.cpp ;
-run result_or_fn0v.cpp ;
-run result_or_fn0r.cpp ;
-run result_and_fn1v.cpp ;
-run result_and_fn1r.cpp ;
-run result_and_eq_fn1v.cpp ;
-run result_and_eq_fn1r.cpp ;
-run result_in_place_use.cpp ;
-run result_or_eq_value.cpp ;
-run result_or_eq_fn0v.cpp ;
-run result_or_eq_fn0r.cpp ;
+import ../../config/checks/config : requires ;

-run result_and_mfn1v.cpp ;
-run result_and_mfn1r.cpp ;
+CPP11 = [ requires cxx11_variadic_templates cxx11_template_aliases cxx11_decltype cxx11_constexpr cxx11_noexcept ] <toolset>gcc-4.7:<build>no ;

-compile result_value_construct_cx.cpp ;
-compile result_error_construct_cx.cpp ;
-compile result_error_construct_cx2.cpp ;
+run result_default_construct.cpp : : : $(CPP11) ;
+run result_value_construct.cpp : : : $(CPP11) ;
+run result_error_construct.cpp : : : $(CPP11) ;
+run result_copy_construct.cpp : : : $(CPP11) ;
+run result_move_construct.cpp : : : $(CPP11) ;
+run result_copy_assign.cpp : : : $(CPP11) ;
+run result_move_assign.cpp : : : $(CPP11) ;
+run result_value_access.cpp : : : $(CPP11) ;
+run result_error_access.cpp : : : $(CPP11) ;
+run result_swap.cpp : : : $(CPP11) <toolset>gcc-10:<cxxflags>"-Wno-maybe-uninitialized" ;
+run result_eq.cpp : : : $(CPP11) ;
+run result_range_for.cpp : : : $(CPP11) ;
+run result_value_construct2.cpp : : : $(CPP11) ;
+run result_error_construct2.cpp : : : $(CPP11) ;
+run result_errc_construct.cpp : : : $(CPP11) ;
+run result_convert_construct.cpp : : : $(CPP11) ;
@@ -14,4 +14,4 @@ target_link_libraries(main Boost::system)
 enable_testing()
 add_test(main main)

-add_custom_target(check VERBATIM COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -C $<CONFIG>)
+add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -C $<CONFIG>)
@@ -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 VERBATIM COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure --no-tests=error -C $<CONFIG>)
+add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure --no-tests=error -C $<CONFIG>)
@@ -50,6 +50,16 @@ int main()
  std::cout << "BOOST_NO_ANSI_APIS is defined" << std::endl;
 #else
  std::cout << "BOOST_NO_ANSI_APIS is not defined" << std::endl;
+#endif
+#ifdef BOOST_NO_CXX11_NOEXCEPT
+  std::cout << "BOOST_NO_CXX11_NOEXCEPT is defined" << std::endl;
+#else
+  std::cout << "BOOST_NO_CXX11_NOEXCEPT is not defined" << std::endl;
+#endif
+#ifdef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
+  std::cout << "BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS is defined" << std::endl;
+#else
+  std::cout << "BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS is not defined" << std::endl;
 #endif
  return 0;
 }
@@ -1,35 +0,0 @@
-// Copyright 2022 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/config.hpp>
-#include <boost/config/pragma_message.hpp>
-
-#if defined(BOOST_GCC) && BOOST_GCC >= 40700 && BOOST_GCC < 40800
-
-BOOST_PRAGMA_MESSAGE("Skipping test, BOOST_GCC is 407xx")
-
-#else
-
-struct X
-{
-    boost::system::error_code ec;
-};
-
-X const& f()
-{
-#if defined(BOOST_CLANG_VERSION) && BOOST_CLANG_VERSION < 30900
-
-    BOOST_STATIC_CONSTEXPR X x = {};
-    return x;
-
-#else
-
-    BOOST_STATIC_CONSTEXPR X x;
-    return x;
-
-#endif
-}
-
-#endif
@@ -0,0 +1,29 @@
+// Copyright 2020 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/cygwin_error.hpp>
+#include <boost/config/pragma_message.hpp>
+
+#if !defined(__CYGWIN__)
+
+BOOST_PRAGMA_MESSAGE( "Skipping test, __CYGWIN__ is not defined" )
+int main() {}
+
+#else
+
+#include <boost/core/lightweight_test.hpp>
+
+int main()
+{
+    namespace sys = boost::system;
+
+    sys::error_code ec = sys::cygwin_error::no_package;
+
+    BOOST_TEST_EQ( ec, sys::cygwin_error::no_package );
+    BOOST_TEST_EQ( ec, sys::error_code( ENOPKG, sys::system_category() ) );
+
+    return boost::report_errors();
+}
+
+#endif
@@ -1,126 +0,0 @@
-// Copyright 2022 Peter Dimov.
-// Distributed under the Boost Software License, Version 1.0.
-// http://www.boost.org/LICENSE_1_0.txt
-
-#include <boost/system/error_code.hpp>
-#include <boost/system/generic_category.hpp>
-#include <boost/system/system_category.hpp>
-#include <boost/core/lightweight_test.hpp>
-#include <cerrno>
-#include <system_error>
-
-namespace sys = boost::system;
-
-int main()
-{
-    // normal against normal (equal, system)
-    {
-        sys::error_code e2( 0, sys::system_category() );
-        sys::error_code e3( e2.value(), e2.category() );
-
-        BOOST_TEST( e2 != e3 || hash_value( e2 ) == hash_value( e3 ) );
-        BOOST_TEST( e2 == e3 || hash_value( e2 ) != hash_value( e3 ) );
-    }
-
-    // normal against normal (equal, generic)
-    {
-        sys::error_code e2( EINVAL, sys::generic_category() );
-        sys::error_code e3( e2.value(), e2.category() );
-
-        BOOST_TEST( e2 != e3 || hash_value( e2 ) == hash_value( e3 ) );
-        BOOST_TEST( e2 == e3 || hash_value( e2 ) != hash_value( e3 ) );
-    }
-
-    // normal against normal (inequal, value, generic)
-    {
-        sys::error_code e2( 0, sys::generic_category() );
-        sys::error_code e3( EINVAL, sys::generic_category() );
-
-        BOOST_TEST( e2 != e3 || hash_value( e2 ) == hash_value( e3 ) );
-        BOOST_TEST( e2 == e3 || hash_value( e2 ) != hash_value( e3 ) );
-    }
-
-    // normal against normal (inequal, value, system)
-    {
-        sys::error_code e2( 1, sys::system_category() );
-        sys::error_code e3( 2, sys::system_category() );
-
-        BOOST_TEST( e2 != e3 || hash_value( e2 ) == hash_value( e3 ) );
-        BOOST_TEST( e2 == e3 || hash_value( e2 ) != hash_value( e3 ) );
-    }
-
-    // normal against normal (inequal, category)
-    {
-        sys::error_code e2( 0, sys::system_category() );
-        sys::error_code e3( 0, sys::generic_category() );
-
-        BOOST_TEST( e2 != e3 || hash_value( e2 ) == hash_value( e3 ) );
-        BOOST_TEST( e2 == e3 || hash_value( e2 ) != hash_value( e3 ) );
-    }
-
-    // empty against normal
-    {
-        sys::error_code e2;
-        sys::error_code e3( e2.value(), e2.category() );
-
-        BOOST_TEST( e2 != e3 || hash_value( e2 ) == hash_value( e3 ) );
-        BOOST_TEST( e2 == e3 || hash_value( e2 ) != hash_value( e3 ) );
-    }
-
-    // std:: wrapping against normal
-    {
-        std::error_code e1( EINVAL, std::generic_category() );
-
-        sys::error_code e2( e1 );
-        sys::error_code e3( e2.value(), e2.category() );
-
-        BOOST_TEST( e2 != e3 || hash_value( e2 ) == hash_value( e3 ) );
-        BOOST_TEST( e2 == e3 || hash_value( e2 ) != hash_value( e3 ) );
-    }
-
-    // empty against wrapping std:: empty
-    {
-        std::error_code e1;
-
-        sys::error_code e2( e1 );
-        sys::error_code e3;
-
-        BOOST_TEST( e2 != e3 || hash_value( e2 ) == hash_value( e3 ) );
-        BOOST_TEST( e2 == e3 || hash_value( e2 ) != hash_value( e3 ) );
-    }
-
-    // empty against roundtrip via std
-    {
-        sys::error_code e2;
-
-        std::error_code e1( e2 );
-        sys::error_code e3( e1 );
-
-        BOOST_TEST( e2 != e3 || hash_value( e2 ) == hash_value( e3 ) );
-        BOOST_TEST( e2 == e3 || hash_value( e2 ) != hash_value( e3 ) );
-    }
-
-    // normal/generic against roundtrip via std
-    {
-        sys::error_code e2( EINVAL, boost::system::generic_category() );
-
-        std::error_code e1( e2 );
-        sys::error_code e3( e1 );
-
-        BOOST_TEST( e2 != e3 || hash_value( e2 ) == hash_value( e3 ) );
-        BOOST_TEST( e2 == e3 || hash_value( e2 ) != hash_value( e3 ) );
-    }
-
-    // normal/system against roundtrip via std
-    {
-        sys::error_code e2( 0, boost::system::system_category() );
-
-        std::error_code e1( e2 );
-        sys::error_code e3( e1 );
-
-        BOOST_TEST( e2 != e3 || hash_value( e2 ) == hash_value( e3 ) );
-        BOOST_TEST( e2 == e3 || hash_value( e2 ) != hash_value( e3 ) );
-    }
-
-    return boost::report_errors();
-}
@@ -85,6 +85,8 @@ int main()
        BOOST_TEST_EQ( ec.location().line(), 75 );
    }

+#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
+
    {
        std::error_code e2( val, std::generic_category() );

@@ -105,8 +107,10 @@ int main()
        BOOST_TEST( ec.failed() );

        BOOST_TEST( ec.has_location() );
-        BOOST_TEST_EQ( ec.location().line(), 98 );
+        BOOST_TEST_EQ( ec.location().line(), 100 );
    }

+#endif
+
    return boost::report_errors();
 }
@@ -32,6 +32,8 @@ sys::error_code make_error_code( E e )
    return e == 0? sys::error_code(): sys::error_code( e, sys::generic_category() );
 }

+#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
+
 enum E2
 {
    e2inval = EINVAL
@@ -55,6 +57,8 @@ std::error_code make_error_code( E2 e )
    return std::error_code( e, std::generic_category() );
 }

+#endif
+
 int main()
 {
    {
@@ -80,7 +84,7 @@ int main()
        BOOST_TEST( ec.failed() );

        BOOST_TEST( ec.has_location() );
-        BOOST_TEST_EQ( ec.location().line(), 73 );
+        BOOST_TEST_EQ( ec.location().line(), 77 );
    }

    {
@@ -130,7 +134,7 @@ int main()
        BOOST_TEST( ec.failed() );

        BOOST_TEST( ec.has_location() );
-        BOOST_TEST_EQ( ec.location().line(), 123 );
+        BOOST_TEST_EQ( ec.location().line(), 127 );
    }

    {
@@ -178,7 +182,7 @@ int main()
        BOOST_TEST( ec.failed() );

        BOOST_TEST( ec.has_location() );
-        BOOST_TEST_EQ( ec.location().line(), 171 );
+        BOOST_TEST_EQ( ec.location().line(), 175 );
    }

    {
@@ -205,6 +209,8 @@ int main()
        BOOST_TEST_EQ( ec.location().line(), 0 );
    }

+#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
+
    {
        sys::error_code ec( e2inval );

@@ -275,5 +281,7 @@ int main()
        BOOST_TEST_EQ( ec.location().line(), 0 );
    }

+#endif
+
    return boost::report_errors();
 }
@@ -57,6 +57,8 @@ int main()
        BOOST_TEST_EQ( ec3.location(), boost::source_location() );
    }

+#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
+
    {
        std::error_code e2( val, std::generic_category() );

@@ -82,5 +84,7 @@ int main()
        BOOST_TEST_EQ( ec3.location(), boost::source_location() );
    }

+#endif
+
    return boost::report_errors();
 }
@@ -59,6 +59,8 @@ int main()
        BOOST_TEST_EQ( ec.location(), boost::source_location() );
    }

+#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
+
    {
        std::error_code e2( val, std::generic_category() );

@@ -85,5 +87,7 @@ int main()
        BOOST_TEST_EQ( ec.location(), boost::source_location() );
    }

+#endif
+
    return boost::report_errors();
 }
@@ -62,6 +62,8 @@ int main()
        BOOST_TEST_EQ( ec.what(), ec.message() + " [system:5 at " + loc.to_string() + "]" );
    }

+#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
+
    {
        std::error_code ec;
        sys::error_code ec2( ec );
@@ -83,5 +85,7 @@ int main()
        BOOST_TEST_EQ( ec2.what(), ec2.message() + " [std:system:5]" );
    }

+#endif
+
    return boost::report_errors();
 }
@@ -8,9 +8,11 @@

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

+// Avoid spurious VC++ warnings
+# define _CRT_SECURE_NO_WARNINGS
+
 #include <boost/system/error_code.hpp>
 #include <boost/core/lightweight_test.hpp>
-#include <boost/core/snprintf.hpp>
 #include <cstdio>

 //
@@ -21,7 +23,7 @@ class user_category: public sys::error_category
 {
 public:

-    virtual const char * name() const noexcept
+    virtual const char * name() const BOOST_NOEXCEPT
    {
        return "user";
    }
@@ -29,7 +31,7 @@ public:
    virtual std::string message( int ev ) const
    {
        char buffer[ 256 ];
-        boost::core::snprintf( buffer, sizeof( buffer ), "user message %d", ev );
+        std::sprintf( buffer, "user message %d", ev );

        return buffer;
    }
@@ -8,9 +8,11 @@

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

+// Avoid spurious VC++ warnings
+#define _CRT_SECURE_NO_WARNINGS
+
 #include <boost/system/error_category.hpp>
 #include <boost/core/lightweight_test.hpp>
-#include <boost/core/snprintf.hpp>
 #include <cstdio>

 //
@@ -21,7 +23,7 @@ class user_category: public sys::error_category
 {
 public:

-    virtual const char * name() const noexcept
+    virtual const char * name() const BOOST_NOEXCEPT
    {
        return "user";
    }
@@ -29,7 +31,7 @@ public:
    virtual std::string message( int ev ) const
    {
        char buffer[ 256 ];
-        boost::core::snprintf( buffer, sizeof( buffer ), "user message %d", ev );
+        std::sprintf( buffer, "user message %d", ev );

        return buffer;
    }
@@ -11,53 +11,26 @@ namespace sys = boost::system;

 int main()
 {
-    char buffer[ 4096 ], buffer2[ 4096 ];
+    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" ) );

    {
-        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(), 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_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.category().message( ec2.value(), buffer, sizeof( buffer ) ) );
        BOOST_TEST( !ec2.failed() );
        BOOST_TEST( !ec2 );

@@ -68,25 +41,12 @@ 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(), 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_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.category().message( ec2.value(), buffer, sizeof( buffer ) ) );
        BOOST_TEST( !ec2.failed() );
        BOOST_TEST( !ec2 );

@@ -101,124 +61,34 @@ 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(), 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_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.category().message( ec2.value(), buffer, sizeof( buffer ) ) );
        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(), 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_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.category().message( ec2.value(), buffer, sizeof( buffer ) ) );
        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();
 }
@@ -1,69 +0,0 @@
-// Copyright 2022 Peter Dimov.
-// Distributed under the Boost Software License, Version 1.0.
-// http://www.boost.org/LICENSE_1_0.txt
-
-#include <boost/system/error_code.hpp>
-#include <boost/system/error_condition.hpp>
-#include <boost/system/generic_category.hpp>
-#include <boost/core/lightweight_test.hpp>
-
-namespace sys = boost::system;
-
-enum my_errc
-{
-    enomem_c = ENOMEM
-};
-
-enum my_errn
-{
-    enomem_n = ENOMEM
-};
-
-namespace boost {
-namespace system {
-
-template<> struct is_error_code_enum<my_errc>
-{
-    static const bool value = true;
-};
-
-template<> struct is_error_condition_enum<my_errn>
-{
-    static const bool value = true;
-};
-
-} // namespace system
-} // namespace boost
-
-sys::error_code make_error_code( my_errc e )
-{
-    return sys::error_code( e, sys::generic_category() );
-}
-
-sys::error_condition make_error_condition( my_errn e )
-{
-    return sys::error_condition( e, sys::generic_category() );
-}
-
-int main()
-{
-    sys::error_code ec = make_error_code( sys::errc::not_enough_memory );
-    sys::error_condition en( sys::errc::not_enough_memory );
-
-    BOOST_TEST_EQ( ec, en );
-    BOOST_TEST_EQ( en, ec );
-
-    BOOST_TEST_EQ( ec, enomem_c );
-    BOOST_TEST_EQ( enomem_c, ec );
-
-    BOOST_TEST_EQ( ec, enomem_n );
-    BOOST_TEST_EQ( enomem_n, ec );
-
-    BOOST_TEST_EQ( en, enomem_c );
-    BOOST_TEST_EQ( enomem_c, en );
-
-    BOOST_TEST_EQ( en, enomem_n );
-    BOOST_TEST_EQ( enomem_n, en );
-
-    return boost::report_errors();
-}
@@ -11,53 +11,26 @@ namespace sys = boost::system;

 int main()
 {
-    char buffer[ 4096 ], buffer2[ 4096 ];
+    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" ) );

    {
-        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(), 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_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.category().message( en2.value(), buffer, sizeof( buffer ) ) );
        BOOST_TEST( !en2.failed() );
        BOOST_TEST( !en2 );

@@ -68,25 +41,12 @@ 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(), 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_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.category().message( en2.value(), buffer, sizeof( buffer ) ) );
        BOOST_TEST( !en2.failed() );
        BOOST_TEST( !en2 );

@@ -101,124 +61,34 @@ 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(), 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_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.category().message( en2.value(), buffer, sizeof( buffer ) ) );
        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(), 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_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.category().message( en2.value(), buffer, sizeof( buffer ) ) );
        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();
 }
@@ -1,54 +0,0 @@
-// 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
@@ -2,9 +2,11 @@
 // Copyright 2018 Peter Dimov.
 // Distributed under the Boost Software License, Version 1.0.

+// Avoid spurious VC++ warnings
+#define _CRT_SECURE_NO_WARNINGS
+
 #include <boost/system/error_code.hpp>
 #include <boost/core/lightweight_test.hpp>
-#include <boost/core/snprintf.hpp>
 #include <cstdio>

 using namespace boost::system;
@@ -13,11 +15,11 @@ struct http_category_impl: public error_category
 {
    // clang++ 3.8 and below: initialization of const object
    // requires a user-provided default constructor
-    BOOST_SYSTEM_CONSTEXPR http_category_impl() noexcept
+    BOOST_SYSTEM_CONSTEXPR http_category_impl() BOOST_NOEXCEPT
    {
    }

-    char const * name() const noexcept
+    char const * name() const BOOST_NOEXCEPT
    {
        return "http";
    }
@@ -26,11 +28,11 @@ struct http_category_impl: public error_category
    {
        char buffer[ 32 ];

-        boost::core::snprintf( buffer, sizeof( buffer ), "HTTP/1.0 %d", ev );
+        std::sprintf( buffer, "HTTP/1.0 %d", ev );
        return buffer;
    }

-    bool failed( int ev ) const noexcept
+    bool failed( int ev ) const BOOST_NOEXCEPT
    {
        return !( ev >= 200 && ev < 300 );
    }
@@ -1,149 +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>
-#include <boost/core/lightweight_test.hpp>
-
-using namespace boost::system;
-
-struct X
-{
-    int v_;
-};
-
-struct Y
-{
-    int v_;
-
-    explicit Y( int v ): v_( v ) {}
-    Y( X x ): v_( x.v_) {}
-
-    Y( Y const& ) = delete;
-    Y& operator=( Y const& ) = delete;
-
-    Y( Y&& r ): v_( r.v_ )
-    {
-        r.v_ = 0;
-    }
-
-    Y& operator=( Y&& r )
-    {
-        if( &r != this )
-        {
-            v_ = r.v_;
-            r.v_ = 0;
-        }
-
-        return *this;
-    }
-};
-
-struct E
-{
-};
-
-struct E2
-{
-    E2() {}
-    E2( E ) {}
-};
-
-result<int, E> fi( int x )
-{
-    return 2 * x + 1;
-}
-
-result<int, E2> fi2( int )
-{
-    return E2();
-}
-
-result<X, E> fy( Y y )
-{
-    return X{ 2 * y.v_ + 1 };
-}
-
-result<Y, E2> fy2( Y )
-{
-    return E2();
-}
-
-result<int&, E> fri( int& )
-{
-    static int x = 2;
-    return x;
-}
-
-result<int&, E2> fri2( int& )
-{
-    return E2();
-}
-
-result<void, E2> fv()
-{
-    return {};
-}
-
-result<void, E2> fv2()
-{
-    return E2();
-}
-
-int main()
-{
-    {
-        result<int, E2> r( 1 );
-
-        r &= fi;
-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( *r, 3 );
-
-        r &= fi2;
-        BOOST_TEST( r.has_error() );
-
-        r &= fi;
-        BOOST_TEST( r.has_error() );
-    }
-
-    {
-        result<Y, E2> r( in_place_value, 1 );
-
-        r &= fy;
-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( r->v_, 3 );
-
-        r &= fy2;
-        BOOST_TEST( r.has_error() );
-
-        r &= fy;
-        BOOST_TEST( r.has_error() );
-    }
-
-    {
-        int x1 = 1;
-        result<int&, E2> r( x1 );
-
-        r &= fri;
-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( &*r, &*fri( x1 ) );
-
-        r &= fri2;
-        BOOST_TEST( r.has_error() );
-
-        r &= fri;
-        BOOST_TEST( r.has_error() );
-    }
-
-    {
-        result<void, E2> r;
-
-        r &= fv;
-        BOOST_TEST( r.has_value() );
-
-        r &= fv2;
-        BOOST_TEST( r.has_error() );
-
-        r &= fv;
-        BOOST_TEST( r.has_error() );
-    }
-
-    return boost::report_errors();
-}
@@ -1,141 +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>
-#include <boost/core/lightweight_test.hpp>
-
-using namespace boost::system;
-
-struct X
-{
-    int v_;
-};
-
-struct Y
-{
-    int v_;
-
-    explicit Y( int v ): v_( v ) {}
-    Y( X x ): v_( x.v_) {}
-
-    Y( Y const& ) = delete;
-    Y& operator=( Y const& ) = delete;
-
-    Y( Y&& r ): v_( r.v_ )
-    {
-        r.v_ = 0;
-    }
-
-    Y& operator=( Y&& r )
-    {
-        if( &r != this )
-        {
-            v_ = r.v_;
-            r.v_ = 0;
-        }
-
-        return *this;
-    }
-};
-
-struct E
-{
-};
-
-int f( int x )
-{
-    return x * 2 + 1;
-}
-
-X g( Y y )
-{
-    return X{ y.v_ * 2 + 1 };
-}
-
-int& h( int& )
-{
-    static int x = 2;
-    return x;
-}
-
-static int fv_called;
-
-void fv()
-{
-    ++fv_called;
-}
-
-int main()
-{
-    {
-        result<int> r( 1 );
-
-        r &= f;
-
-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( *r, 3 );
-    }
-
-    {
-        result<int, E> r( in_place_error );
-
-        r &= f;
-
-        BOOST_TEST( r.has_error() );
-    }
-
-    {
-        result<Y> r( in_place_value, 1 );
-
-        r &= g;
-
-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( r->v_, 3 );
-    }
-
-    {
-        result<Y, E> r( in_place_error );
-
-        r &= g;
-
-        BOOST_TEST( r.has_error() );
-    }
-
-    {
-        int x1 = 1;
-        result<int&> r( x1 );
-
-        r &= h;
-
-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( &*r, &h( x1 ) );
-    }
-
-    {
-        result<int&, E> r( in_place_error );
-
-        r &= h;
-
-        BOOST_TEST( r.has_error() );
-    }
-
-    {
-        result<void> r;
-        fv_called = 0;
-
-        r &= fv;
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST_EQ( fv_called, 1 );
-    }
-
-    {
-        result<void, E> r( in_place_error );
-        fv_called = 0;
-
-        r &= fv;
-
-        BOOST_TEST( r.has_error() );
-        BOOST_TEST_EQ( fv_called, 0 );
-    }
-
-    return boost::report_errors();
-}
@@ -1,503 +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>
-#include <boost/core/lightweight_test.hpp>
-
-using namespace boost::system;
-
-struct X
-{
-    int v_;
-};
-
-struct Y
-{
-    int v_;
-
-    explicit Y( int v ): v_( v ) {}
-    Y( X x ): v_( x.v_) {}
-
-    Y( Y const& ) = delete;
-    Y& operator=( Y const& ) = delete;
-
-    Y( Y&& r ): v_( r.v_ )
-    {
-        r.v_ = 0;
-    }
-
-    Y& operator=( Y&& ) = delete;
-};
-
-struct E
-{
-};
-
-struct E2
-{
-    E2() {}
-    E2( E ) {}
-};
-
-result<int, E2> fi( int x )
-{
-    return 2 * x + 1;
-}
-
-result<int, E2> fi2( int )
-{
-    return E2();
-}
-
-result<void, E2> fi3( int )
-{
-    return {};
-}
-
-result<X, E2> fy( Y y )
-{
-    return X{ 2 * y.v_ + 1 };
-}
-
-result<X, E2> fy2( Y )
-{
-    return E2();
-}
-
-result<void, E2> fy3( Y )
-{
-    return {};
-}
-
-result<int, E2> fri( int& x )
-{
-    return x * 2 + 1;
-}
-
-result<int&, E2> fri2( int& )
-{
-    return E2();
-}
-
-result<void, E2> fri3( int& )
-{
-    return {};
-}
-
-result<int, E2> fk()
-{
-    return 7;
-}
-
-result<int, E2> fk2()
-{
-    return E2();
-}
-
-result<void, E2> fk3()
-{
-    return {};
-}
-
-result<void, E2> fk4()
-{
-    return E2();
-}
-
-int main()
-{
-    {
-        result<int, E> r( 1 );
-
-        {
-            result<int, E2> r2 = r & fi;
-            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 3 );
-        }
-
-        {
-            result<int, E2> r2 = r & fi2;
-            BOOST_TEST( r2.has_error() );
-        }
-
-        {
-            result<void, E2> r2 = r & fi3;
-            BOOST_TEST( r2.has_value() );
-        }
-    }
-
-    {
-        result<int, E> const r( 1 );
-
-        {
-            result<int, E2> r2 = r & fi;
-            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 3 );
-        }
-
-        {
-            result<int, E2> r2 = r & fi2;
-            BOOST_TEST( r2.has_error() );
-        }
-
-        {
-            result<void, E2> r2 = r & fi3;
-            BOOST_TEST( r2.has_value() );
-        }
-    }
-
-    {
-        result<int, E2> r2 = result<int, E>( 1 ) & fi;
-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 3 );
-    }
-
-    {
-        result<int, E2> r2 = result<int, E>( 1 ) & fi2;
-        BOOST_TEST( r2.has_error() );
-    }
-
-    {
-        result<void, E2> r2 = result<int, E>( 1 ) & fi3;
-        BOOST_TEST( r2.has_value() );
-    }
-
-    {
-        result<int, E> r( in_place_error );
-
-        {
-            result<int, E2> r2 = r & fi;
-            BOOST_TEST( r2.has_error() );
-        }
-
-        {
-            result<int, E2> r2 = r & fi2;
-            BOOST_TEST( r2.has_error() );
-        }
-
-        {
-            result<void, E2> r2 = r & fi3;
-            BOOST_TEST( r2.has_error() );
-        }
-    }
-
-    {
-        result<int, E> const r( in_place_error );
-
-        {
-            result<int, E2> r2 = r & fi;
-            BOOST_TEST( r2.has_error() );
-        }
-
-        {
-            result<int, E2> r2 = r & fi2;
-            BOOST_TEST( r2.has_error() );
-        }
-
-        {
-            result<void, E2> r2 = r & fi3;
-            BOOST_TEST( r2.has_error() );
-        }
-    }
-
-    {
-        result<int, E2> r2 = result<int, E>( in_place_error ) & fi;
-        BOOST_TEST( r2.has_error() );
-    }
-
-    {
-        result<int, E2> r2 = result<int, E>( in_place_error ) & fi2;
-        BOOST_TEST( r2.has_error() );
-    }
-
-    {
-        result<void, E2> r2 = result<int, E>( in_place_error ) & fi3;
-        BOOST_TEST( r2.has_error() );
-    }
-
-    {
-        result<X, E2> r2 = result<Y, E>( in_place_value, 1 ) & fy;
-
-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2->v_, 3 );
-    }
-
-    {
-        result<X, E2> r2 = result<Y, E>( in_place_value, 1 ) & fy2;
-
-        BOOST_TEST( r2.has_error() );
-    }
-
-    {
-        result<void, E2> r2 = result<Y, E>( in_place_value, 1 ) & fy3;
-
-        BOOST_TEST( r2.has_value() );
-    }
-
-    {
-        result<X, E2> r2 = result<Y, E>( in_place_error ) & fy;
-
-        BOOST_TEST( r2.has_error() );
-    }
-
-    {
-        result<X, E2> r2 = result<Y, E>( in_place_error ) & fy2;
-
-        BOOST_TEST( r2.has_error() );
-    }
-
-    {
-        result<void, E2> r2 = result<Y, E>( in_place_error ) & fy3;
-
-        BOOST_TEST( r2.has_error() );
-    }
-
-    {
-        int x1 = 1;
-        result<int&, E> r( x1 );
-
-        {
-            result<int, E2> r2 = r & fri;
-            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 3 );
-        }
-
-        {
-            result<int&, E2> r2 = r & fri2;
-            BOOST_TEST( r2.has_error() );
-        }
-
-        {
-            result<void, E2> r2 = r & fri3;
-            BOOST_TEST( r2.has_value() );
-        }
-    }
-
-    {
-        int x1 = 1;
-        result<int&, E> const r( x1 );
-
-        {
-            result<int, E2> r2 = r & fri;
-            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 3 );
-        }
-
-        {
-            result<int&, E2> r2 = r & fri2;
-            BOOST_TEST( r2.has_error() );
-        }
-
-        {
-            result<void, E2> r2 = r & fri3;
-            BOOST_TEST( r2.has_value() );
-        }
-    }
-
-    {
-        int x1 = 1;
-
-        result<int, E2> r2 = result<int&, E>( x1 ) & fri;
-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 3 );
-    }
-
-    {
-        int x1 = 1;
-
-        result<int&, E2> r2 = result<int&, E>( x1 ) & fri2;
-        BOOST_TEST( r2.has_error() );
-    }
-
-    {
-        int x1 = 1;
-
-        result<void, E2> r2 = result<int&, E>( x1 ) & fri3;
-        BOOST_TEST( r2.has_value() );
-    }
-
-    {
-        result<int&, E> r( in_place_error );
-
-        {
-            result<int, E2> r2 = r & fri;
-            BOOST_TEST( r2.has_error() );
-        }
-
-        {
-            result<int&, E2> r2 = r & fri2;
-            BOOST_TEST( r2.has_error() );
-        }
-
-        {
-            result<void, E2> r2 = r & fri3;
-            BOOST_TEST( r2.has_error() );
-        }
-    }
-
-    {
-        result<int&, E> const r( in_place_error );
-
-        {
-            result<int, E2> r2 = r & fri;
-            BOOST_TEST( r2.has_error() );
-        }
-
-        {
-            result<int&, E2> r2 = r & fri2;
-            BOOST_TEST( r2.has_error() );
-        }
-
-        {
-            result<void, E2> r2 = r & fri3;
-            BOOST_TEST( r2.has_error() );
-        }
-    }
-
-    {
-        result<int, E2> r2 = result<int&, E>( in_place_error ) & fri;
-        BOOST_TEST( r2.has_error() );
-    }
-
-    {
-        result<int&, E2> r2 = result<int&, E>( in_place_error ) & fri2;
-        BOOST_TEST( r2.has_error() );
-    }
-
-    {
-        result<void, E2> r2 = result<int&, E>( in_place_error ) & fri3;
-        BOOST_TEST( r2.has_error() );
-    }
-
-    {
-        result<void, E> r;
-
-        {
-            result<int, E2> r2 = r & fk;
-            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 7 );
-        }
-
-        {
-            result<int, E2> r2 = r & fk2;
-            BOOST_TEST( r2.has_error() );
-        }
-
-        {
-            result<void, E2> r2 = r & fk3;
-            BOOST_TEST( r2.has_value() );
-        }
-
-        {
-            result<void, E2> r2 = r & fk4;
-            BOOST_TEST( r2.has_error() );
-        }
-    }
-
-    {
-        result<void, E> const r;
-
-        {
-            result<int, E2> r2 = r & fk;
-            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 7 );
-        }
-
-        {
-            result<int, E2> r2 = r & fk2;
-            BOOST_TEST( r2.has_error() );
-        }
-
-        {
-            result<void, E2> r2 = r & fk3;
-            BOOST_TEST( r2.has_value() );
-        }
-
-        {
-            result<void, E2> r2 = r & fk4;
-            BOOST_TEST( r2.has_error() );
-        }
-    }
-
-    {
-        result<int, E2> r2 = result<void, E>() & fk;
-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 7 );
-    }
-
-    {
-        result<int, E2> r2 = result<void, E>() & fk2;
-        BOOST_TEST( r2.has_error() );
-    }
-
-    {
-        result<void, E2> r2 = result<void, E>() & fk3;
-        BOOST_TEST( r2.has_value() );
-    }
-
-    {
-        result<void, E2> r2 = result<void, E>() & fk4;
-        BOOST_TEST( r2.has_error() );
-    }
-
-    {
-        result<void, E> r( in_place_error );
-
-        {
-            result<int, E2> r2 = r & fk;
-            BOOST_TEST( r2.has_error() );
-        }
-
-        {
-            result<int, E2> r2 = r & fk2;
-            BOOST_TEST( r2.has_error() );
-        }
-
-        {
-            result<void, E2> r2 = r & fk3;
-            BOOST_TEST( r2.has_error() );
-        }
-
-        {
-            result<void, E2> r2 = r & fk4;
-            BOOST_TEST( r2.has_error() );
-        }
-    }
-
-    {
-        result<void, E> const r( in_place_error );
-
-        {
-            result<int, E2> r2 = r & fk;
-            BOOST_TEST( r2.has_error() );
-        }
-
-        {
-            result<int, E2> r2 = r & fk2;
-            BOOST_TEST( r2.has_error() );
-        }
-
-        {
-            result<void, E2> r2 = r & fk3;
-            BOOST_TEST( r2.has_error() );
-        }
-
-        {
-            result<void, E2> r2 = r & fk4;
-            BOOST_TEST( r2.has_error() );
-        }
-    }
-
-    {
-        result<int, E2> r2 = result<void, E>( in_place_error ) & fk;
-        BOOST_TEST( r2.has_error() );
-    }
-
-    {
-        result<int, E2> r2 = result<void, E>( in_place_error ) & fk2;
-        BOOST_TEST( r2.has_error() );
-    }
-
-    {
-        result<void, E2> r2 = result<void, E>( in_place_error ) & fk3;
-        BOOST_TEST( r2.has_error() );
-    }
-
-    {
-        result<void, E2> r2 = result<void, E>( in_place_error ) & fk4;
-        BOOST_TEST( r2.has_error() );
-    }
-
-    return boost::report_errors();
-}
@@ -1,331 +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>
-#include <boost/core/lightweight_test.hpp>
-
-using namespace boost::system;
-
-struct X
-{
-    int v_;
-};
-
-struct Y
-{
-    int v_;
-
-    explicit Y( int v ): v_( v ) {}
-    Y( X x ): v_( x.v_) {}
-
-    Y( Y const& ) = delete;
-    Y& operator=( Y const& ) = delete;
-
-    Y( Y&& r ): v_( r.v_ )
-    {
-        r.v_ = 0;
-    }
-
-    Y& operator=( Y&& ) = delete;
-};
-
-struct E
-{
-};
-
-int f( int x )
-{
-    return x * 2 + 1;
-}
-
-X g( Y y )
-{
-    return X{ y.v_ * 2 + 1 };
-}
-
-int& h( int& )
-{
-    static int x = 2;
-    return x;
-}
-
-int k()
-{
-    return 7;
-}
-
-static int fv1_called_with;
-
-void fv1( int x )
-{
-    fv1_called_with = x;
-}
-
-static int fv2_called;
-
-void fv2()
-{
-    ++fv2_called;
-}
-
-int main()
-{
-    {
-        result<int> r( 1 );
-        result<int> r2 = r & f;
-
-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 3 );
-    }
-
-    {
-        result<int> const r( 1 );
-        result<int> r2 = r & f;
-
-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 3 );
-    }
-
-    {
-        result<int> r2 = result<int>( 1 ) & f;
-
-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 3 );
-    }
-
-    {
-        result<int, E> r( in_place_error );
-        result<int, E> r2 = r & f;
-
-        BOOST_TEST( r2.has_error() );
-    }
-
-    {
-        result<int, E> const r( in_place_error );
-        result<int, E> r2 = r & f;
-
-        BOOST_TEST( r2.has_error() );
-    }
-
-    {
-        result<int, E> r2 = result<int, E>( in_place_error ) & f;
-
-        BOOST_TEST( r2.has_error() );
-    }
-
-    {
-        result<X> r2 = result<Y>( in_place_value, 1 ) & g;
-
-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2->v_, 3 );
-    }
-
-    {
-        result<X, E> r2 = result<Y, E>( in_place_error ) & g;
-
-        BOOST_TEST( r2.has_error() );
-    }
-
-    {
-        int x1 = 1;
-
-        result<int&> r( x1 );
-
-        result<int&> r2 = r & h;
-
-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &*r2, &h( x1 ) );
-    }
-
-    {
-        int x1 = 1;
-
-        result<int&> const r( x1 );
-
-        result<int&> r2 = r & h;
-
-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &*r2, &h( x1 ) );
-    }
-
-    {
-        int x1 = 1;
-
-        result<int&> r2 = result<int&>( x1 ) & h;
-
-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &*r2, &h( x1 ) );
-    }
-
-    {
-        result<int&, E> r( in_place_error );
-
-        result<int&, E> r2 = r & h;
-
-        BOOST_TEST( r2.has_error() );
-    }
-
-    {
-        result<int&, E> const r( in_place_error );
-
-        result<int&, E> r2 = r & h;
-
-        BOOST_TEST( r2.has_error() );
-    }
-
-    {
-        result<int&, E> r2 = result<int&, E>( in_place_error ) & h;
-
-        BOOST_TEST( r2.has_error() );
-    }
-
-    {
-        result<void> r;
-        result<int> r2 = r & k;
-
-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 7 );
-    }
-
-    {
-        result<void> const r;
-        result<int> r2 = r & k;
-
-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 7 );
-    }
-
-    {
-        result<int> r2 = result<void>() & k;
-
-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 7 );
-    }
-
-    {
-        result<void, E> r( in_place_error );
-        result<int, E> r2 = r & k;
-
-        BOOST_TEST( r2.has_error() );
-    }
-
-    {
-        result<void, E> const r( in_place_error );
-        result<int, E> r2 = r & k;
-
-        BOOST_TEST( r2.has_error() );
-    }
-
-    {
-        result<int, E> r2 = result<void, E>( in_place_error ) & k;
-
-        BOOST_TEST( r2.has_error() );
-    }
-
-    {
-        fv1_called_with = 0;
-
-        result<int> r( 1 );
-        result<void> r2 = r & fv1;
-
-        BOOST_TEST( r2.has_value() );
-        BOOST_TEST_EQ( fv1_called_with, 1 );
-    }
-
-    {
-        result<int> const r( 1 );
-        result<void> r2 = r & fv1;
-
-        BOOST_TEST( r2.has_value() );
-        BOOST_TEST_EQ( fv1_called_with, 1 );
-    }
-
-    {
-        fv1_called_with = 0;
-
-        result<void> r2 = result<int>( 1 ) & fv1;
-
-        BOOST_TEST( r2.has_value() );
-        BOOST_TEST_EQ( fv1_called_with, 1 );
-    }
-
-    {
-        fv1_called_with = 0;
-
-        result<int, E> r( in_place_error );
-        result<void, E> r2 = r & fv1;
-
-        BOOST_TEST( r2.has_error() );
-        BOOST_TEST_EQ( fv1_called_with, 0 );
-    }
-
-    {
-        fv1_called_with = 0;
-
-        result<int, E> const r( in_place_error );
-        result<void, E> r2 = r & fv1;
-
-        BOOST_TEST( r2.has_error() );
-        BOOST_TEST_EQ( fv1_called_with, 0 );
-    }
-
-    {
-        fv1_called_with = 0;
-
-        result<void, E> r2 = result<int, E>( in_place_error ) & fv1;
-
-        BOOST_TEST( r2.has_error() );
-        BOOST_TEST_EQ( fv1_called_with, 0 );
-    }
-
-    {
-        result<void> r;
-        fv2_called = 0;
-
-        result<void> r2 = r & fv2;
-
-        BOOST_TEST( r2.has_value() );
-        BOOST_TEST_EQ( fv2_called, 1 );
-    }
-
-    {
-        result<void> const r;
-        fv2_called = 0;
-
-        result<void> r2 = r & fv2;
-
-        BOOST_TEST( r2.has_value() );
-        BOOST_TEST_EQ( fv2_called, 1 );
-    }
-
-    {
-        fv2_called = 0;
-
-        result<void> r2 = result<void>() & fv2;
-
-        BOOST_TEST( r2.has_value() );
-        BOOST_TEST_EQ( fv2_called, 1 );
-    }
-
-    {
-        result<void, E> r( in_place_error );
-        fv2_called = 0;
-
-        result<void, E> r2 = r & fv2;
-
-        BOOST_TEST( r2.has_error() );
-        BOOST_TEST_EQ( fv2_called, 0 );
-    }
-
-    {
-        result<void, E> const r( in_place_error );
-        fv2_called = 0;
-
-        result<void, E> r2 = r & fv2;
-
-        BOOST_TEST( r2.has_error() );
-        BOOST_TEST_EQ( fv2_called, 0 );
-    }
-
-    {
-        fv2_called = 0;
-
-        result<void, E> r2 = result<void, E>( in_place_error ) & fv2;
-
-        BOOST_TEST( r2.has_error() );
-        BOOST_TEST_EQ( fv2_called, 0 );
-    }
-
-    return boost::report_errors();
-}
@@ -1,230 +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>
-#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();
-}
@@ -1,254 +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>
-#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();
-}
@@ -181,95 +181,6 @@ int main()

    BOOST_TEST_EQ( X::instances, 0 );

-    //
-
-    {
-        result<void, int> r;
-        result<void, X> r2 = r;
-
-        BOOST_TEST( r2 );
-        BOOST_TEST_EQ( X::instances, 0 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        result<void, int> const r;
-        result<void, X> r2 = r;
-
-        BOOST_TEST( r2 );
-        BOOST_TEST_EQ( X::instances, 0 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        result<void, X> r2 = result<void, int>();
-
-        BOOST_TEST( r2 );
-        BOOST_TEST_EQ( X::instances, 0 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        result<void, int> r( 5 );
-        result<void, X> r2 = r;
-
-        BOOST_TEST( !r2 );
-        BOOST_TEST_EQ( r2.error(), X(5) );
-        BOOST_TEST_EQ( X::instances, 1 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        result<void, int> const r( 6 );
-        result<void, X> r2 = r;
-
-        BOOST_TEST( !r2 );
-        BOOST_TEST_EQ( r2.error(), X(6) );
-        BOOST_TEST_EQ( X::instances, 1 );
-    }
-
-    {
-        result<void, X> r2 = result<void, int>( 7 );
-
-        BOOST_TEST( !r2 );
-        BOOST_TEST_EQ( r2.error(), X(7) );
-        BOOST_TEST_EQ( X::instances, 1 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    //
-
-    {
-        int x = 5;
-
-        result<int&> r( x );
-        result<int const&> r2 = r;
-
-        BOOST_TEST( r2 ) && BOOST_TEST_EQ( *r2, 5 );
-    }
-
-    {
-        int x = 6;
-
-        result<int&> const r( x );
-        result<int const&> r2 = r;
-
-        BOOST_TEST( r2 ) && BOOST_TEST_EQ( *r2, 6 );
-    }
-
-    {
-        int x = 7;
-
-        result<int const&> r2 = result<int&>( x );
-
-        BOOST_TEST( r2 ) && BOOST_TEST_EQ( *r2, 7 );
-    }
-
    {
        BOOST_TEST_TRAIT_TRUE((std::is_constructible<result<long>, result<int>>));
        BOOST_TEST_TRAIT_TRUE((std::is_convertible<result<int>, result<long>>));
@@ -285,21 +196,6 @@ int main()

        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int, void*>, result<int, int>>));
        BOOST_TEST_TRAIT_FALSE((std::is_convertible<result<int, int>, result<int, void*>>));
-
-        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<void, void*>, result<void, int>>));
-        BOOST_TEST_TRAIT_FALSE((std::is_convertible<result<void, int>, result<void, void*>>));
-
-        BOOST_TEST_TRAIT_TRUE((std::is_constructible<result<int const&>, result<int&>>));
-        BOOST_TEST_TRAIT_TRUE((std::is_convertible<result<int&>, result<int const&>>));
-
-        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int const&>, result<int>>));
-        BOOST_TEST_TRAIT_FALSE((std::is_convertible<result<int>, result<int const&>>));
-
-        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int const&>, result<long&>>));
-        BOOST_TEST_TRAIT_FALSE((std::is_convertible<result<long&>, result<int const&>>));
-
-        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int const&>, result<long const&>>));
-        BOOST_TEST_TRAIT_FALSE((std::is_convertible<result<long const&>, result<int const&>>));
    }

    return boost::report_errors();
@@ -682,151 +682,5 @@ int main()
        BOOST_TEST_EQ( r, r2 );
    }

-    // reference
-
-    {
-        int x1 = 1;
-        int x2 = 2;
-
-        result<int&> r1( x1 );
-        result<int&> r2( x2 );
-
-        r2 = r1;
-
-        BOOST_TEST_EQ( x1, 1 );
-        BOOST_TEST_EQ( x2, 2 );
-
-        BOOST_TEST_EQ( r1, r2 );
-        BOOST_TEST_EQ( &*r1, &*r2 );
-    }
-
-    {
-        int const x1 = 1;
-        int const x2 = 2;
-
-        result<int const&> r1( x1 );
-        result<int const&> r2( x2 );
-
-        r2 = r1;
-
-        BOOST_TEST_EQ( x1, 1 );
-        BOOST_TEST_EQ( x2, 2 );
-
-        BOOST_TEST_EQ( r1, r2 );
-        BOOST_TEST_EQ( &*r1, &*r2 );
-    }
-
-    {
-        int x1 = 1;
-
-        result<int&> r1( x1 );
-        result<int&> r2( ENOENT, generic_category() );
-
-        r2 = r1;
-
-        BOOST_TEST_EQ( x1, 1 );
-
-        BOOST_TEST_EQ( r1, r2 );
-        BOOST_TEST_EQ( &*r1, &*r2 );
-    }
-
-    {
-        int x1 = 1;
-        int x2 = 2;
-
-        result<int&> const r1( x1 );
-        result<int&> r2( x2 );
-
-        r2 = r1;
-
-        BOOST_TEST_EQ( x1, 1 );
-        BOOST_TEST_EQ( x2, 2 );
-
-        BOOST_TEST_EQ( r1, r2 );
-        BOOST_TEST_EQ( &*r1, &*r2 );
-    }
-
-    {
-        int const x1 = 1;
-        int const x2 = 2;
-
-        result<int const &> const r1( x1 );
-        result<int const &> r2( x2 );
-
-        r2 = r1;
-
-        BOOST_TEST_EQ( x1, 1 );
-        BOOST_TEST_EQ( x2, 2 );
-
-        BOOST_TEST_EQ( r1, r2 );
-        BOOST_TEST_EQ( &*r1, &*r2 );
-    }
-
-    {
-        int x1 = 1;
-
-        result<int&> const r1( x1 );
-        result<int&> r2( ENOENT, generic_category() );
-
-        r2 = r1;
-
-        BOOST_TEST_EQ( x1, 1 );
-
-        BOOST_TEST_EQ( r1, r2 );
-        BOOST_TEST_EQ( &*r1, &*r2 );
-    }
-
-    {
-        int x2 = 2;
-
-        auto ec = make_error_code( errc::invalid_argument );
-
-        result<int&> r1( ec );
-        result<int&> r2( x2 );
-
-        r2 = r1;
-
-        BOOST_TEST_EQ( x2, 2 );
-
-        BOOST_TEST_EQ( r1, r2 );
-    }
-
-    {
-        auto ec = make_error_code( errc::invalid_argument );
-
-        result<int&> r1( ec );
-        result<int&> r2( ENOENT, generic_category() );
-
-        r2 = r1;
-
-        BOOST_TEST_EQ( r1, r2 );
-    }
-
-    {
-        int x2 = 2;
-
-        auto ec = make_error_code( errc::invalid_argument );
-
-        result<int&> const r1( ec );
-        result<int&> r2( x2 );
-
-        r2 = r1;
-
-        BOOST_TEST_EQ( x2, 2 );
-
-        BOOST_TEST_EQ( r1, r2 );
-    }
-
-    {
-        auto ec = make_error_code( errc::invalid_argument );
-
-        result<int&> const r1( ec );
-        result<int&> r2( ENOENT, generic_category() );
-
-        r2 = r1;
-
-        BOOST_TEST_EQ( r1, r2 );
-    }
-
    return boost::report_errors();
 }
@@ -145,8 +145,6 @@ int main()

    BOOST_TEST_EQ( X::instances, 0 );

-    //
-
    {
        result<void> r;
        result<void> r2( r );
@@ -179,121 +177,5 @@ int main()
        BOOST_TEST_EQ( r, r2 );
    }

-    //
-
-    {
-        int x1 = 1;
-
-        result<int&> r1( x1 );
-        result<int&> r2( r1 );
-
-        BOOST_TEST_EQ( r1, r2 );
-        BOOST_TEST_EQ( &*r2, &x1 );
-    }
-
-    {
-        int x1 = 1;
-
-        result<int&> const r1( x1 );
-        result<int&> r2( r1 );
-
-        BOOST_TEST_EQ( r1, r2 );
-        BOOST_TEST_EQ( &*r2, &x1 );
-    }
-
-    {
-        int const x1 = 1;
-
-        result<int const&> r1( x1 );
-        result<int const&> r2( r1 );
-
-        BOOST_TEST_EQ( r1, r2 );
-        BOOST_TEST_EQ( &*r2, &x1 );
-    }
-
-    {
-        int const x1 = 1;
-
-        result<int const&> const r1( x1 );
-        result<int const&> r2( r1 );
-
-        BOOST_TEST_EQ( r1, r2 );
-        BOOST_TEST_EQ( &*r2, &x1 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        X x1( 1 );
-
-        result<X&> r1( x1 );
-        result<X&> r2( r1 );
-
-        BOOST_TEST_EQ( r1, r2 );
-        BOOST_TEST_EQ( &*r2, &x1 );
-        BOOST_TEST_EQ( X::instances, 1 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        X x1( 1 );
-
-        result<X&> const r1( x1 );
-        result<X&> r2( r1 );
-
-        BOOST_TEST_EQ( r1, r2 );
-        BOOST_TEST_EQ( &*r2, &x1 );
-        BOOST_TEST_EQ( X::instances, 1 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        X const x1( 1 );
-
-        result<X const&> r1( x1 );
-        result<X const&> r2( r1 );
-
-        BOOST_TEST_EQ( r1, r2 );
-        BOOST_TEST_EQ( &*r2, &x1 );
-        BOOST_TEST_EQ( X::instances, 1 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        X const x1( 1 );
-
-        result<X const&> const r1( x1 );
-        result<X const&> r2( r1 );
-
-        BOOST_TEST_EQ( r1, r2 );
-        BOOST_TEST_EQ( &*r2, &x1 );
-        BOOST_TEST_EQ( X::instances, 1 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        auto ec = make_error_code( errc::invalid_argument );
-
-        result<int&> r1( ec );
-        result<int&> r2( r1 );
-
-        BOOST_TEST_EQ( r1, r2 );
-    }
-
-    {
-        auto ec = make_error_code( errc::invalid_argument );
-
-        result<int&> const r1( ec );
-        result<int&> r2( r1 );
-
-        BOOST_TEST_EQ( r1, r2 );
-    }
-
-    //
-
    return boost::report_errors();
 }
@@ -12,11 +12,6 @@ struct X
 {
 };

-struct Y
-{
-    Y( int );
-};
-
 int main()
 {
    {
@@ -28,24 +23,6 @@ int main()
        BOOST_TEST_EQ( r.value(), 0 );
    }

-    {
-        result<int> r{};
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST( !r.has_error() );
-
-        BOOST_TEST_EQ( r.value(), 0 );
-    }
-
-    {
-        result<int> r = {};
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST( !r.has_error() );
-
-        BOOST_TEST_EQ( r.value(), 0 );
-    }
-
    {
        result<X> r;

@@ -53,20 +30,6 @@ int main()
        BOOST_TEST( !r.has_error() );
    }

-    {
-        result<X> r{};
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST( !r.has_error() );
-    }
-
-    {
-        result<X> r = {};
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST( !r.has_error() );
-    }
-
    {
        result<void> r;

@@ -74,34 +37,5 @@ int main()
        BOOST_TEST( !r.has_error() );
    }

-    {
-        result<void> r{};
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST( !r.has_error() );
-    }
-
-    {
-        result<void> r = {};
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST( !r.has_error() );
-    }
-
-    {
-        BOOST_TEST_TRAIT_TRUE((std::is_default_constructible<result<int>>));
-        BOOST_TEST_TRAIT_TRUE((std::is_default_constructible<result<int, int>>));
-        BOOST_TEST_TRAIT_TRUE((std::is_default_constructible<result<X>>));
-        BOOST_TEST_TRAIT_TRUE((std::is_default_constructible<result<X, int>>));
-        BOOST_TEST_TRAIT_TRUE((std::is_default_constructible<result<void>>));
-        BOOST_TEST_TRAIT_TRUE((std::is_default_constructible<result<void, int>>));
-
-        BOOST_TEST_TRAIT_FALSE((std::is_default_constructible<result<Y>>));
-        BOOST_TEST_TRAIT_FALSE((std::is_default_constructible<result<Y, int>>));
-
-        BOOST_TEST_TRAIT_FALSE((std::is_default_constructible<result<int&>>));
-        BOOST_TEST_TRAIT_FALSE((std::is_default_constructible<result<int&, int>>));
-    }
-
    return boost::report_errors();
 }
@@ -1,218 +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>
-#include <boost/core/lightweight_test.hpp>
-#include <cerrno>
-
-using namespace boost::system;
-
-struct X
-{
-    static int instances;
-
-    int v_;
-
-    explicit X( int v ): v_( v ) { ++instances; }
-
-    X( int v1, int v2 ): v_( v1+v2 ) { ++instances; }
-    X( int v1, int v2, int v3 ): v_( v1+v2+v3 ) { ++instances; }
-
-    X( X const& ) = delete;
-    X& operator=( X const& ) = delete;
-
-    ~X() { --instances; }
-};
-
-int X::instances = 0;
-
-struct Y
-{
-    static int instances;
-
-    Y() noexcept { ++instances; }
-
-    Y( Y const& ) noexcept { ++instances; }
-
-    Y& operator=( Y const& ) = default;
-
-    ~Y() { --instances; }
-};
-
-int Y::instances = 0;
-
-int main()
-{
-    {
-        result<int> r;
-
-        BOOST_TEST( r.has_value() );
-
-        r.emplace( 1 );
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST_EQ( r.value(), 1 );
-    }
-
-    {
-        result<int> r( ENOENT, generic_category() );
-
-        BOOST_TEST( !r.has_value() );
-
-        r.emplace( 1 );
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST_EQ( r.value(), 1 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        result<X> r( 0 );
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST_EQ( r.value().v_, 0 );
-        BOOST_TEST_EQ( X::instances, 1 );
-
-        r.emplace( 1 );
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST_EQ( r.value().v_, 1 );
-        BOOST_TEST_EQ( X::instances, 1 );
-
-        r.emplace( 1, 2 );
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST_EQ( r.value().v_, 1+2 );
-        BOOST_TEST_EQ( X::instances, 1 );
-
-        r.emplace( 1, 2, 3 );
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST_EQ( r.value().v_, 1+2+3 );
-        BOOST_TEST_EQ( X::instances, 1 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        result<X> r( ENOENT, generic_category() );
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST_EQ( X::instances, 0 );
-
-        r.emplace( 1, 2 );
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST_EQ( r.value().v_, 1+2 );
-        BOOST_TEST_EQ( X::instances, 1 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-    BOOST_TEST_EQ( Y::instances, 0 );
-
-    {
-        result<int, Y> r( Y{} );
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST_EQ( Y::instances, 1 );
-
-        r.emplace( 1 );
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST_EQ( *r, 1 );
-        BOOST_TEST_EQ( Y::instances, 0 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-    BOOST_TEST_EQ( Y::instances, 0 );
-
-    {
-        result<X, Y> r( in_place_error );
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST_EQ( X::instances, 0 );
-        BOOST_TEST_EQ( Y::instances, 1 );
-
-        r.emplace( 1, 2, 3 );
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST_EQ( r->v_, 1+2+3 );
-        BOOST_TEST_EQ( X::instances, 1 );
-        BOOST_TEST_EQ( Y::instances, 0 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-    BOOST_TEST_EQ( Y::instances, 0 );
-
-    {
-        result<void> r;
-
-        BOOST_TEST( r.has_value() );
-
-        r.emplace();
-        BOOST_TEST( r.has_value() );
-    }
-
-    {
-        result<void> r( ENOENT, generic_category() );
-
-        BOOST_TEST( !r.has_value() );
-
-        r.emplace();
-        BOOST_TEST( r.has_value() );
-    }
-
-    BOOST_TEST_EQ( Y::instances, 0 );
-
-    {
-        result<void, Y> r( in_place_error );
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST_EQ( Y::instances, 1 );
-
-        r.emplace();
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST_EQ( Y::instances, 0 );
-    }
-
-    {
-        int x1 = 1;
-        result<int&> r( x1 );
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST_EQ( r.value(), 1 );
-
-        int x2 = 2;
-        r.emplace( x2 );
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST_EQ( r.value(), 2 );
-    }
-
-    {
-        result<int&> r( ENOENT, generic_category() );
-
-        BOOST_TEST( !r.has_value() );
-
-        int x2 = 2;
-        r.emplace( x2 );
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST_EQ( r.value(), 2 );
-    }
-
-    BOOST_TEST_EQ( Y::instances, 0 );
-
-    {
-        result<int&, Y> r( in_place_error );
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST_EQ( Y::instances, 1 );
-
-        int x2 = 2;
-        r.emplace( x2 );
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST_EQ( *r, 2 );
-        BOOST_TEST_EQ( Y::instances, 0 );
-    }
-
-    return boost::report_errors();
-}
@@ -149,83 +149,5 @@ int main()
        BOOST_TEST_NE( r1, r2 );
    }

-    {
-        int x1 = 1;
-        int x2 = 2;
-
-        result<int&> r1( x1 );
-        result<int&> r2( x2 );
-
-        BOOST_TEST_EQ( r1, r1 );
-        BOOST_TEST_NE( r1, r2 );
-    }
-
-    {
-        int x1 = 1;
-        int x2 = 1;
-
-        result<int&> r1( x1 );
-        result<int&> r2( x2 );
-
-        BOOST_TEST_EQ( r1, r2 );
-    }
-
-    {
-        result<int&> r1( 1, generic_category() );
-        result<int&> r2( 2, generic_category() );
-
-        BOOST_TEST_EQ( r1, r1 );
-        BOOST_TEST_NE( r1, r2 );
-    }
-
-    {
-        int x1 = 1;
-
-        result<int&> r1( x1 );
-        result<int&> r2( 2, generic_category() );
-
-        BOOST_TEST_EQ( r1, r1 );
-        BOOST_TEST_NE( r1, r2 );
-    }
-
-    {
-        X x1( 1 );
-        X x2( 2 );
-
-        result<X&, Y> r1( x1 );
-        result<X&, Y> r2( x2 );
-
-        BOOST_TEST_EQ( r1, r1 );
-        BOOST_TEST_NE( r1, r2 );
-    }
-
-    {
-        X x1( 1 );
-        X x2( 1 );
-
-        result<X&, Y> r1( x1 );
-        result<X&, Y> r2( x2 );
-
-        BOOST_TEST_EQ( r1, r2 );
-    }
-
-    {
-        result<X&, Y> r1( in_place_error, 1 );
-        result<X&, Y> r2( in_place_error, 2 );
-
-        BOOST_TEST_EQ( r1, r1 );
-        BOOST_TEST_NE( r1, r2 );
-    }
-
-    {
-        X x1( 1 );
-
-        result<X&, Y> r1( x1 );
-        result<X&, Y> r2( in_place_error, 2 );
-
-        BOOST_TEST_EQ( r1, r1 );
-        BOOST_TEST_NE( r1, r2 );
-    }
-
    return boost::report_errors();
 }
@@ -19,14 +19,5 @@ int main()
    BOOST_TEST_TRAIT_FALSE((std::is_convertible<errc::errc_t, result<bool>>));
    BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<bool>, errc::errc_t>));

-    BOOST_TEST_TRAIT_FALSE((std::is_convertible<errc::errc_t, result<int const&>>));
-    BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int const&>, errc::errc_t>));
-
-    BOOST_TEST_TRAIT_FALSE((std::is_convertible<errc::errc_t, result<double const&>>));
-    BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<double const&>, errc::errc_t>));
-
-    BOOST_TEST_TRAIT_FALSE((std::is_convertible<errc::errc_t, result<bool const&>>));
-    BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<bool const&>, errc::errc_t>));
-
    return boost::report_errors();
 }
@@ -152,8 +152,6 @@ int main()
        BOOST_TEST_EQ( (result<std::string, X>( "s" ).error().v_), 0 );
    }

-    //
-
    {
        result<void> r;

@@ -210,71 +208,5 @@ int main()
        BOOST_TEST_EQ( result<void>( ec ).error(), ec );
    }

-    //
-
-    {
-        int x1 = 1;
-
-        result<int&> r( x1 );
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST( !r.has_error() );
-
-        BOOST_TEST_EQ( r.error(), error_code() );
-    }
-
-    {
-        int x1 = 1;
-
-        result<int&> const r( x1 );
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST( !r.has_error() );
-
-        BOOST_TEST_EQ( r.error(), error_code() );
-    }
-
-    {
-        int x1 = 1;
-
-        BOOST_TEST( result<int&>( x1 ).has_value() );
-        BOOST_TEST( !result<int&>( x1 ).has_error() );
-
-        BOOST_TEST_EQ( result<int&>( x1 ).error(), error_code() );
-    }
-
-    {
-        auto ec = make_error_code( errc::invalid_argument );
-
-        result<int&> r( ec );
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST( r.has_error() );
-
-        BOOST_TEST_EQ( r.error(), ec );
-    }
-
-    {
-        auto ec = make_error_code( errc::invalid_argument );
-
-        result<int&> const r( ec );
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST( r.has_error() );
-
-        BOOST_TEST_EQ( r.error(), ec );
-    }
-
-    {
-        auto ec = make_error_code( errc::invalid_argument );
-
-        BOOST_TEST( !result<int&>( ec ).has_value() );
-        BOOST_TEST( result<int&>( ec ).has_error() );
-
-        BOOST_TEST_EQ( result<int&>( ec ).error(), ec );
-    }
-
-    //
-
    return boost::report_errors();
 }
@@ -146,14 +146,8 @@ int main()
        BOOST_TEST_TRAIT_TRUE((std::is_constructible<result<std::string, X>, int>));
        BOOST_TEST_TRAIT_FALSE((std::is_convertible<int, result<std::string, X>>));

-        // We'd like this to be false due to the ambiguity caused by X having
-        // an explicit constructor taking an int, which should be viable in this
-        // context, but the implicit constructor is enabled, and there's no way to
-        // disallow it
-        //
-        // BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int, X>, int>));
-
-        BOOST_TEST_TRAIT_TRUE((std::is_convertible<int, result<int, X>>));
+        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int, X>, int>));
+        BOOST_TEST_TRAIT_FALSE((std::is_convertible<int, result<int, X>>));
    }

    {
@@ -1,183 +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>
-#include <boost/core/lightweight_test.hpp>
-#include <string>
-#include <cerrno>
-
-using namespace boost::system;
-
-struct X
-{
-    static int instances;
-
-    int v_;
-
-    X(): v_() { ++instances; }
-
-    explicit X( int v ): v_( v ) { ++instances; }
-
-    X( int v1, int v2 ): v_( v1+v2 ) { ++instances; }
-    X( int v1, int v2, int v3 ): v_( v1+v2+v3 ) { ++instances; }
-
-    X( X const& r ): v_( r.v_ ) { ++instances; }
-
-    X& operator=( X const& ) = delete;
-
-    ~X() { --instances; }
-};
-
-int X::instances = 0;
-
-int main()
-{
-    {
-        auto ec = make_error_code( errc::invalid_argument );
-
-        using R = result<int>;
-        R r( R::in_place_error, ec );
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST( r.has_error() );
-
-        BOOST_TEST_EQ( r.error(), ec );
-    }
-
-    {
-        using R = result<int>;
-        R r( R::in_place_error, EINVAL, generic_category() );
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST( r.has_error() );
-
-        BOOST_TEST_EQ( r.error(), error_code( EINVAL, generic_category() ) );
-    }
-
-    {
-        auto ec = make_error_code( errc::invalid_argument );
-
-        using R = result<error_code>;
-        R r( R::in_place_error, ec );
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST( r.has_error() );
-
-        BOOST_TEST_EQ( r.error(), ec );
-    }
-
-    {
-        using R = result<error_code>;
-        R r( R::in_place_error, EINVAL, generic_category() );
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST( r.has_error() );
-
-        BOOST_TEST_EQ( r.error(), error_code( EINVAL, generic_category() ) );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        using R = result<std::string, X>;
-        R r( R::in_place_error, 1 );
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST( r.has_error() );
-
-        BOOST_TEST_EQ( r.error().v_, 1 );
-
-        BOOST_TEST_EQ( X::instances, 1 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        using R = result<int, X>;
-        R r( R::in_place_error, 1, 2 );
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST( r.has_error() );
-
-        BOOST_TEST_EQ( r.error().v_, 1+2 );
-
-        BOOST_TEST_EQ( X::instances, 1 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        using R = result<int, X>;
-        R r( R::in_place_error, 1, 2, 3 );
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST( r.has_error() );
-
-        BOOST_TEST_EQ( r.error().v_, 1+2+3 );
-
-        BOOST_TEST_EQ( X::instances, 1 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        using R = result<X, X>;
-        R r( R::in_place_error, 1 );
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST( r.has_error() );
-
-        BOOST_TEST_EQ( r.error().v_, 1 );
-
-        BOOST_TEST_EQ( X::instances, 1 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        auto ec = make_error_code( errc::invalid_argument );
-
-        using R = result<void>;
-        R r( R::in_place_error, ec );
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST( r.has_error() );
-
-        BOOST_TEST_EQ( r.error(), ec );
-    }
-
-    {
-        using R = result<void>;
-        R r( R::in_place_error, EINVAL, generic_category() );
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST( r.has_error() );
-
-        BOOST_TEST_EQ( r.error(), error_code( EINVAL, generic_category() ) );
-    }
-
-    {
-        auto ec = make_error_code( errc::invalid_argument );
-
-        using R = result<int&>;
-        R r( R::in_place_error, ec );
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST( r.has_error() );
-
-        BOOST_TEST_EQ( r.error(), ec );
-    }
-
-    {
-        using R = result<int&>;
-        R r( R::in_place_error, EINVAL, generic_category() );
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST( r.has_error() );
-
-        BOOST_TEST_EQ( r.error(), error_code( EINVAL, generic_category() ) );
-    }
-
-    return boost::report_errors();
-}
@@ -1,45 +0,0 @@
-// Copyright 2023 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;
-
-// Eigen::Matrix4d has an explicit templated constructor
-// https://github.com/boostorg/system/issues/103
-// https://github.com/boostorg/json/issues/843
-
-struct X
-{
-    X() {}
-    template<class T> explicit X( T const& ) {}
-};
-
-int main()
-{
-    {
-        auto ec = make_error_code( errc::invalid_argument );
-
-        result<X> r = ec;
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST( r.has_error() );
-
-        BOOST_TEST_EQ( r.error(), ec );
-    }
-
-    {
-        auto ec = make_error_code( std::errc::invalid_argument );
-
-        result<X> r = ec;
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST( r.has_error() );
-
-        BOOST_TEST_EQ( r.error(), ec );
-    }
-
-    return boost::report_errors();
-}
@@ -1,160 +0,0 @@
-// Copyright 2017, 2021 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/core/lightweight_test_trait.hpp>
-#include <string>
-#include <cerrno>
-
-using namespace boost::system;
-
-struct X
-{
-    static int instances;
-
-    int v_;
-
-    X(): v_() { ++instances; }
-
-    explicit X( int v ): v_( v ) { ++instances; }
-
-    X( int v1, int v2 ): v_( v1+v2 ) { ++instances; }
-    X( int v1, int v2, int v3 ): v_( v1+v2+v3 ) { ++instances; }
-
-    X( X const& r ): v_( r.v_ ) { ++instances; }
-
-    X& operator=( X const& ) = delete;
-
-    ~X() { --instances; }
-};
-
-int X::instances = 0;
-
-int main()
-{
-    {
-        auto ec = make_error_code( errc::invalid_argument );
-
-        result<int&> r( ec );
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST( r.has_error() );
-
-        BOOST_TEST_EQ( r.error(), ec );
-    }
-
-    {
-        auto ec = make_error_code( errc::invalid_argument );
-
-        result<int&> r = ec;
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST( r.has_error() );
-
-        BOOST_TEST_EQ( r.error(), ec );
-    }
-
-    {
-        result<int&> r( EINVAL, generic_category() );
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST( r.has_error() );
-
-        BOOST_TEST_EQ( r.error(), error_code( EINVAL, generic_category() ) );
-    }
-
-    {
-        auto ec = make_error_code( errc::invalid_argument );
-
-        result<error_code&> r( in_place_error, ec );
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST( r.has_error() );
-
-        BOOST_TEST_EQ( r.error(), ec );
-    }
-
-    {
-        result<error_code&> r( in_place_error, EINVAL, generic_category() );
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST( r.has_error() );
-
-        BOOST_TEST_EQ( r.error(), error_code( EINVAL, generic_category() ) );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        result<std::string&, X> r( 1 );
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST( r.has_error() );
-
-        BOOST_TEST_EQ( r.error().v_, 1 );
-
-        BOOST_TEST_EQ( X::instances, 1 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        result<int&, X> r( 1, 2 );
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST( r.has_error() );
-
-        BOOST_TEST_EQ( r.error().v_, 1+2 );
-
-        BOOST_TEST_EQ( X::instances, 1 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        result<int&, X> r( 1, 2, 3 );
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST( r.has_error() );
-
-        BOOST_TEST_EQ( r.error().v_, 1+2+3 );
-
-        BOOST_TEST_EQ( X::instances, 1 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        result<X&, X> r( in_place_error, 1 );
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST( r.has_error() );
-
-        BOOST_TEST_EQ( r.error().v_, 1 );
-
-        BOOST_TEST_EQ( X::instances, 1 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        BOOST_TEST_TRAIT_TRUE((std::is_constructible<result<int&>, error_code>));
-        BOOST_TEST_TRAIT_TRUE((std::is_convertible<error_code, result<int&>>));
-
-        BOOST_TEST_TRAIT_TRUE((std::is_constructible<result<std::string&, X>, int>));
-        BOOST_TEST_TRAIT_FALSE((std::is_convertible<int, result<std::string&, X>>));
-
-        BOOST_TEST_TRAIT_TRUE((std::is_constructible<result<int&, X>, int>));
-        BOOST_TEST_TRAIT_FALSE((std::is_convertible<int, result<int&, X>>));
-
-        // There's an ambiguity here between int& and X, but since is_convertible
-        // is true, is_constructible can't be false.
-
-        // BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int&, X>, int&>));
-        BOOST_TEST_TRAIT_TRUE((std::is_convertible<int&, result<int&, X>>));
-    }
-
-    return boost::report_errors();
-}
@@ -1,96 +0,0 @@
-// 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
@@ -1,77 +0,0 @@
-// 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
@@ -1,133 +0,0 @@
-// Copyright 2023 Klemens Morgenstern
-// 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 <string>
-
-using namespace boost::system;
-
-struct X
-{
-    int v_;
-
-    explicit X( int v = 0 ): v_( v ) {}
-
-    X( X const& ) = delete;
-    X& operator=( X const& ) = delete;
-
-    X( X && ) = default;
-    X& operator=( X && ) = default;
-};
-
-int main()
-{
-    {
-        result<std::string, X> r( 1 );
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST( r.has_error() );
-
-        BOOST_TEST_EQ( std::move( r ).error().v_, 1 );
-    }
-
-    {
-        BOOST_TEST(( !result<std::string, X>( 1 ).has_value() ));
-        BOOST_TEST(( result<std::string, X>( 1 ).has_error() ));
-
-        BOOST_TEST_EQ( (result<std::string, X>( 1 ).error().v_), 1 );
-    }
-
-    {
-        result<std::string, X> r( "s" );
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST( !r.has_error() );
-
-        BOOST_TEST_EQ( std::move( r ).error().v_, 0 );
-    }
-
-    {
-        BOOST_TEST(( result<std::string, X>( "s" ).has_value() ));
-        BOOST_TEST(( !result<std::string, X>( "s" ).has_error() ));
-
-        BOOST_TEST_EQ( (result<std::string, X>( "s" ).error().v_), 0 );
-    }
-
-    //
-
-    {
-        result<void, X> r( 1 );
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST( r.has_error() );
-
-        BOOST_TEST_EQ( std::move( r ).error().v_, 1 );
-    }
-
-    {
-        BOOST_TEST(( !result<void, X>( 1 ).has_value() ));
-        BOOST_TEST(( result<void, X>( 1 ).has_error() ));
-
-        BOOST_TEST_EQ( (result<void, X>( 1 ).error().v_), 1 );
-    }
-
-    {
-        result<void, X> r;
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST( !r.has_error() );
-
-        BOOST_TEST_EQ( std::move( r ).error().v_, 0 );
-    }
-
-    {
-        BOOST_TEST(( result<void, X>().has_value() ));
-        BOOST_TEST(( !result<void, X>().has_error() ));
-
-        BOOST_TEST_EQ( (result<void, X>().error().v_), 0 );
-    }
-
-    //
-
-    {
-        result<double&, X> r( 1 );
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST( r.has_error() );
-
-        BOOST_TEST_EQ( std::move( r ).error().v_, 1 );
-    }
-
-    {
-        BOOST_TEST(( !result<double&, X>( 1 ).has_value() ));
-        BOOST_TEST(( result<double&, X>( 1 ).has_error() ));
-
-        BOOST_TEST_EQ( (result<double&, X>( 1 ).error().v_), 1 );
-    }
-
-    {
-        double x = 1.0;
-
-        result<double&, X> r( x );
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST( !r.has_error() );
-
-        BOOST_TEST_EQ( std::move( r ).error().v_, 0 );
-    }
-
-    {
-        double x = 1.0;
-
-        BOOST_TEST(( result<double&, X>( x ).has_value() ));
-        BOOST_TEST(( !result<double&, X>( x ).has_error() ));
-
-        BOOST_TEST_EQ( (result<double&, X>( x ).error().v_), 0 );
-    }
-
-    //
-
-    return boost::report_errors();
-}
@@ -1,22 +0,0 @@
-// Copyright 2023 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>
-
-template<class T, class U> void test( T const& t, U const& u )
-{
-    BOOST_TEST_NE( static_cast<void const*>( &t ), static_cast<void const*>( &u ) );
-}
-
-int main()
-{
-    using namespace boost::system;
-
-    test( result<int>::in_place_value, result<int>::in_place_error );
-    test( result<void>::in_place_value, result<void>::in_place_error );
-    test( result<int&>::in_place_value, result<int&>::in_place_error );
-
-    return boost::report_errors();
-}
@@ -508,8 +508,6 @@ int main()

    BOOST_TEST_EQ( Y::instances, 0 );

-    //
-
    {
        result<void> r;
        result<void> r2;
@@ -602,110 +600,5 @@ int main()
        BOOST_TEST_EQ( r2.error(), ec );
    }

-    //
-
-    {
-        int x1 = 1;
-        int x2 = 2;
-
-        result<int&> r1( x1 );
-        result<int&> r2( x2 );
-
-        r2 = std::move( r1 );
-
-        BOOST_TEST_EQ( x1, 1 );
-        BOOST_TEST_EQ( x2, 2 );
-
-        BOOST_TEST( r2.has_value() );
-        BOOST_TEST( !r2.has_error() );
-
-        BOOST_TEST_EQ( r2.value(), 1 );
-
-        BOOST_TEST_EQ( r1, r2 );
-        BOOST_TEST_EQ( &*r1, &*r2 );
-    }
-
-    {
-        int x1 = 1;
-
-        result<int&> r1( x1 );
-        result<int&> r2( ENOENT, generic_category() );
-
-        r2 = std::move( r1 );
-
-        BOOST_TEST_EQ( x1, 1 );
-
-        BOOST_TEST( r2.has_value() );
-        BOOST_TEST( !r2.has_error() );
-
-        BOOST_TEST_EQ( r2.value(), 1 );
-
-        BOOST_TEST_EQ( r1, r2 );
-    }
-
-    {
-        int x1 = 1;
-
-        auto ec = make_error_code( errc::invalid_argument );
-
-        result<int&> r1( ec );
-        result<int&> r2( x1 );
-
-        r2 = std::move( r1 );
-
-        BOOST_TEST_EQ( x1, 1 );
-
-        BOOST_TEST( !r2.has_value() );
-        BOOST_TEST( r2.has_error() );
-
-        BOOST_TEST_EQ( r2.error(), ec );
-    }
-
-    {
-        int x1 = 1;
-
-        auto ec = make_error_code( errc::invalid_argument );
-
-        result<int&> r2( x1 );
-
-        r2 = result<int&>( ec );
-
-        BOOST_TEST_EQ( x1, 1 );
-
-        BOOST_TEST( !r2.has_value() );
-        BOOST_TEST( r2.has_error() );
-
-        BOOST_TEST_EQ( r2.error(), ec );
-    }
-
-    {
-        auto ec = make_error_code( errc::invalid_argument );
-
-        result<int&> r1( ec );
-        result<int&> r2( ENOENT, generic_category() );
-
-        r2 = std::move( r1 );
-
-        BOOST_TEST( !r2.has_value() );
-        BOOST_TEST( r2.has_error() );
-
-        BOOST_TEST_EQ( r2.error(), ec );
-    }
-
-    {
-        auto ec = make_error_code( errc::invalid_argument );
-
-        result<int&> r2( ENOENT, generic_category() );
-
-        r2 = result<int&>( ec );
-
-        BOOST_TEST( !r2.has_value() );
-        BOOST_TEST( r2.has_error() );
-
-        BOOST_TEST_EQ( r2.error(), ec );
-    }
-
-    //
-
    return boost::report_errors();
 }
@@ -207,8 +207,6 @@ int main()

    BOOST_TEST_EQ( X::instances, 0 );

-    //
-
    {
        result<void> r;
        result<void> r2( std::move( r ) );
@@ -247,149 +245,5 @@ int main()
        BOOST_TEST_EQ( r2.error(), ec );
    }

-    //
-
-    {
-        int x1 = 1;
-
-        result<int&> r1( x1 );
-        result<int&> r2( std::move( r1 ) );
-
-        BOOST_TEST( r1.has_value() );
-        BOOST_TEST( !r1.has_error() );
-
-        BOOST_TEST_EQ( r1.value(), 1 );
-        BOOST_TEST_EQ( &*r1, &x1 );
-
-        BOOST_TEST( r2.has_value() );
-        BOOST_TEST( !r2.has_error() );
-
-        BOOST_TEST_EQ( r2.value(), 1 );
-        BOOST_TEST_EQ( &*r2, &x1 );
-    }
-
-    {
-        int const x1 = 1;
-
-        result<int const&> r1( x1 );
-        result<int const&> r2( std::move( r1 ) );
-
-        BOOST_TEST( r1.has_value() );
-        BOOST_TEST( !r1.has_error() );
-
-        BOOST_TEST_EQ( r1.value(), 1 );
-        BOOST_TEST_EQ( &*r1, &x1 );
-
-        BOOST_TEST( r2.has_value() );
-        BOOST_TEST( !r2.has_error() );
-
-        BOOST_TEST_EQ( r2.value(), 1 );
-        BOOST_TEST_EQ( &*r2, &x1 );
-    }
-
-    {
-        int x1 = 1;
-
-        result<int&> r2(( result<int&>( x1 ) ));
-
-        BOOST_TEST( r2.has_value() );
-        BOOST_TEST( !r2.has_error() );
-
-        BOOST_TEST_EQ( r2.value(), 1 );
-        BOOST_TEST_EQ( &*r2, &x1 );
-    }
-
-    {
-        int const x1 = 1;
-
-        result<int const&> r2(( result<int const&>( x1 ) ));
-
-        BOOST_TEST( r2.has_value() );
-        BOOST_TEST( !r2.has_error() );
-
-        BOOST_TEST_EQ( r2.value(), 1 );
-        BOOST_TEST_EQ( &*r2, &x1 );
-    }
-
-    {
-        X x1( 1 );
-
-        result<X&> r1( x1 );
-        result<X&> r2( std::move( r1 ) );
-
-        BOOST_TEST( r1.has_value() );
-        BOOST_TEST( !r1.has_error() );
-
-        BOOST_TEST_EQ( r1.value().v_, 1 );
-        BOOST_TEST_EQ( &*r1, &x1 );
-
-        BOOST_TEST( r2.has_value() );
-        BOOST_TEST( !r2.has_error() );
-
-        BOOST_TEST_EQ( r2.value().v_, 1 );
-        BOOST_TEST_EQ( &*r2, &x1 );
-
-        BOOST_TEST_EQ( X::instances, 1 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        X x1( 1 );
-
-        result<X&> r2(( result<X&>( x1 ) ));
-
-        BOOST_TEST( r2.has_value() );
-        BOOST_TEST( !r2.has_error() );
-
-        BOOST_TEST_EQ( r2.value().v_, 1 );
-        BOOST_TEST_EQ( &*r2, &x1 );
-
-        BOOST_TEST_EQ( X::instances, 1 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        X const x1( 1 );
-
-        result<X const&> r1( x1 );
-        result<X const&> r2( std::move( r1 ) );
-
-        BOOST_TEST( r1.has_value() );
-        BOOST_TEST( !r1.has_error() );
-
-        BOOST_TEST_EQ( r1.value().v_, 1 );
-        BOOST_TEST_EQ( &*r1, &x1 );
-
-        BOOST_TEST( r2.has_value() );
-        BOOST_TEST( !r2.has_error() );
-
-        BOOST_TEST_EQ( r2.value().v_, 1 );
-        BOOST_TEST_EQ( &*r2, &x1 );
-
-        BOOST_TEST_EQ( X::instances, 1 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        X const x1( 1 );
-
-        result<X const&> r2(( result<X const&>( x1 ) ));
-
-        BOOST_TEST( r2.has_value() );
-        BOOST_TEST( !r2.has_error() );
-
-        BOOST_TEST_EQ( r2.value().v_, 1 );
-        BOOST_TEST_EQ( &*r2, &x1 );
-
-        BOOST_TEST_EQ( X::instances, 1 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    //
-
    return boost::report_errors();
 }
@@ -1,160 +0,0 @@
-// Copyright 2017, 2021-2024 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_;
-};
-
-struct Y
-{
-    int v_;
-
-    explicit Y( int v ): v_( v ) {}
-    Y( X x ): v_( x.v_) {}
-
-    Y( Y const& ) = delete;
-    Y& operator=( Y const& ) = delete;
-
-    Y( Y&& r ): v_( r.v_ )
-    {
-        r.v_ = 0;
-    }
-
-    Y& operator=( Y&& r )
-    {
-        if( &r != this )
-        {
-            v_ = r.v_;
-            r.v_ = 0;
-        }
-
-        return *this;
-    }
-};
-
-struct E
-{
-};
-
-struct E2
-{
-    E2() {}
-    E2( E ) {}
-};
-
-result<int, E> fi()
-{
-    return 2;
-}
-
-result<int, E2> fi2()
-{
-    return E2();
-}
-
-result<X, E> fy()
-{
-    return X{ 2 };
-}
-
-result<Y, E2> fy2()
-{
-    return E2();
-}
-
-result<int&, E> fri()
-{
-    static int x = 2;
-    return x;
-}
-
-result<int&, E2> fri2()
-{
-    return E2();
-}
-
-int main()
-{
-    {
-        result<int, E2> r( 1 );
-
-        r |= fi;
-
-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( *r, 1 );
-
-        r |= fi2;
-
-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( *r, 1 );
-    }
-
-    {
-        result<int, E2> r( in_place_error );
-
-        r |= fi2;
-
-        BOOST_TEST( r.has_error() );
-
-        r |= fi;
-
-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( *r, 2 );
-    }
-
-    {
-        result<Y, E2> r( in_place_value, 1 );
-
-        r |= fy;
-
-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( r->v_, 1 );
-
-        r |= fy2;
-
-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( r->v_, 1 );
-    }
-
-    {
-        result<Y, E2> r( in_place_error );
-
-        r |= fy2;
-
-        BOOST_TEST( r.has_error() );
-
-        r |= fy;
-
-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( r->v_, 2 );
-    }
-
-    {
-        int x1 = 1;
-
-        result<int&, E2> r( x1 );
-
-        r |= fri;
-
-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( &*r, &x1 );
-
-        r |= fri2;
-
-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( &*r, &x1 );
-    }
-
-    {
-        result<int&, E2> r( in_place_error );
-
-        r |= fri2;
-
-        BOOST_TEST( r.has_error() );
-
-        r |= fri;
-
-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( &*r, &*fri() );
-    }
-
-    return boost::report_errors();
-}
@@ -1,115 +0,0 @@
-// Copyright 2017, 2021-2024 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_;
-};
-
-struct Y
-{
-    int v_;
-
-    explicit Y( int v ): v_( v ) {}
-    Y( X x ): v_( x.v_) {}
-
-    Y( Y const& ) = delete;
-    Y& operator=( Y const& ) = delete;
-
-    Y( Y&& r ): v_( r.v_ )
-    {
-        r.v_ = 0;
-    }
-
-    Y& operator=( Y&& r )
-    {
-        if( &r != this )
-        {
-            v_ = r.v_;
-            r.v_ = 0;
-        }
-
-        return *this;
-    }
-};
-
-struct E
-{
-};
-
-int f()
-{
-    return 2;
-}
-
-X g()
-{
-    return { 2 };
-}
-
-int& h()
-{
-    static int x = 2;
-    return x;
-}
-
-int main()
-{
-    {
-        result<int> r( 1 );
-
-        r |= f;
-
-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( *r, 1 );
-    }
-
-    {
-        result<int, E> r( in_place_error );
-
-        r |= f;
-
-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( *r, 2 );
-    }
-
-    {
-        result<Y> r( in_place_value, 1 );
-
-        r |= g;
-
-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( r->v_, 1 );
-    }
-
-    {
-        result<Y, E> r( in_place_error );
-
-        r |= g;
-
-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( r->v_, 2 );
-    }
-
-    {
-        int x1 = 1;
-
-        result<int&> r( x1 );
-
-        r |= h;
-
-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( &*r, &x1 );
-    }
-
-    {
-        result<int&, E> r( in_place_error );
-
-        r |= h;
-
-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( &*r, &h() );
-    }
-
-    return boost::report_errors();
-}
@@ -1,102 +0,0 @@
-// Copyright 2017, 2021-2024 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_;
-};
-
-struct Y
-{
-    int v_;
-
-    explicit Y( int v ): v_( v ) {}
-    Y( X x ): v_( x.v_) {}
-
-    Y( Y const& ) = delete;
-    Y& operator=( Y const& ) = delete;
-
-    Y( Y&& r ): v_( r.v_ )
-    {
-        r.v_ = 0;
-    }
-
-    Y& operator=( Y&& r )
-    {
-        if( &r != this )
-        {
-            v_ = r.v_;
-            r.v_ = 0;
-        }
-
-        return *this;
-    }
-};
-
-struct E
-{
-};
-
-int main()
-{
-    {
-        result<int> r( 1 );
-
-        r |= 2;
-
-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( *r, 1 );
-    }
-
-    {
-        result<int, E> r( in_place_error );
-
-        r |= 2;
-
-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( *r, 2 );
-    }
-
-    {
-        result<Y> r( in_place_value, 1 );
-
-        r |= X{2};
-
-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( r->v_, 1 );
-    }
-
-    {
-        result<Y, E> r( in_place_error );
-
-        r |= X{2};
-
-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( r->v_, 2 );
-    }
-
-    {
-        int x1 = 1;
-        int x2 = 2;
-
-        result<int&> r( x1 );
-
-        r |= x2;
-
-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( &*r, &x1 );
-    }
-
-    {
-        int x2 = 2;
-
-        result<int&, E> r( in_place_error );
-
-        r |= x2;
-
-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( &*r, &x2 );
-    }
-
-    return boost::report_errors();
-}
@@ -1,341 +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>
-#include <boost/core/lightweight_test.hpp>
-
-using namespace boost::system;
-
-struct X
-{
-    int v_;
-};
-
-struct Y
-{
-    int v_;
-
-    explicit Y( int v ): v_( v ) {}
-    Y( X x ): v_( x.v_) {}
-
-    Y( Y const& ) = delete;
-    Y& operator=( Y const& ) = delete;
-
-    Y( Y&& r ): v_( r.v_ )
-    {
-        r.v_ = 0;
-    }
-
-    Y& operator=( Y&& ) = delete;
-};
-
-struct E
-{
-};
-
-result<int, E> fi()
-{
-    return 2;
-}
-
-result<int, E> fi2()
-{
-    return E();
-}
-
-result<Y, E> fy()
-{
-    return Y{ 2 };
-}
-
-result<Y, E> fy2()
-{
-    return E();
-}
-
-result<int&, E> fri()
-{
-    static int x = 2;
-    return x;
-}
-
-result<int&, E> fri2()
-{
-    return E();
-}
-
-result<void, E> fv()
-{
-    return {};
-}
-
-result<void, E> fv2()
-{
-    return E();
-}
-
-int main()
-{
-    {
-        result<int> r( 1 );
-
-        int x = r | fi | 3;
-
-        BOOST_TEST_EQ( x, 1 );
-    }
-
-    {
-        result<int> const r( 1 );
-
-        int x = r | fi | 3;
-
-        BOOST_TEST_EQ( x, 1 );
-    }
-
-    {
-        int x = result<int>( 1 ) | fi | 3;
-
-        BOOST_TEST_EQ( x, 1 );
-    }
-
-    {
-        result<int> r( 1 );
-
-        int x = r | fi2 | 3;
-
-        BOOST_TEST_EQ( x, 1 );
-    }
-
-    {
-        result<int> const r( 1 );
-
-        int x = r | fi2 | 3;
-
-        BOOST_TEST_EQ( x, 1 );
-    }
-
-    {
-        int x = result<int>( 1 ) | fi2 | 3;
-
-        BOOST_TEST_EQ( x, 1 );
-    }
-
-    {
-        result<int> r( in_place_error );
-
-        int x = r | fi | 3;
-
-        BOOST_TEST_EQ( x, 2 );
-    }
-
-    {
-        result<int> const r( in_place_error );
-
-        int x = r | fi | 3;
-
-        BOOST_TEST_EQ( x, 2 );
-    }
-
-    {
-        int x = result<int>( in_place_error ) | fi | 3;
-
-        BOOST_TEST_EQ( x, 2 );
-    }
-
-    {
-        result<int> r( in_place_error );
-
-        int x = r | fi2 | 3;
-
-        BOOST_TEST_EQ( x, 3 );
-    }
-
-    {
-        result<int> const r( in_place_error );
-
-        int x = r | fi2 | 3;
-
-        BOOST_TEST_EQ( x, 3 );
-    }
-
-    {
-        int x = result<int>( in_place_error ) | fi2 | 3;
-
-        BOOST_TEST_EQ( x, 3 );
-    }
-
-    {
-        Y y = result<X>( X{1} ) | fy | X{3};
-
-        BOOST_TEST_EQ( y.v_, 1 );
-    }
-
-    {
-        Y y = result<X>( X{1} ) | fy2 | X{3};
-
-        BOOST_TEST_EQ( y.v_, 1 );
-    }
-
-    {
-        Y y = result<X, E>( in_place_error ) | fy | X{3};
-
-        BOOST_TEST_EQ( y.v_, 2 );
-    }
-
-    {
-        Y y = result<X, E>( in_place_error ) | fy2 | Y{3};
-
-        BOOST_TEST_EQ( y.v_, 3 );
-    }
-
-    {
-        int x1 = 1;
-
-        result<int&> r( x1 );
-
-        auto r2 = r | fri;
-
-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &*r2, &x1 );
-    }
-
-    {
-        int x1 = 1;
-
-        result<int&> const r( x1 );
-
-        auto r2 = r | fri;
-
-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &*r2, &x1 );
-    }
-
-    {
-        int x1 = 1;
-
-        auto r2 = result<int&>( x1 ) | fri;
-
-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &*r2, &x1 );
-    }
-
-    {
-        int x1 = 1;
-
-        result<int&> r( x1 );
-
-        auto r2 = r | fri2;
-
-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &*r2, &x1 );
-    }
-
-    {
-        int x1 = 1;
-
-        result<int&> const r( x1 );
-
-        auto r2 = r | fri2;
-
-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &*r2, &x1 );
-    }
-
-    {
-        int x1 = 1;
-
-        auto r2 = result<int&>( x1 ) | fri2;
-
-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &*r2, &x1 );
-    }
-
-    {
-        result<int&, E> r( in_place_error );
-
-        auto r2 = r | fri;
-
-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &*r2, &*fri() );
-    }
-
-    {
-        result<int&, E> const r( in_place_error );
-
-        auto r2 = r | fri;
-
-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &*r2, &*fri() );
-    }
-
-    {
-        auto r2 = result<int&, E>( in_place_error ) | fri;
-
-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &*r2, &*fri() );
-    }
-
-    {
-        result<int&, E> r( in_place_error );
-
-        auto r2 = r | fri2;
-
-        BOOST_TEST( r2.has_error() );
-    }
-
-    {
-        result<int&, E> const r( in_place_error );
-
-        auto r2 = r | fri2;
-
-        BOOST_TEST( r2.has_error() );
-    }
-
-    {
-        auto r2 = result<int&, E>( in_place_error ) | fri2;
-
-        BOOST_TEST( r2.has_error() );
-    }
-
-    {
-        result<void> r;
-        result<void, E> r2 = r | fv;
-
-        BOOST_TEST( r2.has_value() );
-    }
-
-    {
-        result<void> r;
-        result<void, E> r2 = r | fv2;
-
-        BOOST_TEST( r2.has_value() );
-    }
-
-    {
-        result<void> r( in_place_error );
-        result<void, E> r2 = r | fv;
-
-        BOOST_TEST( r2.has_value() );
-    }
-
-    {
-        result<void> r( in_place_error );
-        result<void, E> r2 = r | fv2;
-
-        BOOST_TEST( r2.has_error() );
-    }
-
-    {
-        result<void, E> r2 = result<void>() | fv;
-        BOOST_TEST( r2.has_value() );
-    }
-
-    {
-        result<void, E> r2 = result<void>() | fv2;
-        BOOST_TEST( r2.has_value() );
-    }
-
-    {
-        result<void, E> r2 = result<void>( in_place_error ) | fv;
-        BOOST_TEST( r2.has_value() );
-    }
-
-    {
-        result<void, E> r2 = result<void>( in_place_error ) | fv2;
-        BOOST_TEST( r2.has_error() );
-    }
-
-    return boost::report_errors();
-}
@@ -1,229 +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>
-#include <boost/core/lightweight_test.hpp>
-#include <boost/core/lightweight_test_trait.hpp>
-#include <type_traits>
-
-using namespace boost::system;
-
-struct X
-{
-    int v_;
-};
-
-struct Y
-{
-    int v_;
-
-    explicit Y( int v ): v_( v ) {}
-    Y( X x ): v_( x.v_) {}
-
-    Y( Y const& ) = delete;
-    Y& operator=( Y const& ) = delete;
-
-    Y( Y&& r ): v_( r.v_ )
-    {
-        r.v_ = 0;
-    }
-
-    Y& operator=( Y&& ) = delete;
-};
-
-struct E
-{
-};
-
-int f()
-{
-    return 2;
-}
-
-X g()
-{
-    return { 2 };
-}
-
-int& h()
-{
-    static int x = 2;
-    return x;
-}
-
-int main()
-{
-    {
-        result<int> r( 1 );
-
-        int x = r | f;
-
-        BOOST_TEST_EQ( x, 1 );
-    }
-
-    {
-        result<int> const r( 1 );
-
-        int x = r | f;
-
-        BOOST_TEST_EQ( x, 1 );
-    }
-
-    {
-        int x = result<int>( 1 ) | f;
-
-        BOOST_TEST_EQ( x, 1 );
-    }
-
-    {
-        result<int, E> r( in_place_error );
-
-        int x = r | f;
-
-        BOOST_TEST_EQ( x, 2 );
-    }
-
-    {
-        result<int, E> const r( in_place_error );
-
-        int x = r | f;
-
-        BOOST_TEST_EQ( x, 2 );
-    }
-
-    {
-        int x = result<int, E>( in_place_error ) | f;
-
-        BOOST_TEST_EQ( x, 2 );
-    }
-
-    {
-        Y y = result<Y>( in_place_value, 1 ) | g;
-
-        BOOST_TEST_EQ( y.v_, 1 );
-    }
-
-    {
-        Y y = result<Y, E>( in_place_error ) | g;
-
-        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;
-
-        result<int&> r( x1 );
-
-        int& x = r | h;
-
-        BOOST_TEST_EQ( &x, &x1 );
-    }
-
-    {
-        int x1 = 1;
-
-        result<int&> const r( x1 );
-
-        int& x = r | h;
-
-        BOOST_TEST_EQ( &x, &x1 );
-    }
-
-    {
-        int x1 = 1;
-
-        int& x = result<int&>( x1 ) | h;
-
-        BOOST_TEST_EQ( &x, &x1 );
-    }
-
-    {
-        result<int&, E> r( in_place_error );
-
-        int& x = r | h;
-
-        BOOST_TEST_EQ( &x, &h() );
-    }
-
-    {
-        result<int&, E> const r( in_place_error );
-
-        int& x = r | h;
-
-        BOOST_TEST_EQ( &x, &h() );
-    }
-
-    {
-        int& x = result<int&, E>( in_place_error ) | h;
-
-        BOOST_TEST_EQ( &x, &h() );
-    }
-
-    return boost::report_errors();
-}
@@ -1,247 +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>
-#include <boost/core/lightweight_test.hpp>
-#include <boost/core/lightweight_test_trait.hpp>
-#include <type_traits>
-
-using namespace boost::system;
-
-struct X
-{
-    int v_;
-};
-
-struct Y
-{
-    int v_;
-
-    explicit Y( int v ): v_( v ) {}
-    Y( X x ): v_( x.v_) {}
-
-    Y( Y const& ) = delete;
-    Y& operator=( Y const& ) = delete;
-
-    Y( Y&& r ): v_( r.v_ )
-    {
-        r.v_ = 0;
-    }
-
-    Y& operator=( Y&& ) = delete;
-};
-
-struct E
-{
-};
-
-int main()
-{
-    {
-        result<int> r( 1 );
-
-        int x = r | 2;
-
-        BOOST_TEST_EQ( x, 1 );
-    }
-
-    {
-        result<int> const r( 1 );
-
-        int x = r | 2;
-
-        BOOST_TEST_EQ( x, 1 );
-    }
-
-    {
-        int x = result<int>( 1 ) | 2;
-
-        BOOST_TEST_EQ( x, 1 );
-    }
-
-    {
-        result<int, E> r( in_place_error );
-
-        int x = r | 2;
-
-        BOOST_TEST_EQ( x, 2 );
-    }
-
-    {
-        result<int, E> const r( in_place_error );
-
-        int x = r | 2;
-
-        BOOST_TEST_EQ( x, 2 );
-    }
-
-    {
-        int x = result<int, E>( in_place_error ) | 2;
-
-        BOOST_TEST_EQ( x, 2 );
-    }
-
-    {
-        Y y = result<Y>( in_place_value, 1 ) | Y{2};
-
-        BOOST_TEST_EQ( y.v_, 1 );
-    }
-
-    {
-        Y y = result<Y, E>( in_place_error ) | Y{2};
-
-        BOOST_TEST_EQ( y.v_, 2 );
-    }
-
-    {
-        Y y = result<Y>( in_place_value, 1 ) | X{2};
-
-        BOOST_TEST_EQ( y.v_, 1 );
-    }
-
-    {
-        Y y = result<Y, E>( in_place_error ) | X{2};
-
-        BOOST_TEST_EQ( y.v_, 2 );
-    }
-
-    {
-        int x1 = 1;
-        int x2 = 2;
-
-        result<int&> r( x1 );
-
-        {
-            auto&& x3 = r | x2;
-
-            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;
-
-        result<int&> const r( x1 );
-
-        {
-            auto&& x3 = r | x2;
-
-            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;
-
-        {
-            auto&& x3 = result<int&>( x1 ) | x2;
-
-            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 );
-        }
-    }
-
-    {
-        int x2 = 2;
-
-        result<int&, E> r( in_place_error );
-
-        {
-            auto&& x3 = r | 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;
-
-        result<int&, E> const r( in_place_error );
-
-        {
-            auto&& x3 = r | 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;
-
-        {
-            auto&& x3 = result<int&, E>( in_place_error ) | 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();
-}
@@ -259,55 +259,5 @@ int main()
        BOOST_TEST_EQ( r2, r2c );
    }

-    {
-        int x1 = 1;
-        int x2 = 2;
-
-        result<int&> r1( x1 ), r1c( r1 );
-        result<int&> r2( x2 ), r2c( r2 );
-
-        r1.swap( r2 );
-
-        BOOST_TEST_EQ( r1, r2c );
-        BOOST_TEST_EQ( r2, r1c );
-
-        swap( r1, r2 );
-
-        BOOST_TEST_EQ( r1, r1c );
-        BOOST_TEST_EQ( r2, r2c );
-    }
-
-    {
-        result<int&> r1( 1, generic_category() ), r1c( r1 );
-        result<int&> r2( 2, generic_category() ), r2c( r2 );
-
-        r1.swap( r2 );
-
-        BOOST_TEST_EQ( r1, r2c );
-        BOOST_TEST_EQ( r2, r1c );
-
-        swap( r1, r2 );
-
-        BOOST_TEST_EQ( r1, r1c );
-        BOOST_TEST_EQ( r2, r2c );
-    }
-
-    {
-        int x1 = 1;
-
-        result<int&> r1( x1 ), r1c( r1 );
-        result<int&> r2( 2, generic_category() ), r2c( r2 );
-
-        r1.swap( r2 );
-
-        BOOST_TEST_EQ( r1, r2c );
-        BOOST_TEST_EQ( r2, r1c );
-
-        swap( r1, r2 );
-
-        BOOST_TEST_EQ( r1, r1c );
-        BOOST_TEST_EQ( r2, r2c );
-    }
-
    return boost::report_errors();
 }
@@ -1,39 +0,0 @@
-// Copyright 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_trait.hpp>
-
-using namespace boost::system;
-
-struct X {};
-
-int main()
-{
-    BOOST_TEST_TRAIT_SAME( result<int>::value_type, int );
-    BOOST_TEST_TRAIT_SAME( result<int>::error_type, error_code );
-
-    BOOST_TEST_TRAIT_SAME( result<X>::value_type, X );
-    BOOST_TEST_TRAIT_SAME( result<X>::error_type, error_code );
-
-    BOOST_TEST_TRAIT_SAME( result<void>::value_type, void );
-    BOOST_TEST_TRAIT_SAME( result<void>::error_type, error_code );
-
-    BOOST_TEST_TRAIT_SAME( result<int&>::value_type, int& );
-    BOOST_TEST_TRAIT_SAME( result<int&>::error_type, error_code );
-
-    BOOST_TEST_TRAIT_SAME( result<int, X>::value_type, int );
-    BOOST_TEST_TRAIT_SAME( result<int, X>::error_type, X );
-
-    BOOST_TEST_TRAIT_SAME( result<X, X>::value_type, X );
-    BOOST_TEST_TRAIT_SAME( result<X, X>::error_type, X );
-
-    BOOST_TEST_TRAIT_SAME( result<void, X>::value_type, void );
-    BOOST_TEST_TRAIT_SAME( result<void, X>::error_type, X );
-
-    BOOST_TEST_TRAIT_SAME( result<int&, X>::value_type, int& );
-    BOOST_TEST_TRAIT_SAME( result<int&, X>::error_type, X );
-
-    return boost::report_errors();
-}
@@ -5,7 +5,6 @@
 #include <boost/system/result.hpp>
 #include <boost/core/lightweight_test.hpp>
 #include <boost/core/lightweight_test_trait.hpp>
-#include <boost/config.hpp>
 #include <system_error>

 using namespace boost::system;
@@ -224,10 +223,7 @@ int main()
        BOOST_TEST_NOT( r );
        BOOST_TEST( !r );

-#if defined(BOOST_CLANG_VERSION) && BOOST_CLANG_VERSION < 30600
-#else
        BOOST_TEST_THROWS( r.value(), E2 );
-#endif

        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
    }
@@ -336,8 +332,6 @@ int main()
        BOOST_TEST_EQ( (result<X, Y>( ec ).operator->()), static_cast<X*>(0) );
    }

-    //
-
    {
        result<void> r;

@@ -477,10 +471,7 @@ int main()
        BOOST_TEST_NOT( r );
        BOOST_TEST( !r );

-#if defined(BOOST_CLANG_VERSION) && BOOST_CLANG_VERSION < 30600
-#else
        BOOST_TEST_THROWS( r.value(), E2 );
-#endif

        BOOST_TEST_EQ( r.operator->(), static_cast<void*>(0) );
    }
@@ -499,179 +490,5 @@ int main()
        BOOST_TEST_EQ( r.operator->(), static_cast<void*>(0) );
    }

-    //
-
-    {
-        int x1 = 1;
-
-        result<int&> r( x1 );
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST( !r.has_error() );
-
-        BOOST_TEST( r );
-        BOOST_TEST_NOT( !r );
-
-        BOOST_TEST_EQ( r.value(), 1 );
-        BOOST_TEST_EQ( *r, 1 );
-
-        BOOST_TEST_EQ( r.operator->(), &*r );
-    }
-
-    {
-        int x1 = 1;
-
-        result<int&> const r( x1 );
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST( !r.has_error() );
-
-        BOOST_TEST( r );
-        BOOST_TEST_NOT( !r );
-
-        BOOST_TEST_EQ( r.value(), 1 );
-        BOOST_TEST_EQ( *r, 1 );
-
-        BOOST_TEST_EQ( r.operator->(), &*r );
-    }
-
-    {
-        int x1 = 1;
-
-        BOOST_TEST( result<int&>( x1 ).has_value() );
-        BOOST_TEST( !result<int&>( x1 ).has_error() );
-
-        BOOST_TEST( result<int&>( x1 ) );
-        BOOST_TEST_NOT( !result<int&>( x1 ) );
-
-        BOOST_TEST_EQ( result<int&>( x1 ).value(), 1 );
-        BOOST_TEST_EQ( *result<int&>( x1 ), 1 );
-
-        BOOST_TEST_EQ( result<int&>( x1 ).operator->(), &x1 );
-    }
-
-    {
-        auto ec = make_error_code( errc::invalid_argument );
-
-        result<int&> r( ec );
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST( r.has_error() );
-
-        BOOST_TEST_NOT( r );
-        BOOST_TEST( !r );
-
-        BOOST_TEST_THROWS( r.value(), system_error );
-
-        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
-    }
-
-    {
-        auto ec = make_error_code( errc::invalid_argument );
-
-        result<int&> const r( ec );
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST( r.has_error() );
-
-        BOOST_TEST_NOT( r );
-        BOOST_TEST( !r );
-
-        BOOST_TEST_THROWS( r.value(), system_error );
-
-        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
-    }
-
-    {
-        auto ec = make_error_code( errc::invalid_argument );
-
-        BOOST_TEST( !result<int&>( ec ).has_value() );
-        BOOST_TEST( result<int&>( ec ).has_error() );
-
-        BOOST_TEST_NOT( result<int&>( ec ) );
-        BOOST_TEST( !result<int&>( ec ) );
-
-        BOOST_TEST_THROWS( result<int&>( ec ).value(), system_error );
-
-        BOOST_TEST_EQ( result<int&>( ec ).operator->(), static_cast<int*>(0) );
-    }
-
-    {
-        auto ec = make_error_code( std::errc::invalid_argument );
-
-        result<int&, std::error_code> const r( ec );
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST( r.has_error() );
-
-        BOOST_TEST_NOT( r );
-        BOOST_TEST( !r );
-
-        BOOST_TEST_THROWS( r.value(), std::system_error );
-
-        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
-    }
-
-    {
-        result<int&, errc::errc_t> const r( in_place_error, errc::invalid_argument );
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST( r.has_error() );
-
-        BOOST_TEST_NOT( r );
-        BOOST_TEST( !r );
-
-        BOOST_TEST_THROWS( r.value(), system_error );
-
-        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
-    }
-
-    {
-        result<int&, std::errc> const r( std::errc::invalid_argument );
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST( r.has_error() );
-
-        BOOST_TEST_NOT( r );
-        BOOST_TEST( !r );
-
-        BOOST_TEST_THROWS( r.value(), std::system_error );
-
-        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
-    }
-
-    {
-        result<int&, std::exception_ptr> const r( std::make_exception_ptr( E2() ) );
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST( r.has_error() );
-
-        BOOST_TEST_NOT( r );
-        BOOST_TEST( !r );
-
-#if defined(BOOST_CLANG_VERSION) && BOOST_CLANG_VERSION < 30600
-#else
-        BOOST_TEST_THROWS( r.value(), E2 );
-#endif
-
-        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
-    }
-
-    {
-        result<int&, std::exception_ptr> const r( in_place_error );
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST( r.has_error() );
-
-        BOOST_TEST_NOT( r );
-        BOOST_TEST( !r );
-
-        BOOST_TEST_THROWS( r.value(), std::bad_exception );
-
-        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
-    }
-
-    //
-
    return boost::report_errors();
 }
@@ -69,11 +69,6 @@ result<std::vector<int>> fv2()
    return {{ 1, 2 }};
 }

-result<void> fw0()
-{
-    return {};
-}
-
 int main()
 {
    {
@@ -153,12 +148,5 @@ int main()
        BOOST_TEST_EQ( r->at(1), 2 );
    }

-    {
-        result<void> r = fw0();
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST( !r.has_error() );
-    }
-
    return boost::report_errors();
 }
@@ -1,142 +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>
-#include <boost/core/lightweight_test.hpp>
-
-using namespace boost::system;
-
-struct X
-{
-    static int instances;
-
-    int v_;
-
-    explicit X( int v ): v_( v ) { ++instances; }
-
-    X( int v1, int v2 ): v_( v1+v2 ) { ++instances; }
-    X( int v1, int v2, int v3 ): v_( v1+v2+v3 ) { ++instances; }
-
-    X( X const& ) = delete;
-    X& operator=( X const& ) = delete;
-
-    ~X() { --instances; }
-};
-
-int X::instances = 0;
-
-int main()
-{
-    {
-        using R = result<int>;
-        R r( R::in_place_value, 0 );
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST( !r.has_error() );
-
-        BOOST_TEST_EQ( r.value(), 0 );
-    }
-
-    {
-        using R = result<int, int>;
-        R r( R::in_place_value, 1 );
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST( !r.has_error() );
-
-        BOOST_TEST_EQ( *r, 1 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        using R = result<X>;
-        R r( R::in_place_value, 1 );
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST( !r.has_error() );
-
-        BOOST_TEST_EQ( r.value().v_, 1 );
-
-        BOOST_TEST_EQ( X::instances, 1 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        using R = result<X>;
-        R r( R::in_place_value, 1, 2 );
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST( !r.has_error() );
-
-        BOOST_TEST_EQ( r.value().v_, 1+2 );
-
-        BOOST_TEST_EQ( X::instances, 1 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        using R = result<X>;
-        R r( R::in_place_value, 1, 2, 3 );
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST( !r.has_error() );
-
-        BOOST_TEST_EQ( r.value().v_, 1+2+3 );
-
-        BOOST_TEST_EQ( X::instances, 1 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        using R = result<X, X>;
-        R r( R::in_place_value, 1 );
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST( !r.has_error() );
-
-        BOOST_TEST_EQ( r->v_, 1 );
-
-        BOOST_TEST_EQ( X::instances, 1 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        using R = result<void>;
-        R r( R::in_place_value );
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST( !r.has_error() );
-    }
-
-    {
-        int x1 = 1;
-
-        using R = result<int&>;
-        R r( R::in_place_value, x1 );
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST( !r.has_error() );
-
-        BOOST_TEST_EQ( r.value(), 1 );
-    }
-
-    {
-        int x1 = 1;
-
-        using R = result<int&, int>;
-        R r( R::in_place_value, x1 );
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST( !r.has_error() );
-
-        BOOST_TEST_EQ( *r, 1 );
-    }
-
-    return boost::report_errors();
-}
@@ -1,59 +0,0 @@
-// Copyright 2023 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;
-
-// Tricky mixed construction cases
-// https://github.com/boostorg/system/issues/104
-// https://brevzin.github.io//c++/2023/01/18/optional-construction/
-
-int main()
-{
-    {
-        result<int> r( make_error_code( errc::invalid_argument ) );
-        result<result<int>> r2( r );
-
-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2.value(), r );
-    }
-
-    {
-        result<int> r( 5 );
-        result<result<int>> r2( r );
-
-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2.value(), r );
-    }
-
-    {
-        result<int> const r( make_error_code( errc::invalid_argument ) );
-        result<result<int>> r2( r );
-
-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2.value(), r );
-    }
-
-    {
-        result<int> const r( 5 );
-        result<result<int>> r2( r );
-
-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2.value(), r );
-    }
-
-    {
-        result<int> r( make_error_code( errc::invalid_argument ) );
-        result<result<int>> r2( std::move( r ) );
-
-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2.value(), r );
-    }
-
-    {
-        result<int> r( 5 );
-        result<result<int>> r2( std::move( r ) );
-
-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2.value(), r );
-    }
-
-    return boost::report_errors();
-}
@@ -1,86 +0,0 @@
-// Copyright 2023 Peter Dimov.
-// Distributed under the Boost Software License, Version 1.0.
-// https://www.boost.org/LICENSE_1_0.txt
-
-#if defined(_MSC_VER) && _MSC_VER < 1910
-# pragma warning( disable: 4800 ) // forcing value to bool 'true' or 'false'
-#endif
-
-#include <boost/system/result.hpp>
-#include <boost/core/lightweight_test.hpp>
-#include <boost/core/lightweight_test_trait.hpp>
-#include <utility>
-#include <type_traits>
-
-using namespace boost::system;
-
-// Tricky mixed construction cases
-// https://github.com/boostorg/system/issues/104
-// https://brevzin.github.io//c++/2023/01/18/optional-construction/
-
-template<class R1, class R2> void test()
-{
-    {
-        R1 r1( make_error_code( errc::invalid_argument ) );
-        R2 r2( r1 );
-
-        BOOST_TEST( !r2.has_value() );
-    }
-
-    {
-        R1 r1( 0 );
-        R2 r2( r1 );
-
-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2.value(), false );
-    }
-
-    {
-        R1 r1( 1 );
-        R2 r2( r1 );
-
-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2.value(), true );
-    }
-
-    {
-        R1 r1( make_error_code( errc::invalid_argument ) );
-        R2 r2( std::move( r1 ) );
-
-        BOOST_TEST( !r2.has_value() );
-    }
-
-    {
-        R1 r1( 0 );
-        R2 r2( std::move( r1 ) );
-
-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2.value(), false );
-    }
-
-    {
-        R1 r1( 1 );
-        R2 r2( std::move( r1 ) );
-
-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2.value(), true );
-    }
-}
-
-struct X
-{
-};
-
-int main()
-{
-    test< result<int>, result<bool> >();
-    test< result<int> const, result<bool> >();
-
-    BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<bool>, result<X>&>));
-    BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<bool>, result<X> const&>));
-    BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<bool>, result<X>&&>));
-    BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<bool>, result<X> const&&>));
-
-    BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<bool const>, result<X>&>));
-    BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<bool const>, result<X> const&>));
-    BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<bool const>, result<X>&&>));
-    BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<bool const>, result<X> const&&>));
-
-    return boost::report_errors();
-}
@@ -1,121 +0,0 @@
-// Copyright 2017, 2021, 2023 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/core/lightweight_test_trait.hpp>
-
-using namespace boost::system;
-
-struct X
-{
-    static int instances;
-
-    int v_;
-
-    explicit X( int v ): v_( v ) { ++instances; }
-
-    X( X const& ) = delete;
-    X& operator=( X const& ) = delete;
-
-    ~X() { --instances; }
-};
-
-int X::instances = 0;
-
-int main()
-{
-    {
-        int x = 0;
-        result<int&> r( x );
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST( !r.has_error() );
-
-        BOOST_TEST_EQ( r.value(), 0 );
-    }
-
-    {
-        int x = 0;
-        result<int&> r = x;
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST( !r.has_error() );
-
-        BOOST_TEST_EQ( r.value(), 0 );
-    }
-
-    {
-        int x = 1;
-        result<int&, int> r( in_place_value, x );
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST( !r.has_error() );
-
-        BOOST_TEST_EQ( *r, 1 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        X x( 1 );
-        result<X&> r( x );
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST( !r.has_error() );
-
-        BOOST_TEST_EQ( r.value().v_, 1 );
-
-        BOOST_TEST_EQ( X::instances, 1 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        X x( 1 );
-        result<X&> r = x;
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST( !r.has_error() );
-
-        BOOST_TEST_EQ( r.value().v_, 1 );
-
-        BOOST_TEST_EQ( X::instances, 1 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        X x( 1 );
-        result<X&, X> r( in_place_value, x );
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST( !r.has_error() );
-
-        BOOST_TEST_EQ( r->v_, 1 );
-
-        BOOST_TEST_EQ( X::instances, 1 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        BOOST_TEST_TRAIT_TRUE((std::is_constructible<result<int&>, int&>));
-        BOOST_TEST_TRAIT_TRUE((std::is_convertible<int&, result<int&>>));
-
-        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int&>, int const&>));
-        BOOST_TEST_TRAIT_FALSE((std::is_convertible<int const&, result<int&>>));
-
-        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int&>, int>));
-        BOOST_TEST_TRAIT_FALSE((std::is_convertible<int, result<int&>>));
-
-        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int&, int>, int&>));
-        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int&, float>, int&>));
-
-        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<X&>, int>));
-        BOOST_TEST_TRAIT_FALSE((std::is_convertible<int, result<X&>>));
-    }
-
-    return boost::report_errors();
-}
@@ -1,211 +0,0 @@
-// Copyright 2017, 2021, 2023 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/core/lightweight_test_trait.hpp>
-
-using namespace boost::system;
-
-struct X
-{
-    static int instances;
-
-    int v_;
-
-    explicit X( int v ): v_( v ) { ++instances; }
-
-    X( X const& ) = delete;
-    X& operator=( X const& ) = delete;
-
-    ~X() { --instances; }
-};
-
-int X::instances = 0;
-
-int main()
-{
-    {
-        int x = 0;
-        result<int const&> r( x );
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST( !r.has_error() );
-
-        BOOST_TEST_EQ( r.value(), 0 );
-    }
-
-    {
-        int const x = 0;
-        result<int const&> r( x );
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST( !r.has_error() );
-
-        BOOST_TEST_EQ( r.value(), 0 );
-    }
-
-    {
-        int x = 0;
-        result<int const&> r = x;
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST( !r.has_error() );
-
-        BOOST_TEST_EQ( r.value(), 0 );
-    }
-
-    {
-        int const x = 0;
-        result<int const&> r = x;
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST( !r.has_error() );
-
-        BOOST_TEST_EQ( r.value(), 0 );
-    }
-
-    {
-        int x = 1;
-        result<int const&, int> r( in_place_value, x );
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST( !r.has_error() );
-
-        BOOST_TEST_EQ( *r, 1 );
-    }
-
-    {
-        int const x = 1;
-        result<int const&, int> r( in_place_value, x );
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST( !r.has_error() );
-
-        BOOST_TEST_EQ( *r, 1 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        X x( 1 );
-        result<X const&> r( x );
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST( !r.has_error() );
-
-        BOOST_TEST_EQ( r.value().v_, 1 );
-
-        BOOST_TEST_EQ( X::instances, 1 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        X const x( 1 );
-        result<X const&> r( x );
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST( !r.has_error() );
-
-        BOOST_TEST_EQ( r.value().v_, 1 );
-
-        BOOST_TEST_EQ( X::instances, 1 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        X x( 1 );
-        result<X const&> r = x;
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST( !r.has_error() );
-
-        BOOST_TEST_EQ( r.value().v_, 1 );
-
-        BOOST_TEST_EQ( X::instances, 1 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        X const x( 1 );
-        result<X const&> r = x;
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST( !r.has_error() );
-
-        BOOST_TEST_EQ( r.value().v_, 1 );
-
-        BOOST_TEST_EQ( X::instances, 1 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        X x( 1 );
-        result<X const&, X> r( in_place_value, x );
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST( !r.has_error() );
-
-        BOOST_TEST_EQ( r->v_, 1 );
-
-        BOOST_TEST_EQ( X::instances, 1 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        X const x( 1 );
-        result<X const&, X> r( in_place_value, x );
-
-        BOOST_TEST( r.has_value() );
-        BOOST_TEST( !r.has_error() );
-
-        BOOST_TEST_EQ( r->v_, 1 );
-
-        BOOST_TEST_EQ( X::instances, 1 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        BOOST_TEST_TRAIT_TRUE((std::is_constructible<result<int const&>, int&>));
-        BOOST_TEST_TRAIT_TRUE((std::is_convertible<int&, result<int const&>>));
-
-        BOOST_TEST_TRAIT_TRUE((std::is_constructible<result<int const&>, int const&>));
-        BOOST_TEST_TRAIT_TRUE((std::is_convertible<int const&, result<int const&>>));
-
-        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int const&>, int>));
-        BOOST_TEST_TRAIT_FALSE((std::is_convertible<int, result<int const&>>));
-
-        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<double const&>, int&>));
-        BOOST_TEST_TRAIT_FALSE((std::is_convertible<int&, result<double const&>>));
-
-        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<double const&>, int const&>));
-        BOOST_TEST_TRAIT_FALSE((std::is_convertible<int const&, result<double const&>>));
-
-        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<double const&>, int>));
-        BOOST_TEST_TRAIT_FALSE((std::is_convertible<int, result<double const&>>));
-
-        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int const&, int>, int&>));
-        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int const&, float>, int&>));
-
-        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int const&, int>, int const&>));
-        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int const&, float>, int const&>));
-
-        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int const&, int>, int>));
-        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int const&, float>, int>));
-
-        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<X const&>, int>));
-        BOOST_TEST_TRAIT_FALSE((std::is_convertible<int, result<X const&>>));
-
-        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<X const&>, X const>));
-        BOOST_TEST_TRAIT_FALSE((std::is_convertible<X const, result<X const&>>));
-    }
-
-    return boost::report_errors();
-}
@@ -1,47 +0,0 @@
-// 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
@@ -2,16 +2,6 @@
 // Distributed under the Boost Software License, Version 1.0.
 // http://www.boost.org/LICENSE_1_0.txt

-#if defined(__GNUC__) && __GNUC__ >= 7
-# 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>

@@ -8,9 +8,28 @@

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

+// Avoid spurious VC++ warnings
+# define _CRT_SECURE_NO_WARNINGS
+
 #include <boost/system/error_code.hpp>
+#include <boost/config.hpp>
+#include <boost/config/pragma_message.hpp>
+#include <iostream>
+
+#if !defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
+
+BOOST_PRAGMA_MESSAGE( "BOOST_SYSTEM_HAS_SYSTEM_ERROR not defined, test will be skipped" )
+
+int main()
+{
+  std::cout
+    << "The version of the C++ standard library being used does not"
+    " support header <system_error> so interoperation will not be tested.\n";
+}
+
+#else
+
 #include <boost/core/lightweight_test.hpp>
-#include <boost/core/snprintf.hpp>
 #include <system_error>
 #include <cerrno>
 #include <string>
@@ -100,7 +119,7 @@ class user_category_impl: public boost::system::error_category
 {
 public:

-    virtual const char * name() const noexcept
+    virtual const char * name() const BOOST_NOEXCEPT
    {
        return "user";
    }
@@ -108,12 +127,12 @@ public:
    virtual std::string message( int ev ) const
    {
        char buffer[ 256 ];
-        boost::core::snprintf( buffer, sizeof( buffer ), "user message %d", ev );
+        std::sprintf( buffer, "user message %d", ev );

        return buffer;
    }

-    virtual boost::system::error_condition default_error_condition( int ev ) const noexcept
+    virtual boost::system::error_condition default_error_condition( int ev ) const BOOST_NOEXCEPT
    {
        if( ev == 4 )
        {
@@ -129,7 +148,7 @@ public:
        }
    }

-    virtual bool equivalent( int code, const boost::system::error_condition & condition ) const noexcept
+    virtual bool equivalent( int code, const boost::system::error_condition & condition ) const BOOST_NOEXCEPT
    {
        if( code == 4 && condition == make_error_condition( boost::system::errc::too_many_files_open_in_system ) )
        {
@@ -144,7 +163,7 @@ public:
        return default_error_condition( code ) == condition;
    }

-    // virtual bool equivalent( const error_code & code, int condition ) const noexcept;
+    // virtual bool equivalent( const error_code & code, int condition ) const BOOST_NOEXCEPT;
 };

 boost::system::error_category const & user_category()
@@ -240,7 +259,7 @@ class user2_category_impl: public boost::system::error_category
 {
 public:

-    virtual const char * name() const noexcept
+    virtual const char * name() const BOOST_NOEXCEPT
    {
        return "user2";
    }
@@ -248,22 +267,22 @@ public:
    virtual std::string message( int ev ) const
    {
        char buffer[ 256 ];
-        boost::core::snprintf( buffer, sizeof( buffer ), "user2 message %d", ev );
+        std::sprintf( buffer, "user2 message %d", ev );

        return buffer;
    }

-    virtual boost::system::error_condition default_error_condition( int ev ) const noexcept
+    virtual boost::system::error_condition default_error_condition( int ev ) const BOOST_NOEXCEPT
    {
        return boost::system::error_condition( ev, *this );
    }

-    virtual bool equivalent( int code, const boost::system::error_condition & condition ) const noexcept
+    virtual bool equivalent( int code, const boost::system::error_condition & condition ) const BOOST_NOEXCEPT
    {
        return default_error_condition( code ) == condition;
    }

-    virtual bool equivalent( const boost::system::error_code & code, int condition ) const noexcept
+    virtual bool equivalent( const boost::system::error_code & code, int condition ) const BOOST_NOEXCEPT
    {
        if( code.category() == *this )
        {
@@ -320,6 +339,9 @@ static void test_user2_category()

 int main()
 {
+    std::cout
+      << "The version of the C++ standard library being used"
+      " supports header <system_error> so interoperation will be tested.\n";
    test_generic_category();
    test_system_category();
    test_user_category();
@@ -327,3 +349,5 @@ int main()

    return boost::report_errors();
 }
+
+#endif
@@ -4,7 +4,16 @@

 #include <boost/system/error_code.hpp>
 #include <boost/core/lightweight_test.hpp>
+#include <boost/config/pragma_message.hpp>
 #include <cerrno>
+
+#if !defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
+
+BOOST_PRAGMA_MESSAGE( "BOOST_SYSTEM_HAS_SYSTEM_ERROR not defined, test will be skipped" )
+int main() {}
+
+#else
+
 #include <system_error>

 int main()
@@ -53,3 +62,5 @@ int main()

    return boost::report_errors();
 }
+
+#endif
--- a/Show More
+++ b/Show More