Merge branch 'develop' into feature/std-category

Update index.html

.github/workflows/ci.yml

@@ -17,24 +17,17 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          - toolset: gcc-4.7
-            cxxstd: "03,11"
-            os: ubuntu-16.04
-            install: g++-4.7
           - toolset: gcc-4.8
             cxxstd: "03,11"
-            os: ubuntu-16.04
+            os: ubuntu-18.04
             install: g++-4.8
-          - toolset: gcc-4.9
-            cxxstd: "03,11"
-            os: ubuntu-16.04
-            install: g++-4.9
           - toolset: gcc-5
             cxxstd: "03,11,14,1z"
-            os: ubuntu-16.04
+            os: ubuntu-18.04
+            install: g++-5
           - toolset: gcc-6
             cxxstd: "03,11,14,1z"
-            os: ubuntu-16.04
+            os: ubuntu-18.04
             install: g++-6
           - toolset: gcc-7
             cxxstd: "03,11,14,17"
@@ -45,48 +38,29 @@ jobs:
             install: g++-8
           - toolset: gcc-9
             cxxstd: "03,11,14,17,2a"
-            os: ubuntu-18.04
+            os: ubuntu-20.04
           - toolset: gcc-10
             cxxstd: "03,11,14,17,2a"
-            os: ubuntu-18.04
+            os: ubuntu-20.04
+            install: g++-10
           - toolset: gcc-11
             cxxstd: "03,11,14,17,2a"
-            os: ubuntu-18.04
+            os: ubuntu-20.04
             install: g++-11
-          - toolset: clang
-            compiler: clang++-3.5
-            cxxstd: "03,11"
-            os: ubuntu-16.04
-            install: clang-3.5
-          - toolset: clang
-            compiler: clang++-3.6
-            cxxstd: "03,11,14"
-            os: ubuntu-16.04
-            install: clang-3.6
-          - toolset: clang
-            compiler: clang++-3.7
-            cxxstd: "03,11,14"
-            os: ubuntu-16.04
-            install: clang-3.7
-          - toolset: clang
-            compiler: clang++-3.8
-            cxxstd: "03,11,14"
-            os: ubuntu-16.04
-            install: clang-3.8
           - toolset: clang
             compiler: clang++-3.9
             cxxstd: "03,11,14"
-            os: ubuntu-16.04
+            os: ubuntu-18.04
             install: clang-3.9
           - toolset: clang
             compiler: clang++-4.0
             cxxstd: "03,11,14"
-            os: ubuntu-16.04
+            os: ubuntu-18.04
             install: clang-4.0
           - toolset: clang
             compiler: clang++-5.0
             cxxstd: "03,11,14,1z"
-            os: ubuntu-16.04
+            os: ubuntu-18.04
             install: clang-5.0
           - toolset: clang
             compiler: clang++-6.0
@@ -215,3 +189,159 @@ jobs:
         run: |
           cd ../boost-root
           b2 -j3 libs/%LIBRARY%/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} address-model=${{matrix.addrmd}} variant=debug,release
+
+  posix-cmake-subdir:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-18.04
+          - os: ubuntu-20.04
+          - os: macos-10.15
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Install packages
+        if: matrix.install
+        run: sudo apt install ${{matrix.install}}
+
+      - name: Setup Boost
+        run: |
+          echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
+          LIBRARY=${GITHUB_REPOSITORY#*/}
+          echo LIBRARY: $LIBRARY
+          echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
+          echo GITHUB_BASE_REF: $GITHUB_BASE_REF
+          echo GITHUB_REF: $GITHUB_REF
+          REF=${GITHUB_BASE_REF:-$GITHUB_REF}
+          REF=${REF#refs/heads/}
+          echo REF: $REF
+          BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
+          echo BOOST_BRANCH: $BOOST_BRANCH
+          cd ..
+          git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
+
+      - name: Use library with add_subdirectory
+        run: |
+          cd ../boost-root/libs/$LIBRARY/test/cmake_subdir_test
+          mkdir __build__ && cd __build__
+          cmake ..
+          cmake --build .
+          ctest --output-on-failure --no-tests=error
+
+  posix-cmake-install:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-18.04
+          - os: ubuntu-20.04
+          - os: macos-10.15
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Install packages
+        if: matrix.install
+        run: sudo apt install ${{matrix.install}}
+
+      - name: Setup Boost
+        run: |
+          echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
+          LIBRARY=${GITHUB_REPOSITORY#*/}
+          echo LIBRARY: $LIBRARY
+          echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
+          echo GITHUB_BASE_REF: $GITHUB_BASE_REF
+          echo GITHUB_REF: $GITHUB_REF
+          REF=${GITHUB_BASE_REF:-$GITHUB_REF}
+          REF=${REF#refs/heads/}
+          echo REF: $REF
+          BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
+          echo BOOST_BRANCH: $BOOST_BRANCH
+          cd ..
+          git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
+
+      - name: Configure
+        run: |
+          cd ../boost-root
+          mkdir __build__ && cd __build__
+          cmake -DBOOST_INCLUDE_LIBRARIES=$LIBRARY -DCMAKE_INSTALL_PREFIX=~/.local ..
+
+      - name: Install
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target install
+
+      - name: Use the installed library
+        run: |
+          cd ../boost-root/libs/$LIBRARY/test/cmake_install_test && mkdir __build__ && cd __build__
+          cmake -DCMAKE_INSTALL_PREFIX=~/.local ..
+          cmake --build .
+          ctest --output-on-failure --no-tests=error
+
+  posix-cmake-test:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-18.04
+          - os: ubuntu-20.04
+          - os: macos-10.15
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Install packages
+        if: matrix.install
+        run: sudo apt install ${{matrix.install}}
+
+      - name: Setup Boost
+        run: |
+          echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
+          LIBRARY=${GITHUB_REPOSITORY#*/}
+          echo LIBRARY: $LIBRARY
+          echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
+          echo GITHUB_BASE_REF: $GITHUB_BASE_REF
+          echo GITHUB_REF: $GITHUB_REF
+          REF=${GITHUB_BASE_REF:-$GITHUB_REF}
+          REF=${REF#refs/heads/}
+          echo REF: $REF
+          BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
+          echo BOOST_BRANCH: $BOOST_BRANCH
+          cd ..
+          git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
+
+      - name: Configure
+        run: |
+          cd ../boost-root
+          mkdir __build__ && cd __build__
+          cmake -DBOOST_INCLUDE_LIBRARIES=$LIBRARY -DBUILD_TESTING=ON ..
+
+      - name: Build tests
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target tests
+
+      - name: Run tests
+        run: |
+          cd ../boost-root/__build__
+          ctest --output-on-failure --no-tests=error

CMakeLists.txt

@@ -1,4 +1,4 @@
-# Copyright 2018-2020 Peter Dimov
+# Copyright 2018-2021 Peter Dimov
 # 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
 
@@ -13,7 +13,10 @@ target_include_directories(boost_system INTERFACE include)
 
 target_link_libraries(boost_system
   INTERFACE
+    Boost::assert
     Boost::config
+    Boost::throw_exception
+    Boost::variant2
     Boost::winapi
 )
 

build/Jamfile.v2

@@ -5,7 +5,7 @@
 # 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 http://www.boost.org/libs/system
+# See library home page at https://www.boost.org/libs/system
 
 project boost/system
     : source-location ../src

doc/system.adoc

@@ -4,7 +4,7 @@ Copyright 2018 Peter Dimov
 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
+https://www.boost.org/LICENSE_1_0.txt
 ////
 
 # Boost.System: Extensible Error Reporting

doc/system/changes.adoc

@@ -1,16 +1,21 @@
 ////
 Copyright 2018-2021 Peter Dimov
-
 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
+https://www.boost.org/LICENSE_1_0.txt
 ////
 
 [#changes]
 # Revision History
 :idprefix:
 
+## Changes in Boost 1.78
+
+* Added support for source locations to `error_code`.
+* Added `error_code::to_string`, `error_condition::to_string`.
+* `system_error::what()` now contains the source location, if present.
+* Added `result<T, E = error_code>`, a class holding either a value or an
+  error, defined in `<boost/system/result.hpp>`.
+
 ## Changes in Boost 1.77
 
 * The conversion operator from `error_category` to `std::error_category`

include/boost/system.hpp

@@ -10,4 +10,8 @@
 #include <boost/system/error_code.hpp>
 #include <boost/system/system_error.hpp>
 
+#if (__cplusplus >= 201103L) || (defined(_MSC_VER) && _MSC_VER >= 1900)
+# include <boost/system/result.hpp>
+#endif
+
 #endif // #ifndef BOOST_SYSTEM_HPP_INCLUDED

include/boost/system/detail/append_int.hpp

@@ -0,0 +1,32 @@
+#ifndef BOOST_SYSTEM_DETAIL_APPEND_INT_HPP_INCLUDED
+#define BOOST_SYSTEM_DETAIL_APPEND_INT_HPP_INCLUDED
+
+// Copyright 2021 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/system/detail/snprintf.hpp>
+#include <string>
+
+//
+
+namespace boost
+{
+namespace system
+{
+namespace detail
+{
+
+inline void append_int( std::string& s, int v )
+{
+    char buffer[ 32 ];
+    detail::snprintf( buffer, sizeof( buffer ), ":%d", v );
+
+    s += buffer;
+}
+
+} // namespace detail
+} // namespace system
+} // namespace boost
+
+#endif // #ifndef BOOST_SYSTEM_DETAIL_APPEND_INT_HPP_INCLUDED

include/boost/system/detail/error_category.hpp

@@ -55,6 +55,9 @@ private:
     friend std::size_t hash_value( error_code const & ec );
     friend BOOST_SYSTEM_CONSTEXPR bool detail::failed_impl( int ev, error_category const & cat );
 
+    friend class error_code;
+    friend class error_condition;
+
 #if !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS)
 public:
 
@@ -170,9 +173,9 @@ public:
 namespace detail
 {
 
-static const boost::ulong_long_type generic_category_id = ( boost::ulong_long_type( 0xB2AB117A ) << 32 ) + 0x257EDF0D;
-static const boost::ulong_long_type system_category_id = ( boost::ulong_long_type( 0x8FAFD21E ) << 32 ) + 0x25C5E09B;
-static const boost::ulong_long_type interop_category_id = ( boost::ulong_long_type( 0x943F2817 ) << 32 ) + 0xFD3A8FAF;
+static const boost::ulong_long_type generic_category_id = ( boost::ulong_long_type( 0xB2AB117A ) << 32 ) + 0x257EDFD0;
+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 )
 {

include/boost/system/detail/error_category_impl.hpp

@@ -38,7 +38,7 @@ inline bool error_category::equivalent( int code, const error_condition & condit
 
 inline bool error_category::equivalent( const error_code & code, int condition ) const BOOST_NOEXCEPT
 {
-    return *this == code.category() && code.value() == condition;
+    return code.equals( condition, *this );
 }
 
 inline char const * error_category::message( int ev, char * buffer, std::size_t len ) const BOOST_NOEXCEPT
@@ -102,18 +102,26 @@ inline char const * error_category::message( int ev, char * buffer, std::size_t
 
 inline boost::system::error_category::operator std::error_category const & () const
 {
+    if( id_ == boost::system::detail::generic_category_id )
+    {
+#if defined(BOOST_GCC) && BOOST_GCC < 50000
+
+        static const boost::system::detail::std_category generic_instance( this, 0x1F4D3 );
+        return generic_instance;
+
+#else
+
+        return std::generic_category();
+
+#endif
+    }
+
     if( id_ == boost::system::detail::system_category_id )
     {
         static const boost::system::detail::std_category system_instance( this, 0x1F4D7 );
         return system_instance;
     }
 
-    if( id_ == boost::system::detail::generic_category_id )
-    {
-        static const boost::system::detail::std_category generic_instance( this, 0x1F4D3 );
-        return generic_instance;
-    }
-
     boost::system::detail::std_category* p = ps_.load( std::memory_order_acquire );
 
     if( p != 0 )

include/boost/system/detail/error_code.hpp

@@ -3,7 +3,7 @@
 
 //  Copyright Beman Dawes 2006, 2007
 //  Copyright Christoper Kohlhoff 2007
-//  Copyright Peter Dimov 2017, 2018
+//  Copyright Peter Dimov 2017-2021
 //
 //  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)
@@ -18,12 +18,15 @@
 #include <boost/system/detail/interop_category.hpp>
 #include <boost/system/detail/enable_if.hpp>
 #include <boost/system/detail/is_same.hpp>
+#include <boost/system/detail/append_int.hpp>
 #include <boost/system/detail/snprintf.hpp>
 #include <boost/system/detail/config.hpp>
+#include <boost/assert/source_location.hpp>
 #include <boost/cstdint.hpp>
 #include <boost/config.hpp>
 #include <ostream>
 #include <new>
+#include <cstdio>
 
 #if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
 # include <system_error>
@@ -77,26 +80,35 @@ private:
     // 1: holds std::error_code in d2_
     // 2: holds error code in d1_, failed == false
     // 3: holds error code in d1_, failed == true
-    unsigned flags_;
+    // >3: pointer to source_location, failed_ in lsb
+    boost::uintptr_t lc_flags_;
 
 public:
 
     // constructors:
 
     BOOST_SYSTEM_CONSTEXPR error_code() BOOST_NOEXCEPT:
-        d1_(), flags_( 0 )
+        d1_(), lc_flags_( 0 )
     {
     }
 
     BOOST_SYSTEM_CONSTEXPR error_code( int val, const error_category & cat ) BOOST_NOEXCEPT:
-        d1_(), flags_( 2 + detail::failed_impl( val, cat ) )
+        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 ) BOOST_NOEXCEPT:
+        d1_(), lc_flags_( ( loc? reinterpret_cast<boost::uintptr_t>( loc ): 2 ) | +detail::failed_impl( val, cat ) )
     {
         d1_.val_ = val;
         d1_.cat_ = &cat;
     }
 
     template<class ErrorCodeEnum> BOOST_SYSTEM_CONSTEXPR error_code( ErrorCodeEnum e,
-        typename detail::enable_if<is_error_code_enum<ErrorCodeEnum>::value>::type* = 0 ) BOOST_NOEXCEPT
+        typename detail::enable_if<is_error_code_enum<ErrorCodeEnum>::value>::type* = 0 ) BOOST_NOEXCEPT:
+        d1_(), lc_flags_( 0 )
     {
         *this = make_error_code( e );
     }
@@ -104,7 +116,7 @@ public:
 #if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
 
     error_code( std::error_code const& ec ) BOOST_NOEXCEPT:
-        flags_( 1 )
+        lc_flags_( 1 )
     {
         ::new( d2_ ) std::error_code( ec );
     }
@@ -118,6 +130,11 @@ public:
         *this = error_code( val, cat );
     }
 
+    void assign( int val, const error_category & cat, source_location const * loc ) BOOST_NOEXCEPT
+    {
+        *this = error_code( val, cat, loc );
+    }
+
     template<typename ErrorCodeEnum>
         BOOST_SYSTEM_CONSTEXPR typename detail::enable_if<is_error_code_enum<ErrorCodeEnum>::value, error_code>::type &
         operator=( ErrorCodeEnum val ) BOOST_NOEXCEPT
@@ -135,7 +152,7 @@ public:
 
     BOOST_SYSTEM_CONSTEXPR int value() const BOOST_NOEXCEPT
     {
-        if( flags_ != 1 )
+        if( lc_flags_ != 1 )
         {
             return d1_.val_;
         }
@@ -154,11 +171,11 @@ public:
 
     BOOST_SYSTEM_CONSTEXPR const error_category & category() const BOOST_NOEXCEPT
     {
-        if( flags_ == 0 )
+        if( lc_flags_ == 0 )
         {
             return system_category();
         }
-        else if( flags_ == 1 )
+        else if( lc_flags_ == 1 )
         {
             return detail::interop_category();
         }
@@ -178,7 +195,7 @@ public:
     {
 #if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
 
-        if( flags_ == 1 )
+        if( lc_flags_ == 1 )
         {
             std::error_code const& ec = *reinterpret_cast<std::error_code const*>( d2_ );
             return ec.message();
@@ -192,7 +209,7 @@ public:
     char const * message( char * buffer, std::size_t len ) const BOOST_NOEXCEPT
     {
 #if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
-        if( flags_ == 1 )
+        if( lc_flags_ == 1 )
         {
 #if !defined(BOOST_NO_EXCEPTIONS)
             try
@@ -215,18 +232,20 @@ public:
 
     BOOST_SYSTEM_CONSTEXPR bool failed() const BOOST_NOEXCEPT
     {
-#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
-
-        if( flags_ == 1 )
+        if( lc_flags_ & 1 )
         {
-            std::error_code const& ec = *reinterpret_cast<std::error_code const*>( d2_ );
-            return ec.value() != 0;
+#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
-
-#endif
         {
-            return (flags_ & 1) != 0;
+            return false;
         }
     }
 
@@ -254,8 +273,43 @@ public:
 
 #endif
 
+    bool has_location() const BOOST_NOEXCEPT
+    {
+        return lc_flags_ >= 4;
+    }
+
+    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;
+    }
+
     // relationals:
 
+private:
+
+    // private equality for use in error_category::equivalent
+
+    friend class error_category;
+
+    BOOST_SYSTEM_CONSTEXPR bool equals( int val, error_category const& cat ) const BOOST_NOEXCEPT
+    {
+        if( lc_flags_ == 0 )
+        {
+            return val == 0 && cat.id_ == detail::system_category_id;
+        }
+        else if( lc_flags_ == 1 )
+        {
+            return cat.id_ == detail::interop_category_id && val == value();
+        }
+        else
+        {
+            return val == d1_.val_ && cat == *d1_.cat_;
+        }
+    }
+
+public:
+
     //  the more symmetrical non-member syntax allows enum
     //  conversions work for both rhs and lhs.
 
@@ -263,7 +317,7 @@ public:
     {
 #if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
 
-        if( lhs.flags_ == 1 && rhs.flags_ == 1 )
+        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_ );
@@ -281,7 +335,7 @@ public:
     {
 #if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
 
-        if( lhs.flags_ == 1 && rhs.flags_ == 1 )
+        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_ );
@@ -304,7 +358,7 @@ public:
     {
 #if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
 
-        if( code.flags_ == 1 )
+        if( code.lc_flags_ == 1 )
         {
             return static_cast<std::error_code>( code ) == static_cast<std::error_condition>( condition );
         }
@@ -320,7 +374,7 @@ public:
     {
 #if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
 
-        if( code.flags_ == 1 )
+        if( code.lc_flags_ == 1 )
         {
             return static_cast<std::error_code>( code ) == static_cast<std::error_condition>( condition );
         }
@@ -444,11 +498,11 @@ public:
 
     operator std::error_code () const
     {
-        if( flags_ == 1 )
+        if( lc_flags_ == 1 )
         {
             return *reinterpret_cast<std::error_code const*>( d2_ );
         }
-        else if( flags_ == 0 )
+        else if( lc_flags_ == 0 )
         {
             //return std::error_code();
             return std::error_code( 0, boost::system::system_category() );
@@ -468,11 +522,11 @@ public:
       class E = typename detail::enable_if<detail::is_same<T, std::error_code>::value>::type>
       operator T& ()
     {
-        if( flags_ != 1 )
+        if( lc_flags_ != 1 )
         {
             std::error_code e2( *this );
             ::new( d2_ ) std::error_code( e2 );
-            flags_ = 1;
+            lc_flags_ = 1;
         }
 
         return *reinterpret_cast<std::error_code*>( d2_ );
@@ -488,24 +542,34 @@ public:
 
 #endif
 
-    template<class Ch, class Tr>
-        inline friend std::basic_ostream<Ch, Tr>&
-        operator<< (std::basic_ostream<Ch, Tr>& os, error_code const & ec)
+    std::string to_string() const
     {
 #if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
 
-        if( ec.flags_ == 1 )
+        if( lc_flags_ == 1 )
         {
-            std::error_code const& e2 = *reinterpret_cast<std::error_code const*>( ec.d2_ );
-            os << "std:" << e2.category().name() << ':' << e2.value();
+            std::error_code const& e2 = *reinterpret_cast<std::error_code const*>( d2_ );
+
+            std::string r( "std:" );
+            r += e2.category().name();
+            detail::append_int( r, e2.value() );
+
+            return r;
         }
         else
 #endif
         {
-            os << ec.category().name() << ':' << ec.value();
+            std::string r = category().name();
+            detail::append_int( r, value() );
+            return r;
         }
+    }
 
-        return os;
+    template<class Ch, class Tr>
+        inline friend std::basic_ostream<Ch, Tr>&
+        operator<< (std::basic_ostream<Ch, Tr>& os, error_code const & ec)
+    {
+        return os << ec.to_string();
     }
 };
 
@@ -513,7 +577,7 @@ inline std::size_t hash_value( error_code const & ec )
 {
 #if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
 
-    if( ec.flags_ == 1 )
+    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 );

include/boost/system/detail/error_condition.hpp

@@ -3,7 +3,7 @@
 
 //  Copyright Beman Dawes 2006, 2007
 //  Copyright Christoper Kohlhoff 2007
-//  Copyright Peter Dimov 2017, 2018
+//  Copyright Peter Dimov 2017-2021
 //
 //  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)
@@ -15,6 +15,7 @@
 #include <boost/system/detail/enable_if.hpp>
 #include <boost/system/detail/is_same.hpp>
 #include <boost/system/detail/errc.hpp>
+#include <boost/system/detail/append_int.hpp>
 #include <boost/system/is_error_condition_enum.hpp>
 #include <boost/system/detail/config.hpp>
 #include <boost/config.hpp>
@@ -45,25 +46,31 @@ class error_condition
 private:
 
     int val_;
-    bool failed_;
     error_category const * cat_;
 
+private:
+
+    boost::ulong_long_type cat_id() const BOOST_NOEXCEPT
+    {
+        return cat_? cat_->id_: detail::generic_category_id;
+    }
+
 public:
 
     // constructors:
 
     BOOST_SYSTEM_CONSTEXPR error_condition() BOOST_NOEXCEPT:
-        val_( 0 ), failed_( false ), cat_( 0 )
+        val_( 0 ), cat_( 0 )
     {
     }
 
     BOOST_SYSTEM_CONSTEXPR error_condition( int val, const error_category & cat ) BOOST_NOEXCEPT:
-        val_( val ), failed_( detail::failed_impl( val, cat ) ), cat_( &cat )
+        val_( val ), cat_( &cat )
     {
     }
 
     BOOST_SYSTEM_CONSTEXPR explicit error_condition( boost::system::detail::generic_value_tag vt ) BOOST_NOEXCEPT:
-        val_( vt.value ), failed_( vt.value != 0 ), cat_( 0 )
+        val_( vt.value ), cat_( 0 )
     {
     }
 
@@ -77,7 +84,7 @@ public:
 
     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) BOOST_NOEXCEPT:
-        val_( e ), failed_( e != 0 ), cat_( 0 )
+        val_( e ), cat_( 0 )
     {
     }
 
@@ -86,7 +93,6 @@ public:
     BOOST_SYSTEM_CONSTEXPR void assign( int val, const error_category & cat ) BOOST_NOEXCEPT
     {
         val_ = val;
-        failed_ = detail::failed_impl( val, cat );
         cat_ = &cat;
     }
 
@@ -101,7 +107,6 @@ public:
     BOOST_SYSTEM_CONSTEXPR void clear() BOOST_NOEXCEPT
     {
         val_ = 0;
-        failed_ = false;
         cat_ = 0;
     }
 
@@ -125,7 +130,7 @@ public:
         }
         else
         {
-            return generic_category().message( value() );
+            return detail::generic_error_category_message( value() );
         }
     }
 
@@ -137,20 +142,27 @@ public:
         }
         else
         {
-            return generic_category().message( value(), buffer, len );
+            return detail::generic_error_category_message( value(), buffer, len );
         }
     }
 
     BOOST_SYSTEM_CONSTEXPR bool failed() const BOOST_NOEXCEPT
     {
-        return failed_;
+        if( cat_ )
+        {
+            return detail::failed_impl( val_, *cat_ );
+        }
+        else
+        {
+            return val_ != 0;
+        }
     }
 
 #if !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
 
     BOOST_SYSTEM_CONSTEXPR explicit operator bool() const BOOST_NOEXCEPT  // true if error
     {
-        return failed_;
+        return failed();
     }
 
 #else
@@ -160,12 +172,12 @@ public:
 
     BOOST_SYSTEM_CONSTEXPR operator unspecified_bool_type() const BOOST_NOEXCEPT  // true if error
     {
-        return failed_? unspecified_bool_true: 0;
+        return failed()? unspecified_bool_true: 0;
     }
 
     BOOST_SYSTEM_CONSTEXPR bool operator!() const BOOST_NOEXCEPT  // true if no error
     {
-        return !failed_;
+        return !failed();
     }
 
 #endif
@@ -176,7 +188,22 @@ public:
 
     BOOST_SYSTEM_CONSTEXPR inline friend bool operator==( const error_condition & lhs, const error_condition & rhs ) BOOST_NOEXCEPT
     {
-        return lhs.val_ == rhs.val_ && lhs.category() == rhs.category();
+        if( lhs.val_ != rhs.val_ )
+        {
+            return false;
+        }
+        else if( lhs.cat_ == 0 )
+        {
+            return rhs.cat_id() == detail::generic_category_id;
+        }
+        else if( rhs.cat_ == 0 )
+        {
+            return lhs.cat_id() == detail::generic_category_id;
+        }
+        else
+        {
+            return *lhs.cat_ == *rhs.cat_;
+        }
     }
 
     BOOST_SYSTEM_CONSTEXPR inline friend bool operator<( const error_condition & lhs, const error_condition & rhs ) BOOST_NOEXCEPT
@@ -220,14 +247,29 @@ public:
 
 #endif
 
+    std::string to_string() const
+    {
+        std::string r( "cond:" );
+
+        if( cat_ )
+        {
+            r += cat_->name();
+        }
+        else
+        {
+            r += "generic";
+        }
+
+        detail::append_int( r, value() );
+
+        return r;
+    }
+
     template<class Ch, class Tr>
         inline friend std::basic_ostream<Ch, Tr>&
         operator<< (std::basic_ostream<Ch, Tr>& os, error_condition const & en)
     {
-        {
-            os << "cond:" << en.category().name() << ':' << en.value();
-        }
-
+        os << en.to_string();
         return os;
     }
 };

include/boost/system/detail/system_category_condition_win32.hpp

@@ -58,7 +58,9 @@ inline int system_category_condition_win32( int ev ) BOOST_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_UNIT_: return no_such_device;
+    case ERROR_BROKEN_PIPE_: return broken_pipe;
     case ERROR_BUFFER_OVERFLOW_: return filename_too_long;
     case ERROR_BUSY_: return device_or_resource_busy;
     case ERROR_BUSY_DRIVE_: return device_or_resource_busy;
@@ -80,7 +82,8 @@ inline int system_category_condition_win32( int ev ) BOOST_NOEXCEPT
     case ERROR_INVALID_DRIVE_: return no_such_device;
     case ERROR_INVALID_FUNCTION_: return function_not_supported;
     case ERROR_INVALID_HANDLE_: return invalid_argument;
-    case ERROR_INVALID_NAME_: return invalid_argument;
+    case ERROR_INVALID_NAME_: return no_such_file_or_directory;
+    case ERROR_INVALID_PARAMETER_: return invalid_argument;
     case ERROR_LOCK_VIOLATION_: return no_lock_available;
     case ERROR_LOCKED_: return no_lock_available;
     case ERROR_NEGATIVE_SEEK_: return invalid_argument;
@@ -94,6 +97,7 @@ inline int system_category_condition_win32( int ev ) BOOST_NOEXCEPT
     case ERROR_OUTOFMEMORY_: return not_enough_memory;
     case ERROR_PATH_NOT_FOUND_: return no_such_file_or_directory;
     case ERROR_READ_FAULT_: return io_error;
+    case ERROR_REPARSE_TAG_INVALID_: return invalid_argument;
     case ERROR_RETRY_: return resource_unavailable_try_again;
     case ERROR_SEEK_: return io_error;
     case ERROR_SHARING_VIOLATION_: return permission_denied;

include/boost/system/result.hpp

@@ -0,0 +1,507 @@
+#ifndef BOOST_SYSTEM_RESULT_HPP_INCLUDED
+#define BOOST_SYSTEM_RESULT_HPP_INCLUDED
+
+// 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/errc.hpp>
+#include <boost/system/system_error.hpp>
+#include <boost/system/detail/error_code.hpp>
+#include <boost/system/detail/error_category_impl.hpp>
+#include <boost/variant2/variant.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/assert.hpp>
+#include <boost/config.hpp>
+#include <type_traits>
+#include <utility>
+#include <iosfwd>
+
+//
+
+namespace boost
+{
+namespace system
+{
+
+// throw_exception_from_error
+
+BOOST_NORETURN inline void throw_exception_from_error( error_code const & e )
+{
+    boost::throw_exception( system_error( e ) );
+}
+
+// in_place_*
+
+using in_place_value_t = variant2::in_place_index_t<0>;
+constexpr in_place_value_t in_place_value{};
+
+using in_place_error_t = variant2::in_place_index_t<1>;
+constexpr in_place_error_t in_place_error{};
+
+// result
+
+template<class T, class E = error_code> class result
+{
+private:
+
+    variant2::variant<T, E> v_;
+
+public:
+
+    // constructors
+
+    // default
+    template<class En2 = void, class En = typename std::enable_if<
+        std::is_void<En2>::value &&
+        std::is_default_constructible<T>::value
+        >::type>
+    constexpr result()
+        noexcept( std::is_nothrow_default_constructible<T>::value )
+        : v_( in_place_value )
+    {
+    }
+
+    // explicit, value
+    template<class A, class En = typename std::enable_if<
+        std::is_constructible<T, A>::value &&
+        !std::is_convertible<A, T>::value &&
+        !std::is_constructible<E, A>::value
+        >::type>
+    explicit constexpr result( A&& a )
+        noexcept( std::is_nothrow_constructible<T, A>::value )
+        : v_( in_place_value, std::forward<A>(a) )
+    {
+    }
+
+    // explicit, error
+    template<class A, class En2 = void, class En = typename std::enable_if<
+        std::is_constructible<E, A>::value &&
+        !std::is_convertible<A, E>::value &&
+        !std::is_constructible<T, A>::value
+        >::type>
+    explicit constexpr result( A&& a )
+        noexcept( std::is_nothrow_constructible<E, A>::value )
+        : v_( in_place_error, std::forward<A>(a) )
+    {
+    }
+
+    // implicit, value
+    template<class A, class En2 = void, class En3 = void, class En = typename std::enable_if<
+        std::is_convertible<A, T>::value &&
+        !std::is_constructible<E, A>::value
+        >::type>
+    constexpr result( A&& a )
+        noexcept( std::is_nothrow_constructible<T, A>::value )
+        : v_( in_place_value, std::forward<A>(a) )
+    {
+    }
+
+    // implicit, error
+    template<class A, class En2 = void, class En3 = void, class En4 = void, class En = typename std::enable_if<
+        std::is_convertible<A, E>::value &&
+        !std::is_constructible<T, A>::value
+        >::type>
+    constexpr result( A&& a )
+        noexcept( std::is_nothrow_constructible<E, A>::value )
+        : v_( in_place_error, std::forward<A>(a) )
+    {
+    }
+
+    // more than one arg, value
+    template<class... A, class En = typename std::enable_if<
+        std::is_constructible<T, A...>::value &&
+        !std::is_constructible<E, A...>::value &&
+        sizeof...(A) >= 2
+        >::type>
+    constexpr result( A&&... a )
+        noexcept( std::is_nothrow_constructible<T, A...>::value )
+        : v_( in_place_value, std::forward<A>(a)... )
+    {
+    }
+
+    // more than one arg, error
+    template<class... A, class En2 = void, class En = typename std::enable_if<
+        !std::is_constructible<T, A...>::value &&
+        std::is_constructible<E, A...>::value &&
+        sizeof...(A) >= 2
+        >::type>
+    constexpr result( A&&... a )
+        noexcept( std::is_nothrow_constructible<E, A...>::value )
+        : v_( in_place_error, std::forward<A>(a)... )
+    {
+    }
+
+    // tagged, value
+    template<class... A, class En = typename std::enable_if<
+        std::is_constructible<T, A...>::value
+        >::type>
+    constexpr result( in_place_value_t, A&&... a )
+        noexcept( std::is_nothrow_constructible<T, A...>::value )
+        : v_( in_place_value, std::forward<A>(a)... )
+    {
+    }
+
+    // tagged, error
+    template<class... A, class En = typename std::enable_if<
+        std::is_constructible<E, A...>::value
+        >::type>
+    constexpr result( in_place_error_t, A&&... a )
+        noexcept( std::is_nothrow_constructible<E, A...>::value )
+        : v_( in_place_error, std::forward<A>(a)... )
+    {
+    }
+
+    // queries
+
+    constexpr bool has_value() const noexcept
+    {
+        return v_.index() == 0;
+    }
+
+    constexpr bool has_error() const noexcept
+    {
+        return v_.index() != 0;
+    }
+
+    constexpr explicit operator bool() const noexcept
+    {
+        return v_.index() == 0;
+    }
+
+    // checked value access
+#if defined( BOOST_NO_CXX11_REF_QUALIFIERS )
+
+    BOOST_CXX14_CONSTEXPR T value() const
+    {
+        if( has_value() )
+        {
+            return variant2::unsafe_get<0>( v_ );
+        }
+        else
+        {
+            throw_exception_from_error( variant2::unsafe_get<1>( v_ ) );
+        }
+    }
+
+#else
+
+    BOOST_CXX14_CONSTEXPR T& value() &
+    {
+        if( has_value() )
+        {
+            return variant2::unsafe_get<0>( v_ );
+        }
+        else
+        {
+            throw_exception_from_error( variant2::unsafe_get<1>( v_ ) );
+        }
+    }
+
+    BOOST_CXX14_CONSTEXPR T const& value() const&
+    {
+        if( has_value() )
+        {
+            return variant2::unsafe_get<0>( v_ );
+        }
+        else
+        {
+            throw_exception_from_error( variant2::unsafe_get<1>( v_ ) );
+        }
+    }
+
+    BOOST_CXX14_CONSTEXPR T&& value() &&
+    {
+        return std::move( value() );
+    }
+
+    BOOST_CXX14_CONSTEXPR T const&& value() const&&
+    {
+        return std::move( value() );
+    }
+
+#endif
+
+    // unchecked value access
+
+    BOOST_CXX14_CONSTEXPR T* operator->() noexcept
+    {
+        return variant2::get_if<0>( &v_ );
+    }
+
+    BOOST_CXX14_CONSTEXPR T const* operator->() const noexcept
+    {
+        return variant2::get_if<0>( &v_ );
+    }
+
+#if defined( BOOST_NO_CXX11_REF_QUALIFIERS )
+
+    BOOST_CXX14_CONSTEXPR T& operator*() noexcept
+    {
+        T* p = operator->();
+
+        BOOST_ASSERT( p != 0 );
+
+        return *p;
+    }
+
+    BOOST_CXX14_CONSTEXPR T const& operator*() const noexcept
+    {
+        T const* p = operator->();
+
+        BOOST_ASSERT( p != 0 );
+
+        return *p;
+    }
+
+#else
+
+    BOOST_CXX14_CONSTEXPR T& operator*() & noexcept
+    {
+        T* p = operator->();
+
+        BOOST_ASSERT( p != 0 );
+
+        return *p;
+    }
+
+    BOOST_CXX14_CONSTEXPR T const& operator*() const & noexcept
+    {
+        T const* p = operator->();
+
+        BOOST_ASSERT( p != 0 );
+
+        return *p;
+    }
+
+    BOOST_CXX14_CONSTEXPR T&& operator*() && noexcept
+    {
+        return std::move(**this);
+    }
+
+    BOOST_CXX14_CONSTEXPR T const&& operator*() const && noexcept
+    {
+        return std::move(**this);
+    }
+
+#endif
+
+    // error access
+
+    constexpr E error() const
+        noexcept( std::is_nothrow_default_constructible<E>::value && std::is_nothrow_copy_constructible<E>::value )
+    {
+        return has_error()? variant2::unsafe_get<1>( v_ ): E();
+    }
+
+    // swap
+
+    BOOST_CXX14_CONSTEXPR void swap( result& r )
+        noexcept( noexcept( v_.swap( r.v_ ) ) )
+    {
+        v_.swap( r.v_ );
+    }
+
+    friend BOOST_CXX14_CONSTEXPR void swap( result & r1, result & r2 )
+        noexcept( noexcept( r1.swap( r2 ) ) )
+    {
+        r1.swap( r2 );
+    }
+
+    // equality
+
+    friend constexpr bool operator==( result const & r1, result const & r2 )
+        noexcept( noexcept( r1.v_ == r2.v_ ) )
+    {
+        return r1.v_ == r2.v_;
+    }
+
+    friend constexpr bool operator!=( result const & r1, result const & r2 )
+        noexcept( noexcept( !( r1 == r2 ) ) )
+    {
+        return !( r1 == r2 );
+    }
+};
+
+template<class Ch, class Tr, class T, class E> std::basic_ostream<Ch, Tr>& operator<<( std::basic_ostream<Ch, Tr>& os, result<T, E> const & r )
+{
+    if( r.has_value() )
+    {
+        os << "value:" << *r;
+    }
+    else
+    {
+        os << "error:" << r.error();
+    }
+
+    return os;
+}
+
+// result<void>
+
+template<class E> class result<void, E>
+{
+private:
+
+    variant2::variant<variant2::monostate, E> v_;
+
+public:
+
+    // constructors
+
+    // default
+    constexpr result() noexcept
+        : v_( in_place_value )
+    {
+    }
+
+    // explicit, error
+    template<class A, class En = typename std::enable_if<
+        std::is_constructible<E, A>::value &&
+        !std::is_convertible<A, E>::value
+        >::type>
+    explicit constexpr result( A&& a )
+        noexcept( std::is_nothrow_constructible<E, A>::value )
+        : v_( in_place_error, std::forward<A>(a) )
+    {
+    }
+
+    // implicit, error
+    template<class A, class En2 = void, class En = typename std::enable_if<
+        std::is_convertible<A, E>::value
+        >::type>
+    constexpr result( A&& a )
+        noexcept( std::is_nothrow_constructible<E, A>::value )
+        : v_( in_place_error, std::forward<A>(a) )
+    {
+    }
+
+    // more than one arg, error
+    template<class... A, class En2 = void, class En3 = void, class En = typename std::enable_if<
+        std::is_constructible<E, A...>::value &&
+        sizeof...(A) >= 2
+        >::type>
+    constexpr result( A&&... a )
+        noexcept( std::is_nothrow_constructible<E, A...>::value )
+        : v_( in_place_error, std::forward<A>(a)... )
+    {
+    }
+
+    // tagged, value
+    constexpr result( in_place_value_t ) noexcept
+        : v_( in_place_value )
+    {
+    }
+
+    // tagged, error
+    template<class... A, class En = typename std::enable_if<
+        std::is_constructible<E, A...>::value
+        >::type>
+    constexpr result( in_place_error_t, A&&... a )
+        noexcept( std::is_nothrow_constructible<E, A...>::value )
+        : v_( in_place_error, std::forward<A>(a)... )
+    {
+    }
+
+    // queries
+
+    constexpr bool has_value() const noexcept
+    {
+        return v_.index() == 0;
+    }
+
+    constexpr bool has_error() const noexcept
+    {
+        return v_.index() != 0;
+    }
+
+    constexpr explicit operator bool() const noexcept
+    {
+        return v_.index() == 0;
+    }
+
+    // checked value access
+
+    BOOST_CXX14_CONSTEXPR void value() const
+    {
+        if( has_value() )
+        {
+        }
+        else
+        {
+            throw_exception_from_error( variant2::unsafe_get<1>( v_ ) );
+        }
+    }
+
+    // unchecked value access
+
+    BOOST_CXX14_CONSTEXPR void* operator->() noexcept
+    {
+        return variant2::get_if<0>( &v_ );
+    }
+
+    BOOST_CXX14_CONSTEXPR void const* operator->() const noexcept
+    {
+        return variant2::get_if<0>( &v_ );
+    }
+
+    BOOST_CXX14_CONSTEXPR void operator*() const noexcept
+    {
+        BOOST_ASSERT( has_value() );
+    }
+
+    // error access
+
+    constexpr E error() const
+        noexcept( std::is_nothrow_default_constructible<E>::value && std::is_nothrow_copy_constructible<E>::value )
+    {
+        return has_error()? variant2::unsafe_get<1>( v_ ): E();
+    }
+
+    // swap
+
+    BOOST_CXX14_CONSTEXPR void swap( result& r )
+        noexcept( noexcept( v_.swap( r.v_ ) ) )
+    {
+        v_.swap( r.v_ );
+    }
+
+    friend BOOST_CXX14_CONSTEXPR void swap( result & r1, result & r2 )
+        noexcept( noexcept( r1.swap( r2 ) ) )
+    {
+        r1.swap( r2 );
+    }
+
+    // equality
+
+    friend constexpr bool operator==( result const & r1, result const & r2 )
+        noexcept( noexcept( r1.v_ == r2.v_ ) )
+    {
+        return r1.v_ == r2.v_;
+    }
+
+    friend constexpr bool operator!=( result const & r1, result const & r2 )
+        noexcept( noexcept( !( r1 == r2 ) ) )
+    {
+        return !( r1 == r2 );
+    }
+};
+
+template<class Ch, class Tr, class E> std::basic_ostream<Ch, Tr>& operator<<( std::basic_ostream<Ch, Tr>& os, result<void, E> const & r )
+{
+    if( r.has_value() )
+    {
+        os << "value:void";
+    }
+    else
+    {
+        os << "error:" << r.error();
+    }
+
+    return os;
+}
+
+} // namespace system
+} // namespace boost
+
+#endif // #ifndef BOOST_SYSTEM_RESULT_HPP_INCLUDED

include/boost/system/system_error.hpp

@@ -1,84 +1,110 @@
-//  Boost system_error.hpp  --------------------------------------------------//
-
-//  Copyright Beman Dawes 2006
-
-//  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)
-
 #ifndef BOOST_SYSTEM_SYSTEM_ERROR_HPP
 #define BOOST_SYSTEM_SYSTEM_ERROR_HPP
 
-#include <boost/system/error_code.hpp>
+// Copyright Beman Dawes 2006
+// Copyright Peter Dimov 2021
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/errc.hpp>
+#include <boost/system/detail/error_code.hpp>
+#include <boost/system/detail/snprintf.hpp>
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 namespace boost
 {
-  namespace system
-  {
-    //  class system_error  ------------------------------------------------------------//
+namespace system
+{
 
-    class BOOST_SYMBOL_VISIBLE system_error : public std::runtime_error
-    // BOOST_SYMBOL_VISIBLE is needed by GCC to ensure system_error thrown from a shared
-    // library can be caught. See svn.boost.org/trac/boost/ticket/3697
+class BOOST_SYMBOL_VISIBLE system_error: public std::runtime_error
+{
+private:
+
+    error_code code_;
+
+private:
+
+    static std::string to_string( int v )
     {
-    public:
-      explicit system_error( error_code ec )
-          : std::runtime_error(""), m_error_code(ec) {}
+        char buffer[ 32 ];
+        detail::snprintf( buffer, sizeof( buffer ), "%d", v );
 
-      system_error( error_code ec, const std::string & what_arg )
-          : std::runtime_error(what_arg), m_error_code(ec) {}
-
-      system_error( error_code ec, const char* what_arg )
-          : std::runtime_error(what_arg), m_error_code(ec) {}
-
-      system_error( int ev, const error_category & ecat )
-          : std::runtime_error(""), m_error_code(ev,ecat) {}
-
-      system_error( int ev, const error_category & ecat,
-        const std::string & what_arg )
-          : std::runtime_error(what_arg), m_error_code(ev,ecat) {}
-
-      system_error( int ev, const error_category & ecat,
-        const char * what_arg )
-          : std::runtime_error(what_arg), m_error_code(ev,ecat) {}
-
-      virtual ~system_error() BOOST_NOEXCEPT_OR_NOTHROW {}
-
-      error_code code() const BOOST_NOEXCEPT { return m_error_code; }
-      const char * what() const BOOST_NOEXCEPT_OR_NOTHROW BOOST_OVERRIDE;
-
-    private:
-      error_code           m_error_code;
-      mutable std::string  m_what;
-    };
-
-    //  implementation  ------------------------------------------------------//
-
-    inline const char * system_error::what() const BOOST_NOEXCEPT_OR_NOTHROW
-    // see http://www.boost.org/more/error_handling.html for lazy build rationale
-    {
-      if ( m_what.empty() )
-      {
-#ifndef BOOST_NO_EXCEPTIONS
-        try
-#endif
-        {
-          m_what = this->std::runtime_error::what();
-          if ( !m_what.empty() ) m_what += ": ";
-          m_what += m_error_code.message();
-        }
-#ifndef BOOST_NO_EXCEPTIONS
-        catch (...) { return std::runtime_error::what(); }
-#endif
-      }
-      return m_what.c_str();
+        return buffer;
     }
 
-  } // namespace system
+    static std::string build_message( char const * prefix, error_code const & ec )
+    {
+        std::string r;
+
+        if( prefix )
+        {
+            r += prefix;
+            r += ": ";
+        }
+
+        r += ec.message();
+
+        if( ec.has_location() )
+        {
+            r += " [";
+            r += ec.to_string();
+            r += " at ";
+
+            boost::source_location loc = ec.location();
+
+            r += loc.file_name();
+
+            r += ':';
+            r += to_string( loc.line() );
+
+            if( loc.column() != 0 )
+            {
+                r += ':';
+                r += to_string( loc.column() );
+            }
+
+            r += " in function '";
+            r += loc.function_name();
+            r += "\']";
+        }
+
+        return r;
+    }
+
+    static std::string build_message( char const * prefix, int ev, error_category const & cat )
+    {
+        return build_message( prefix, error_code( ev, cat ) );
+    }
+
+public:
+
+    explicit system_error( error_code const & ec )
+      : std::runtime_error( build_message( 0, ec ) ), code_( ec ) {}
+
+    system_error( error_code const & ec, std::string const & prefix )
+      : std::runtime_error( build_message( prefix.c_str(), ec ) ), code_( ec ) {}
+
+    system_error( error_code const & ec, char const * prefix )
+      : std::runtime_error( build_message( prefix, ec ) ), code_( ec ) {}
+
+    system_error( int ev, error_category const & ecat )
+      : std::runtime_error( build_message( 0, ev, ecat ) ), code_( ev, ecat ) {}
+
+    system_error( int ev, error_category const & ecat, std::string const & prefix )
+      : std::runtime_error( build_message( prefix.c_str(), ev, ecat ) ), code_( ev, ecat ) {}
+
+    system_error( int ev, error_category const & ecat, char const * prefix )
+      : std::runtime_error( build_message( prefix, ev, ecat ) ), code_( ev, ecat ) {}
+
+    error_code code() const BOOST_NOEXCEPT
+    {
+        return code_;
+    }
+};
+
+} // namespace system
 } // namespace boost
 
 #endif // BOOST_SYSTEM_SYSTEM_ERROR_HPP
-
-

index.html

@@ -8,8 +8,8 @@ Automatic redirection failed, please go to
 </body>
 </html>
 <!--
-	<EFBFBD> Copyright Beman Dawes, 2001
+	© Copyright Beman Dawes, 2001
 	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
+	https://www.boost.org/LICENSE_1_0.txt
 -->

test/CMakeLists.txt

@@ -98,3 +98,25 @@ boost_test(TYPE run SOURCES std_interop_test6.cpp)
 boost_test(TYPE run SOURCES std_interop_test7.cpp)
 boost_test(TYPE run SOURCES std_interop_test8.cpp)
 boost_test(TYPE run SOURCES std_interop_test9.cpp)
+
+boost_test(TYPE run SOURCES ec_location_test.cpp)
+
+boost_test(TYPE run SOURCES error_condition_test3.cpp)
+boost_test(TYPE run SOURCES error_code_test2.cpp)
+boost_test(TYPE run SOURCES system_error_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)
+boost_test(TYPE run SOURCES result_copy_construct.cpp)
+boost_test(TYPE run SOURCES result_move_construct.cpp)
+boost_test(TYPE run SOURCES result_copy_assign.cpp)
+boost_test(TYPE run SOURCES result_move_assign.cpp)
+boost_test(TYPE run SOURCES result_value_access.cpp)
+boost_test(TYPE run SOURCES result_error_access.cpp)
+boost_test(TYPE run SOURCES result_swap.cpp)
+boost_test(TYPE run SOURCES result_eq.cpp)

test/Jamfile.v2

@@ -1,7 +1,7 @@
 # Boost System Library test Jamfile
 
 # Copyright Beman Dawes 2003, 2006
-# Copyright 2017-2019 Peter Dimov
+# Copyright 2017-2021 Peter Dimov
 
 # Distributed under the Boost Software License, Version 1.0.
 # See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt
@@ -10,6 +10,18 @@
 
 import testing ;
 
+project
+  : default-build
+
+    <warnings>extra
+
+  : requirements
+
+    <toolset>msvc:<warnings-as-errors>on
+    <toolset>gcc:<warnings-as-errors>on
+    <toolset>clang:<warnings-as-errors>on
+  ;
+
 rule system-run ( sources + )
 {
     local result ;
@@ -108,3 +120,27 @@ run std_interop_test6.cpp ;
 run std_interop_test7.cpp ;
 run std_interop_test8.cpp ;
 run std_interop_test9.cpp ;
+
+run ec_location_test.cpp ;
+
+run error_condition_test3.cpp ;
+run error_code_test2.cpp ;
+run system_error_test2.cpp ;
+
+# result
+
+import ../../config/checks/config : requires ;
+
+CPP11 = [ requires cxx11_variadic_templates cxx11_template_aliases cxx11_decltype cxx11_constexpr cxx11_noexcept ] ;
+
+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) ;

test/after_main_test.cpp

@@ -5,8 +5,13 @@
 #include <boost/system/error_code.hpp>
 #include <boost/core/lightweight_test.hpp>
 #include <boost/core/quick_exit.hpp>
+#include <boost/config.hpp>
 #include <cerrno>
 
+#if defined(BOOST_MSVC)
+# pragma warning(disable: 4722) // Z::~Z never returns
+#endif
+
 using namespace boost::system;
 
 struct Z
@@ -27,4 +32,6 @@ static error_code e2( ENOENT, generic_category() );
 
 int main()
 {
+    (void)e1;
+    (void)e2;
 }

test/cmake_subdir_test/CMakeLists.txt

@@ -1,8 +1,8 @@
-# Copyright 2018, 2019 Peter Dimov
+# Copyright 2018-2021 Peter Dimov
 # Distributed under the Boost Software License, Version 1.0.
 # See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
 
-cmake_minimum_required(VERSION 3.5...3.16)
+cmake_minimum_required(VERSION 3.5...3.20)
 
 project(cmake_subdir_test LANGUAGES CXX)
 
@@ -10,7 +10,10 @@ add_subdirectory(../.. boostorg/system)
 add_subdirectory(../../../assert boostorg/assert)
 add_subdirectory(../../../config boostorg/config)
 add_subdirectory(../../../core boostorg/core)
+add_subdirectory(../../../mp11 boostorg/mp11)
 add_subdirectory(../../../predef boostorg/predef)
+add_subdirectory(../../../throw_exception boostorg/throw_exception)
+add_subdirectory(../../../variant2 boostorg/variant2)
 add_subdirectory(../../../winapi boostorg/winapi)
 
 add_executable(quick ../quick.cpp)
@@ -19,4 +22,4 @@ target_link_libraries(quick Boost::system Boost::core)
 enable_testing()
 add_test(quick quick)
 
-add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -C $<CONFIG>)
+add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure --no-tests=error -C $<CONFIG>)

test/ec_location_test.cpp

@@ -0,0 +1,116 @@
+// Copyright 2021 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <cerrno>
+
+int main()
+{
+    int const val = ENOENT;
+    boost::system::error_category const & cat = boost::system::generic_category();
+
+    {
+        boost::system::error_code ec( val, cat );
+
+        BOOST_TEST_EQ( ec.value(), val );
+        BOOST_TEST_EQ( &ec.category(), &cat );
+
+        BOOST_TEST( ec.failed() );
+
+        BOOST_TEST( !ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 0 );
+    }
+
+    {
+        BOOST_STATIC_CONSTEXPR boost::source_location loc = BOOST_CURRENT_LOCATION;
+
+        boost::system::error_code ec( val, cat, &loc );
+
+        BOOST_TEST_EQ( ec.value(), val );
+        BOOST_TEST_EQ( &ec.category(), &cat );
+
+        BOOST_TEST( ec.failed() );
+
+        BOOST_TEST( ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 27 );
+    }
+
+    {
+        boost::system::error_code ec;
+
+        BOOST_TEST_EQ( ec.value(), 0 );
+        BOOST_TEST_EQ( &ec.category(), &boost::system::system_category() );
+
+        BOOST_TEST( !ec.failed() );
+
+        BOOST_TEST( !ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 0 );
+
+        BOOST_STATIC_CONSTEXPR boost::source_location loc = BOOST_CURRENT_LOCATION;
+
+        ec = boost::system::error_code( val, cat, &loc );
+
+        BOOST_TEST_EQ( ec.value(), val );
+        BOOST_TEST_EQ( &ec.category(), &cat );
+
+        BOOST_TEST( ec.failed() );
+
+        BOOST_TEST( ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 51 );
+    }
+
+    {
+        boost::system::error_code ec;
+
+        BOOST_TEST_EQ( ec.value(), 0 );
+        BOOST_TEST_EQ( &ec.category(), &boost::system::system_category() );
+
+        BOOST_TEST( !ec.failed() );
+
+        BOOST_TEST( !ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 0 );
+
+        BOOST_STATIC_CONSTEXPR boost::source_location loc = BOOST_CURRENT_LOCATION;
+
+        ec.assign( val, cat, &loc );
+
+        BOOST_TEST_EQ( ec.value(), val );
+        BOOST_TEST_EQ( &ec.category(), &cat );
+
+        BOOST_TEST( ec.failed() );
+
+        BOOST_TEST( ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 75 );
+    }
+
+#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
+
+    {
+        std::error_code e2( val, std::generic_category() );
+
+        boost::system::error_code ec( e2 );
+
+        BOOST_TEST( ec.failed() );
+
+        BOOST_TEST( !ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 0 );
+
+        BOOST_STATIC_CONSTEXPR boost::source_location loc = BOOST_CURRENT_LOCATION;
+
+        ec.assign( val, cat, &loc );
+
+        BOOST_TEST_EQ( ec.value(), val );
+        BOOST_TEST_EQ( &ec.category(), &cat );
+
+        BOOST_TEST( ec.failed() );
+
+        BOOST_TEST( ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 100 );
+    }
+
+#endif
+
+    return boost::report_errors();
+}

test/error_code_test.cpp

@@ -108,6 +108,7 @@ int main( int, char ** )
 
   std::cout << "Conversion use cases...\n";
   error_condition x1( errc::file_exists );
+  (void)x1;
   //error_code x2( errc::file_exists ); // should fail to compile
   make_error_code(errc::file_exists);
   make_error_condition(errc::file_exists);

test/error_code_test2.cpp

@@ -0,0 +1,94 @@
+// Copyright 2020, 2021 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>
+
+namespace sys = boost::system;
+
+int main()
+{
+    char buffer[ 1024 ];
+
+    sys::error_code ec;
+
+    BOOST_TEST_EQ( ec.value(), 0 );
+    BOOST_TEST( ec.category() == sys::system_category() );
+    BOOST_TEST_EQ( ec.message(), ec.category().message( ec.value() ) );
+    BOOST_TEST_CSTR_EQ( ec.message( buffer, sizeof( buffer ) ), ec.category().message( ec.value(), buffer, sizeof( buffer ) ) );
+    BOOST_TEST( !ec.failed() );
+    BOOST_TEST( !ec );
+
+    BOOST_TEST_EQ( ec.to_string(), std::string( "system:0" ) );
+
+    {
+        sys::error_code ec2( ec );
+
+        BOOST_TEST_EQ( ec2.value(), 0 );
+        BOOST_TEST( ec2.category() == sys::system_category() );
+        BOOST_TEST_EQ( ec2.message(), ec2.category().message( ec2.value() ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.category().message( ec2.value(), buffer, sizeof( buffer ) ) );
+        BOOST_TEST( !ec2.failed() );
+        BOOST_TEST( !ec2 );
+
+        BOOST_TEST_EQ( ec, ec2 );
+        BOOST_TEST_NOT( ec != ec2 );
+
+        BOOST_TEST_EQ( ec2.to_string(), std::string( "system:0" ) );
+    }
+
+    {
+        sys::error_code ec2( ec.value(), ec.category() );
+
+        BOOST_TEST_EQ( ec2.value(), 0 );
+        BOOST_TEST( ec2.category() == sys::system_category() );
+        BOOST_TEST_EQ( ec2.message(), ec2.category().message( ec2.value() ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.category().message( ec2.value(), buffer, sizeof( buffer ) ) );
+        BOOST_TEST( !ec2.failed() );
+        BOOST_TEST( !ec2 );
+
+        BOOST_TEST_EQ( ec, ec2 );
+        BOOST_TEST_NOT( ec != ec2 );
+
+        BOOST_TEST_EQ( ec2.to_string(), std::string( "system:0" ) );
+    }
+
+    {
+        sys::error_code ec2( 5, sys::generic_category() );
+
+        BOOST_TEST_EQ( ec2.value(), 5 );
+        BOOST_TEST( ec2.category() == sys::generic_category() );
+        BOOST_TEST_EQ( ec2.message(), ec2.category().message( ec2.value() ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.category().message( ec2.value(), buffer, sizeof( buffer ) ) );
+        BOOST_TEST( ec2.failed() );
+        BOOST_TEST( ec2 );
+        BOOST_TEST_NOT( !ec2 );
+
+        BOOST_TEST_NE( ec, ec2 );
+        BOOST_TEST_NOT( ec == ec2 );
+
+        BOOST_TEST_EQ( ec2.to_string(), std::string( "generic:5" ) );
+    }
+
+    {
+        sys::error_code ec2( 5, sys::system_category() );
+
+        BOOST_TEST_EQ( ec2.value(), 5 );
+        BOOST_TEST( ec2.category() == sys::system_category() );
+        BOOST_TEST_EQ( ec2.message(), ec2.category().message( ec2.value() ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.category().message( ec2.value(), buffer, sizeof( buffer ) ) );
+        BOOST_TEST( ec2.failed() );
+        BOOST_TEST( ec2 );
+        BOOST_TEST_NOT( !ec2 );
+
+        BOOST_TEST_NE( ec, ec2 );
+        BOOST_TEST_NOT( ec == ec2 );
+
+        BOOST_TEST_EQ( ec2.to_string(), std::string( "system:5" ) );
+    }
+
+    return boost::report_errors();
+}

test/error_condition_test3.cpp

@@ -0,0 +1,94 @@
+// Copyright 2020, 2021 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/error_condition.hpp>
+#include <boost/system/generic_category.hpp>
+#include <boost/system/system_category.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+namespace sys = boost::system;
+
+int main()
+{
+    char buffer[ 1024 ];
+
+    sys::error_condition en;
+
+    BOOST_TEST_EQ( en.value(), 0 );
+    BOOST_TEST( en.category() == sys::generic_category() );
+    BOOST_TEST_EQ( en.message(), en.category().message( en.value() ) );
+    BOOST_TEST_CSTR_EQ( en.message( buffer, sizeof( buffer ) ), en.category().message( en.value(), buffer, sizeof( buffer ) ) );
+    BOOST_TEST( !en.failed() );
+    BOOST_TEST( !en );
+
+    BOOST_TEST_EQ( en.to_string(), std::string( "cond:generic:0" ) );
+
+    {
+        sys::error_condition en2( en );
+
+        BOOST_TEST_EQ( en2.value(), 0 );
+        BOOST_TEST( en2.category() == sys::generic_category() );
+        BOOST_TEST_EQ( en2.message(), en2.category().message( en2.value() ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.category().message( en2.value(), buffer, sizeof( buffer ) ) );
+        BOOST_TEST( !en2.failed() );
+        BOOST_TEST( !en2 );
+
+        BOOST_TEST_EQ( en, en2 );
+        BOOST_TEST_NOT( en != en2 );
+
+        BOOST_TEST_EQ( en2.to_string(), std::string( "cond:generic:0" ) );
+    }
+
+    {
+        sys::error_condition en2( en.value(), en.category() );
+
+        BOOST_TEST_EQ( en2.value(), 0 );
+        BOOST_TEST( en2.category() == sys::generic_category() );
+        BOOST_TEST_EQ( en2.message(), en2.category().message( en2.value() ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.category().message( en2.value(), buffer, sizeof( buffer ) ) );
+        BOOST_TEST( !en2.failed() );
+        BOOST_TEST( !en2 );
+
+        BOOST_TEST_EQ( en, en2 );
+        BOOST_TEST_NOT( en != en2 );
+
+        BOOST_TEST_EQ( en2.to_string(), std::string( "cond:generic:0" ) );
+    }
+
+    {
+        sys::error_condition en2( 5, sys::generic_category() );
+
+        BOOST_TEST_EQ( en2.value(), 5 );
+        BOOST_TEST( en2.category() == sys::generic_category() );
+        BOOST_TEST_EQ( en2.message(), en2.category().message( en2.value() ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.category().message( en2.value(), buffer, sizeof( buffer ) ) );
+        BOOST_TEST( en2.failed() );
+        BOOST_TEST( en2 );
+        BOOST_TEST_NOT( !en2 );
+
+        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( 5, sys::system_category() );
+
+        BOOST_TEST_EQ( en2.value(), 5 );
+        BOOST_TEST( en2.category() == sys::system_category() );
+        BOOST_TEST_EQ( en2.message(), en2.category().message( en2.value() ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.category().message( en2.value(), buffer, sizeof( buffer ) ) );
+        BOOST_TEST( en2.failed() );
+        BOOST_TEST( en2 );
+        BOOST_TEST_NOT( !en2 );
+
+        BOOST_TEST_NE( en, en2 );
+        BOOST_TEST_NOT( en == en2 );
+
+        BOOST_TEST_EQ( en2.to_string(), std::string( "cond:system:5" ) );
+    }
+
+    return boost::report_errors();
+}

test/failed_constexpr_test.cpp

@@ -33,6 +33,12 @@ BOOST_STATIC_ASSERT( !ec3.failed() );
 BOOST_STATIC_ASSERT( ec3? false: true );
 BOOST_STATIC_ASSERT( !ec3 );
 
+#if defined(__GNUC__) && __GNUC__ == 7 && __cplusplus == 201703L
+
+// 'cat_' is not a constant expression
+
+#else
+
 constexpr error_condition en1( 1, system_category() );
 
 BOOST_STATIC_ASSERT( en1.failed() );
@@ -51,6 +57,8 @@ BOOST_STATIC_ASSERT( !en3.failed() );
 BOOST_STATIC_ASSERT( en3? false: true );
 BOOST_STATIC_ASSERT( !en3 );
 
+#endif
+
 int main()
 {
 }

test/header_only_test.cpp

@@ -16,8 +16,10 @@
 #include <boost/detail/lightweight_test.hpp>
 #include <boost/system/error_code.hpp>
 
-int main( int, char*[] )
+int main()
 {
-  boost::system::error_code ec( 0, boost::system::system_category() );
-  return ::boost::report_errors();
+    boost::system::error_code ec( 0, boost::system::system_category() );
+    (void)ec;
+
+    return ::boost::report_errors();
 }

test/result_copy_assign.cpp

@@ -0,0 +1,686 @@
+// 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 <iosfwd>
+#include <cerrno>
+
+using namespace boost::system;
+
+struct X
+{
+    static int instances;
+
+    int v_;
+
+    explicit X( int v = 0 ): v_( v ) { ++instances; }
+
+    X( X const& r ): v_( r.v_ ) { ++instances; }
+
+    X& operator=( X const& ) = default;
+
+    ~X() { --instances; }
+};
+
+bool operator==( X const & x1, X const & x2 )
+{
+    return x1.v_ == x2.v_;
+}
+
+std::ostream& operator<<( std::ostream& os, X const & x )
+{
+    os << "X:" << x.v_;
+    return os;
+}
+
+int X::instances = 0;
+
+struct Y
+{
+    static int instances;
+
+    int v_;
+
+    explicit Y( int v = 0 ): v_( v ) { ++instances; }
+
+    Y( Y const& r ) noexcept: v_( r.v_ ) { ++instances; }
+
+    Y& operator=( Y const& ) = default;
+
+    ~Y() { --instances; }
+};
+
+bool operator==( Y const & y1, Y const & y2 )
+{
+    return y1.v_ == y2.v_;
+}
+
+std::ostream& operator<<( std::ostream& os, Y const & y )
+{
+    os << "Y:" << y.v_;
+    return os;
+}
+
+int Y::instances = 0;
+
+int main()
+{
+    // default-initialized lhs
+
+    {
+        result<int> r;
+        result<int> r2;
+
+        r2 = r;
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    {
+        result<int> r;
+        result<int> r2( 1 );
+
+        r2 = r;
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    {
+        result<int> r;
+        result<int> r2( ENOENT, generic_category() );
+
+        r2 = r;
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    {
+        result<int> const r;
+        result<int> r2;
+
+        r2 = r;
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    {
+        result<int> const r;
+        result<int> r2( 1 );
+
+        r2 = r;
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    {
+        result<int> const r;
+        result<int> r2( ENOENT, generic_category() );
+
+        r2 = r;
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        result<X> r;
+        result<X> r2;
+
+        BOOST_TEST_EQ( X::instances, 2 );
+
+        r2 = r;
+
+        BOOST_TEST_EQ( X::instances, 2 );
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        result<X> r;
+        result<X> r2( 1 );
+
+        BOOST_TEST_EQ( X::instances, 2 );
+
+        r2 = r;
+
+        BOOST_TEST_EQ( X::instances, 2 );
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        result<X> r;
+        result<X> r2( ENOENT, generic_category() );
+
+        BOOST_TEST_EQ( X::instances, 1 );
+
+        r2 = r;
+
+        BOOST_TEST_EQ( X::instances, 2 );
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        result<X> const r;
+        result<X> r2;
+
+        BOOST_TEST_EQ( X::instances, 2 );
+
+        r2 = r;
+
+        BOOST_TEST_EQ( X::instances, 2 );
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        result<X> const r;
+        result<X> r2( 1 );
+
+        BOOST_TEST_EQ( X::instances, 2 );
+
+        r2 = r;
+
+        BOOST_TEST_EQ( X::instances, 2 );
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        result<X> const r;
+        result<X> r2( ENOENT, generic_category() );
+
+        BOOST_TEST_EQ( X::instances, 1 );
+
+        r2 = r;
+
+        BOOST_TEST_EQ( X::instances, 2 );
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    // value lhs
+
+    {
+        result<int> r( 0 );
+        result<int> r2;
+
+        r2 = r;
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    {
+        result<int> r( 0 );
+        result<int> r2( 1 );
+
+        r2 = r;
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    {
+        result<int> r( 0 );
+        result<int> r2( ENOENT, generic_category() );
+
+        r2 = r;
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    {
+        result<int> const r( 0 );
+        result<int> r2;
+
+        r2 = r;
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    {
+        result<int> const r( 0 );
+        result<int> r2( 1 );
+
+        r2 = r;
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    {
+        result<int> const r( 0 );
+        result<int> r2( ENOENT, generic_category() );
+
+        r2 = r;
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        result<X> r( 1 );
+        result<X> r2;
+
+        BOOST_TEST_EQ( X::instances, 2 );
+
+        r2 = r;
+
+        BOOST_TEST_EQ( X::instances, 2 );
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        result<X> r( 1 );
+        result<X> r2( 2 );
+
+        BOOST_TEST_EQ( X::instances, 2 );
+
+        r2 = r;
+
+        BOOST_TEST_EQ( X::instances, 2 );
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        result<X> r( 1 );
+        result<X> r2( ENOENT, generic_category() );
+
+        BOOST_TEST_EQ( X::instances, 1 );
+
+        r2 = r;
+
+        BOOST_TEST_EQ( X::instances, 2 );
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        result<X> const r( 1 );
+        result<X> r2;
+
+        BOOST_TEST_EQ( X::instances, 2 );
+
+        r2 = r;
+
+        BOOST_TEST_EQ( X::instances, 2 );
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        result<X> const r( 1 );
+        result<X> r2( 2 );
+
+        BOOST_TEST_EQ( X::instances, 2 );
+
+        r2 = r;
+
+        BOOST_TEST_EQ( X::instances, 2 );
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        result<X> const r( 1 );
+        result<X> r2( ENOENT, generic_category() );
+
+        BOOST_TEST_EQ( X::instances, 1 );
+
+        r2 = r;
+
+        BOOST_TEST_EQ( X::instances, 2 );
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    // error lhs
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<int> r( ec );
+        result<int> r2;
+
+        r2 = r;
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<int> r( ec );
+        result<int> r2( 1 );
+
+        r2 = r;
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<int> r( ec );
+        result<int> r2( ENOENT, generic_category() );
+
+        r2 = r;
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<int> const r( ec );
+        result<int> r2;
+
+        r2 = r;
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<int> const r( ec );
+        result<int> r2( 1 );
+
+        r2 = r;
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<int> const r( ec );
+        result<int> r2( ENOENT, generic_category() );
+
+        r2 = r;
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<X> r( ec );
+        result<X> r2;
+
+        BOOST_TEST_EQ( X::instances, 1 );
+
+        r2 = r;
+
+        BOOST_TEST_EQ( X::instances, 0 );
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<X> r( ec );
+        result<X> r2( 1 );
+
+        BOOST_TEST_EQ( X::instances, 1 );
+
+        r2 = r;
+
+        BOOST_TEST_EQ( X::instances, 0 );
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<X> r( ec );
+        result<X> r2( ENOENT, generic_category() );
+
+        BOOST_TEST_EQ( X::instances, 0 );
+
+        r2 = r;
+
+        BOOST_TEST_EQ( X::instances, 0 );
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<X> const r( ec );
+        result<X> r2;
+
+        BOOST_TEST_EQ( X::instances, 1 );
+
+        r2 = r;
+
+        BOOST_TEST_EQ( X::instances, 0 );
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<X> const r( ec );
+        result<X> r2( 1 );
+
+        BOOST_TEST_EQ( X::instances, 1 );
+
+        r2 = r;
+
+        BOOST_TEST_EQ( X::instances, 0 );
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<X> const r( ec );
+        result<X> r2( ENOENT, generic_category() );
+
+        BOOST_TEST_EQ( X::instances, 0 );
+
+        r2 = r;
+
+        BOOST_TEST_EQ( X::instances, 0 );
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    //
+
+    BOOST_TEST_EQ( Y::instances, 0 );
+
+    {
+        result<std::string, Y> r( 1 );
+        result<std::string, Y> r2( 2 );
+
+        BOOST_TEST_EQ( Y::instances, 2 );
+
+        r2 = r;
+
+        BOOST_TEST_EQ( Y::instances, 2 );
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    BOOST_TEST_EQ( Y::instances, 0 );
+
+    {
+        result<std::string, Y> r( 1 );
+        result<std::string, Y> r2( "str" );
+
+        BOOST_TEST_EQ( Y::instances, 1 );
+
+        r2 = r;
+
+        BOOST_TEST_EQ( Y::instances, 2 );
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    BOOST_TEST_EQ( Y::instances, 0 );
+
+    {
+        result<std::string, Y> const r( 1 );
+        result<std::string, Y> r2( 2 );
+
+        BOOST_TEST_EQ( Y::instances, 2 );
+
+        r2 = r;
+
+        BOOST_TEST_EQ( Y::instances, 2 );
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    BOOST_TEST_EQ( Y::instances, 0 );
+
+    {
+        result<std::string, Y> const r( 1 );
+        result<std::string, Y> r2( "str" );
+
+        BOOST_TEST_EQ( Y::instances, 1 );
+
+        r2 = r;
+
+        BOOST_TEST_EQ( Y::instances, 2 );
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    BOOST_TEST_EQ( Y::instances, 0 );
+
+    // void
+
+    {
+        result<void> r;
+        result<void> r2;
+
+        r2 = r;
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    {
+        result<void> r;
+        result<void> r2( ENOENT, generic_category() );
+
+        r2 = r;
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    {
+        result<void> const r;
+        result<void> r2;
+
+        r2 = r;
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    {
+        result<void> const r;
+        result<void> r2( ENOENT, generic_category() );
+
+        r2 = r;
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<void> r( ec );
+        result<void> r2;
+
+        r2 = r;
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<void> r( ec );
+        result<void> r2( ENOENT, generic_category() );
+
+        r2 = r;
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<void> const r( ec );
+        result<void> r2;
+
+        r2 = r;
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<void> const r( ec );
+        result<void> r2( ENOENT, generic_category() );
+
+        r2 = r;
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    return boost::report_errors();
+}

test/result_copy_construct.cpp

@@ -0,0 +1,181 @@
+// 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>
+
+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; }
+};
+
+bool operator==( X const & x1, X const & x2 )
+{
+    return x1.v_ == x2.v_;
+}
+
+std::ostream& operator<<( std::ostream& os, X const & x )
+{
+    os << "X:" << x.v_;
+    return os;
+}
+
+int X::instances = 0;
+
+int main()
+{
+    {
+        result<int> r;
+        result<int> r2( r );
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    {
+        result<int> const r;
+        result<int> r2( r );
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        result<X> r;
+        result<X> r2( r );
+
+        BOOST_TEST_EQ( r, r2 );
+        BOOST_TEST_EQ( X::instances, 2 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        result<int> r( 1 );
+        result<int> r2( r );
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    {
+        result<int> const r( 1 );
+        result<int> r2( r );
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        result<X> r( 1 );
+        result<X> r2( r );
+
+        BOOST_TEST_EQ( r, r2 );
+        BOOST_TEST_EQ( X::instances, 2 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        result<X> const r( 1 );
+        result<X> r2( r );
+
+        BOOST_TEST_EQ( r, r2 );
+        BOOST_TEST_EQ( X::instances, 2 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<int> r( ec );
+        result<int> r2( r );
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<int> const r( ec );
+        result<int> r2( r );
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        result<std::string, X> r( 1 );
+        result<std::string, X> r2( r );
+
+        BOOST_TEST_EQ( r, r2 );
+        BOOST_TEST_EQ( X::instances, 2 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        result<std::string, X> const r( 1 );
+        result<std::string, X> r2( r );
+
+        BOOST_TEST_EQ( r, r2 );
+        BOOST_TEST_EQ( X::instances, 2 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        result<void> r;
+        result<void> r2( r );
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    {
+        result<void> const r;
+        result<void> r2( r );
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<void> r( ec );
+        result<void> r2( r );
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<void> const r( ec );
+        result<void> r2( r );
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    return boost::report_errors();
+}

test/result_default_construct.cpp

@@ -0,0 +1,41 @@
+// 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>
+
+using namespace boost::system;
+
+struct X
+{
+};
+
+int main()
+{
+    {
+        result<int> r;
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+
+        BOOST_TEST_EQ( r.value(), 0 );
+    }
+
+    {
+        result<X> r;
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+    }
+
+    {
+        result<void> r;
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+    }
+
+    return boost::report_errors();
+}

test/result_eq.cpp

@@ -0,0 +1,153 @@
+// 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 <iosfwd>
+#include <cerrno>
+
+using namespace boost::system;
+
+struct X
+{
+    static int instances;
+
+    int v_;
+
+    explicit X( int v ): v_( v ) { ++instances; }
+
+    X( X const& r ) = delete;
+    X( X&& r ): v_( r.v_ ) { r.v_ = 0; ++instances; }
+
+    X& operator=( X const& ) = delete;
+
+    X& operator=( X&& r )
+    {
+        v_ = r.v_;
+        r.v_ = 0;
+
+        return *this;
+    }
+
+    ~X() { --instances; }
+};
+
+bool operator==( X const & x1, X const & x2 )
+{
+    return x1.v_ == x2.v_;
+}
+
+std::ostream& operator<<( std::ostream& os, X const & x )
+{
+    os << "X:" << x.v_;
+    return os;
+}
+
+int X::instances = 0;
+
+struct Y
+{
+    static int instances;
+
+    int v_;
+
+    explicit Y( int v = 0 ): v_( v ) { ++instances; }
+
+    Y( Y const& r ) noexcept: v_( r.v_ ) { ++instances; }
+    Y( Y&& r ) noexcept: v_( r.v_ ) { r.v_ = 0; ++instances; }
+
+    Y& operator=( Y const& ) = default;
+
+    Y& operator=( Y&& r )
+    {
+        v_ = r.v_;
+        r.v_ = 0;
+
+        return *this;
+    }
+
+    ~Y() { --instances; }
+};
+
+bool operator==( Y const & y1, Y const & y2 )
+{
+    return y1.v_ == y2.v_;
+}
+
+std::ostream& operator<<( std::ostream& os, Y const & y )
+{
+    os << "Y:" << y.v_;
+    return os;
+}
+
+int Y::instances = 0;
+
+int main()
+{
+    {
+        result<int> r1( 1 );
+        result<int> r2( 2 );
+
+        BOOST_TEST_EQ( r1, r1 );
+        BOOST_TEST_NE( r1, r2 );
+    }
+
+    {
+        result<int> r1( 1, generic_category() );
+        result<int> r2( 2, generic_category() );
+
+        BOOST_TEST_EQ( r1, r1 );
+        BOOST_TEST_NE( r1, r2 );
+    }
+
+    {
+        result<int> r1( 1 );
+        result<int> r2( 2, generic_category() );
+
+        BOOST_TEST_EQ( r1, r1 );
+        BOOST_TEST_NE( r1, r2 );
+    }
+
+    {
+        result<X, Y> r1( in_place_value, 1 );
+        result<X, Y> r2( in_place_value, 2 );
+
+        BOOST_TEST_EQ( r1, r1 );
+        BOOST_TEST_NE( 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 );
+    }
+
+    {
+        result<X, Y> r1( in_place_value, 1 );
+        result<X, Y> r2( in_place_error, 2 );
+
+        BOOST_TEST_EQ( r1, r1 );
+        BOOST_TEST_NE( r1, r2 );
+    }
+
+    {
+        result<void> r1;
+        result<void> r2;
+
+        BOOST_TEST_EQ( r1, r1 );
+        BOOST_TEST_EQ( r1, r2 );
+    }
+
+    {
+        result<void> r1( 1, generic_category() );
+        result<void> r2( 2, generic_category() );
+
+        BOOST_TEST_EQ( r1, r1 );
+        BOOST_TEST_NE( r1, r2 );
+    }
+
+    return boost::report_errors();
+}

test/result_error_access.cpp

@@ -0,0 +1,212 @@
+// 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>
+
+using namespace boost::system;
+
+struct X
+{
+    int v_;
+
+    explicit X( int v = 0 ): v_( v ) {}
+
+    X( X const& ) = default;
+    X& operator=( X const& ) = delete;
+};
+
+int main()
+{
+    {
+        result<int> r;
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+
+        BOOST_TEST_EQ( r.error(), error_code() );
+    }
+
+    {
+        result<int> const r;
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+
+        BOOST_TEST_EQ( r.error(), error_code() );
+    }
+
+    {
+        BOOST_TEST( result<int>().has_value() );
+        BOOST_TEST( !result<int>().has_error() );
+
+        BOOST_TEST_EQ( result<int>().error(), error_code() );
+    }
+
+    {
+        result<int> r( 1 );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+
+        BOOST_TEST_EQ( r.error(), error_code() );
+    }
+
+    {
+        result<int> const r( 1 );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+
+        BOOST_TEST_EQ( r.error(), error_code() );
+    }
+
+    {
+        BOOST_TEST( result<int>( 1 ).has_value() );
+        BOOST_TEST( !result<int>( 1 ).has_error() );
+
+        BOOST_TEST_EQ( result<int>( 1 ).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 );
+    }
+
+    {
+        result<std::string, X> r( 1 );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_EQ( r.error().v_, 1 );
+    }
+
+    {
+        result<std::string, X> const r( 1 );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_EQ( 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( r.error().v_, 0 );
+    }
+
+    {
+        result<std::string, X> const r( "s" );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+
+        BOOST_TEST_EQ( 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> r;
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+
+        BOOST_TEST_EQ( r.error(), error_code() );
+    }
+
+    {
+        result<void> const r;
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+
+        BOOST_TEST_EQ( r.error(), error_code() );
+    }
+
+    {
+        BOOST_TEST( result<void>().has_value() );
+        BOOST_TEST( !result<void>().has_error() );
+
+        BOOST_TEST_EQ( result<void>().error(), error_code() );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<void> 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<void> 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<void>( ec ).has_value() );
+        BOOST_TEST( result<void>( ec ).has_error() );
+
+        BOOST_TEST_EQ( result<void>( ec ).error(), ec );
+    }
+
+    return boost::report_errors();
+}

test/result_error_construct.cpp

@@ -0,0 +1,185 @@
+// 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(), std::error_code( EINVAL, generic_category() ) );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<std::error_code> r( in_place_error, ec );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_EQ( r.error(), ec );
+    }
+
+    {
+        result<std::error_code> r( in_place_error, EINVAL, generic_category() );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_EQ( r.error(), std::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>, std::error_code>));
+        BOOST_TEST_TRAIT_TRUE((std::is_convertible<std::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_FALSE((std::is_constructible<result<int, X>, int>));
+        BOOST_TEST_TRAIT_FALSE((std::is_convertible<int, result<int, X>>));
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<void> 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<void> r = ec;
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_EQ( r.error(), ec );
+    }
+
+    {
+        result<void> r( EINVAL, generic_category() );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_EQ( r.error(), std::error_code( EINVAL, generic_category() ) );
+    }
+
+    return boost::report_errors();
+}

test/result_move_assign.cpp

@@ -0,0 +1,604 @@
+// 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 <iosfwd>
+#include <cerrno>
+
+using namespace boost::system;
+
+struct X
+{
+    static int instances;
+
+    int v_;
+
+    explicit X( int v = 0 ): v_( v ) { ++instances; }
+
+    X( X const& r ) = delete;
+    X( X&& r ): v_( r.v_ ) { r.v_ = 0; ++instances; }
+
+    X& operator=( X const& ) = delete;
+
+    X& operator=( X&& r )
+    {
+        v_ = r.v_;
+        r.v_ = 0;
+
+        return *this;
+    }
+
+    ~X() { --instances; }
+};
+
+bool operator==( X const & x1, X const & x2 )
+{
+    return x1.v_ == x2.v_;
+}
+
+std::ostream& operator<<( std::ostream& os, X const & x )
+{
+    os << "X:" << x.v_;
+    return os;
+}
+
+int X::instances = 0;
+
+struct Y
+{
+    static int instances;
+
+    int v_;
+
+    explicit Y( int v = 0 ): v_( v ) { ++instances; }
+
+    Y( Y const& r ) noexcept: v_( r.v_ ) { ++instances; }
+    Y( Y&& r ) noexcept: v_( r.v_ ) { r.v_ = 0; ++instances; }
+
+    Y& operator=( Y const& ) = default;
+
+    Y& operator=( Y&& r )
+    {
+        v_ = r.v_;
+        r.v_ = 0;
+
+        return *this;
+    }
+
+    ~Y() { --instances; }
+};
+
+bool operator==( Y const & y1, Y const & y2 )
+{
+    return y1.v_ == y2.v_;
+}
+
+std::ostream& operator<<( std::ostream& os, Y const & y )
+{
+    os << "Y:" << y.v_;
+    return os;
+}
+
+int Y::instances = 0;
+
+int main()
+{
+    // default-initialized lhs
+
+    {
+        result<int> r;
+        result<int> r2;
+
+        r2 = std::move( r );
+
+        BOOST_TEST( r2.has_value() );
+        BOOST_TEST( !r2.has_error() );
+
+        BOOST_TEST_EQ( r2.value(), 0 );
+    }
+
+    {
+        result<int> r2;
+
+        r2 = result<int>();
+
+        BOOST_TEST( r2.has_value() );
+        BOOST_TEST( !r2.has_error() );
+
+        BOOST_TEST_EQ( r2.value(), 0 );
+    }
+
+    {
+        result<int> r;
+        result<int> r2( 1 );
+
+        r2 = std::move( r );
+
+        BOOST_TEST( r2.has_value() );
+        BOOST_TEST( !r2.has_error() );
+
+        BOOST_TEST_EQ( r2.value(), 0 );
+    }
+
+    {
+        result<int> r2( 1 );
+
+        r2 = result<int>();
+
+        BOOST_TEST( r2.has_value() );
+        BOOST_TEST( !r2.has_error() );
+
+        BOOST_TEST_EQ( r2.value(), 0 );
+    }
+
+    {
+        result<int> r;
+        result<int> r2( ENOENT, generic_category() );
+
+        r2 = std::move( r );
+
+        BOOST_TEST( r2.has_value() );
+        BOOST_TEST( !r2.has_error() );
+
+        BOOST_TEST_EQ( r2.value(), 0 );
+    }
+
+    {
+        result<int> r2( ENOENT, generic_category() );
+
+        r2 = result<int>();
+
+        BOOST_TEST( r2.has_value() );
+        BOOST_TEST( !r2.has_error() );
+
+        BOOST_TEST_EQ( r2.value(), 0 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        result<X> r;
+        result<X> r2;
+
+        BOOST_TEST_EQ( X::instances, 2 );
+
+        r2 = std::move( r );
+
+        BOOST_TEST_EQ( X::instances, 2 );
+
+        BOOST_TEST( r2.has_value() );
+        BOOST_TEST( !r2.has_error() );
+
+        BOOST_TEST_EQ( r2.value(), X() );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        result<X> r;
+        result<X> r2( 1 );
+
+        BOOST_TEST_EQ( X::instances, 2 );
+
+        r2 = std::move( r );
+
+        BOOST_TEST_EQ( X::instances, 2 );
+
+        BOOST_TEST( r2.has_value() );
+        BOOST_TEST( !r2.has_error() );
+
+        BOOST_TEST_EQ( r2.value(), X() );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        result<X> r;
+        result<X> r2( ENOENT, generic_category() );
+
+        BOOST_TEST_EQ( X::instances, 1 );
+
+        r2 = std::move( r );
+
+        BOOST_TEST_EQ( X::instances, 2 );
+
+        BOOST_TEST( r2.has_value() );
+        BOOST_TEST( !r2.has_error() );
+
+        BOOST_TEST_EQ( r2.value(), X() );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    // value lhs
+
+    {
+        result<int> r( 1 );
+        result<int> r2;
+
+        r2 = std::move( r );
+
+        BOOST_TEST( r2.has_value() );
+        BOOST_TEST( !r2.has_error() );
+
+        BOOST_TEST_EQ( r2.value(), 1 );
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    {
+        result<int> r( 1 );
+        result<int> r2( 2 );
+
+        r2 = std::move( r );
+
+        BOOST_TEST( r2.has_value() );
+        BOOST_TEST( !r2.has_error() );
+
+        BOOST_TEST_EQ( r2.value(), 1 );
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    {
+        result<int> r( 1 );
+        result<int> r2( ENOENT, generic_category() );
+
+        r2 = std::move( r );
+
+        BOOST_TEST( r2.has_value() );
+        BOOST_TEST( !r2.has_error() );
+
+        BOOST_TEST_EQ( r2.value(), 1 );
+
+        BOOST_TEST_EQ( r, r2 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        result<X> r( 1 );
+        result<X> r2;
+
+        BOOST_TEST_EQ( X::instances, 2 );
+
+        r2 = std::move( r );
+
+        BOOST_TEST_EQ( X::instances, 2 );
+
+        BOOST_TEST( r2.has_value() );
+        BOOST_TEST( !r2.has_error() );
+
+        BOOST_TEST_EQ( r2.value().v_, 1 );
+
+        BOOST_TEST_EQ( r.value().v_, 0 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        result<X> r( 1 );
+        result<X> r2( 2 );
+
+        BOOST_TEST_EQ( X::instances, 2 );
+
+        r2 = std::move( r );
+
+        BOOST_TEST_EQ( X::instances, 2 );
+
+        BOOST_TEST( r2.has_value() );
+        BOOST_TEST( !r2.has_error() );
+
+        BOOST_TEST_EQ( r2.value().v_, 1 );
+
+        BOOST_TEST_EQ( r.value().v_, 0 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        result<X> r( 1 );
+        result<X> r2( ENOENT, generic_category() );
+
+        BOOST_TEST_EQ( X::instances, 1 );
+
+        r2 = std::move( r );
+
+        BOOST_TEST_EQ( X::instances, 2 );
+
+        BOOST_TEST( r2.has_value() );
+        BOOST_TEST( !r2.has_error() );
+
+        BOOST_TEST_EQ( r2.value().v_, 1 );
+
+        BOOST_TEST_EQ( r.value().v_, 0 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    // error lhs
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<int> r( ec );
+        result<int> r2;
+
+        r2 = std::move( r );
+
+        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;
+
+        r2 = result<int>( ec );
+
+        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> r( ec );
+        result<int> r2( 1 );
+
+        r2 = std::move( r );
+
+        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( 1 );
+
+        r2 = result<int>( ec );
+
+        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> r( ec );
+        result<int> r2( ENOENT, generic_category() );
+
+        r2 = std::move( r );
+
+        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 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<X> r( ec );
+        result<X> r2;
+
+        BOOST_TEST_EQ( X::instances, 1 );
+
+        r2 = std::move( r );
+
+        BOOST_TEST_EQ( X::instances, 0 );
+
+        BOOST_TEST( !r2.has_value() );
+        BOOST_TEST( r2.has_error() );
+
+        BOOST_TEST_EQ( r2.error(), ec );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<X> r( ec );
+        result<X> r2( 1 );
+
+        BOOST_TEST_EQ( X::instances, 1 );
+
+        r2 = std::move( r );
+
+        BOOST_TEST_EQ( X::instances, 0 );
+
+        BOOST_TEST( !r2.has_value() );
+        BOOST_TEST( r2.has_error() );
+
+        BOOST_TEST_EQ( r2.error(), ec );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<X> r( ec );
+        result<X> r2( ENOENT, generic_category() );
+
+        BOOST_TEST_EQ( X::instances, 0 );
+
+        r2 = std::move( r );
+
+        BOOST_TEST_EQ( X::instances, 0 );
+
+        BOOST_TEST( !r2.has_value() );
+        BOOST_TEST( r2.has_error() );
+
+        BOOST_TEST_EQ( r2.error(), ec );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    //
+
+    BOOST_TEST_EQ( Y::instances, 0 );
+
+    {
+        result<std::string, Y> r( 1 );
+        result<std::string, Y> r2( 2 );
+
+        BOOST_TEST_EQ( Y::instances, 2 );
+
+        r2 = std::move( r );
+
+        BOOST_TEST_EQ( Y::instances, 2 );
+
+        BOOST_TEST( !r2.has_value() );
+        BOOST_TEST( r2.has_error() );
+
+        BOOST_TEST_EQ( r2.error().v_, 1 );
+
+        BOOST_TEST_EQ( r.error().v_, 0 );
+    }
+
+    BOOST_TEST_EQ( Y::instances, 0 );
+
+    {
+        result<std::string, Y> r( 1 );
+        result<std::string, Y> r2( "str" );
+
+        BOOST_TEST_EQ( Y::instances, 1 );
+
+        r2 = std::move( r );
+
+        BOOST_TEST_EQ( Y::instances, 2 );
+
+        BOOST_TEST( !r2.has_value() );
+        BOOST_TEST( r2.has_error() );
+
+        BOOST_TEST_EQ( r2.error().v_, 1 );
+
+        BOOST_TEST_EQ( r.error().v_, 0 );
+    }
+
+    BOOST_TEST_EQ( Y::instances, 0 );
+
+    {
+        result<void> r;
+        result<void> r2;
+
+        r2 = std::move( r );
+
+        BOOST_TEST( r2.has_value() );
+        BOOST_TEST( !r2.has_error() );
+    }
+
+    {
+        result<void> r2;
+
+        r2 = result<void>();
+
+        BOOST_TEST( r2.has_value() );
+        BOOST_TEST( !r2.has_error() );
+    }
+
+    {
+        result<void> r;
+        result<void> r2( ENOENT, generic_category() );
+
+        r2 = std::move( r );
+
+        BOOST_TEST( r2.has_value() );
+        BOOST_TEST( !r2.has_error() );
+    }
+
+    {
+        result<void> r2( ENOENT, generic_category() );
+
+        r2 = result<void>();
+
+        BOOST_TEST( r2.has_value() );
+        BOOST_TEST( !r2.has_error() );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<void> r( ec );
+        result<void> r2;
+
+        r2 = std::move( r );
+
+        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<void> r2;
+
+        r2 = result<void>( ec );
+
+        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<void> r( ec );
+        result<void> r2( ENOENT, generic_category() );
+
+        r2 = std::move( r );
+
+        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<void> r2( ENOENT, generic_category() );
+
+        r2 = result<void>( ec );
+
+        BOOST_TEST( !r2.has_value() );
+        BOOST_TEST( r2.has_error() );
+
+        BOOST_TEST_EQ( r2.error(), ec );
+    }
+
+    return boost::report_errors();
+}

test/result_move_construct.cpp

@@ -0,0 +1,249 @@
+// 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>
+
+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( X&& r ): v_( r.v_ ) { r.v_ = 0; ++instances; }
+
+    X& operator=( X const& ) = delete;
+
+    ~X() { --instances; }
+};
+
+bool operator==( X const & x1, X const & x2 )
+{
+    return x1.v_ == x2.v_;
+}
+
+std::ostream& operator<<( std::ostream& os, X const & x )
+{
+    os << "X:" << x.v_;
+    return os;
+}
+
+int X::instances = 0;
+
+int main()
+{
+    {
+        result<int> r;
+        result<int> r2( std::move( r ) );
+
+        BOOST_TEST( r2.has_value() );
+        BOOST_TEST( !r2.has_error() );
+
+        BOOST_TEST_EQ( r2.value(), 0 );
+    }
+
+    {
+        result<int> r2( result<int>{} );
+
+        BOOST_TEST( r2.has_value() );
+        BOOST_TEST( !r2.has_error() );
+
+        BOOST_TEST_EQ( r2.value(), 0 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        result<X> r;
+        result<X> r2( std::move( r ) );
+
+        BOOST_TEST( r2.has_value() );
+        BOOST_TEST( !r2.has_error() );
+
+        BOOST_TEST_EQ( r2.value(), X() );
+
+        BOOST_TEST_EQ( X::instances, 2 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        result<X> r2( result<X>{} );
+
+        BOOST_TEST( r2.has_value() );
+        BOOST_TEST( !r2.has_error() );
+
+        BOOST_TEST_EQ( r2.value(), X() );
+
+        BOOST_TEST_EQ( X::instances, 1 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        result<int> r( 1 );
+        result<int> r2( std::move( r ) );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+
+        BOOST_TEST_EQ( r.value(), 1 );
+
+        BOOST_TEST( r2.has_value() );
+        BOOST_TEST( !r2.has_error() );
+
+        BOOST_TEST_EQ( r2.value(), 1 );
+    }
+
+    {
+        result<int> r2( result<int>( 1 ) );
+
+        BOOST_TEST( r2.has_value() );
+        BOOST_TEST( !r2.has_error() );
+
+        BOOST_TEST_EQ( r2.value(), 1 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        result<X> r( 1 );
+        result<X> r2( std::move( r ) );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+
+        BOOST_TEST_EQ( r.value().v_, 0 );
+
+        BOOST_TEST( r2.has_value() );
+        BOOST_TEST( !r2.has_error() );
+
+        BOOST_TEST_EQ( r2.value().v_, 1 );
+
+        BOOST_TEST_EQ( X::instances, 2 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        result<X> r2( result<X>( 1 ) );
+
+        BOOST_TEST( r2.has_value() );
+        BOOST_TEST( !r2.has_error() );
+
+        BOOST_TEST_EQ( r2.value().v_, 1 );
+
+        BOOST_TEST_EQ( X::instances, 1 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<int> r( ec );
+        result<int> r2( std::move( r ) );
+
+        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( result<int>{ ec } );
+
+        BOOST_TEST( !r2.has_value() );
+        BOOST_TEST( r2.has_error() );
+
+        BOOST_TEST_EQ( r2.error(), ec );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        result<std::string, X> r( 1 );
+        result<std::string, X> r2( std::move( r ) );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_EQ( r.error().v_, 0 );
+
+        BOOST_TEST( !r2.has_value() );
+        BOOST_TEST( r2.has_error() );
+
+        BOOST_TEST_EQ( r2.error().v_, 1 );
+
+        BOOST_TEST_EQ( X::instances, 2 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        result<std::string, X> r2( result<std::string, X>( 1 ) );
+
+        BOOST_TEST( !r2.has_value() );
+        BOOST_TEST( r2.has_error() );
+
+        BOOST_TEST_EQ( r2.error().v_, 1 );
+
+        BOOST_TEST_EQ( X::instances, 1 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        result<void> r;
+        result<void> r2( std::move( r ) );
+
+        BOOST_TEST( r2.has_value() );
+        BOOST_TEST( !r2.has_error() );
+    }
+
+    {
+        result<void> r2( result<void>{} );
+
+        BOOST_TEST( r2.has_value() );
+        BOOST_TEST( !r2.has_error() );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<void> r( ec );
+        result<void> r2( std::move( r ) );
+
+        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<void> r2( result<void>{ ec } );
+
+        BOOST_TEST( !r2.has_value() );
+        BOOST_TEST( r2.has_error() );
+
+        BOOST_TEST_EQ( r2.error(), ec );
+    }
+
+    return boost::report_errors();
+}

test/result_swap.cpp

@@ -0,0 +1,263 @@
+// 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 <iosfwd>
+#include <cerrno>
+
+using namespace boost::system;
+
+struct X
+{
+    static int instances;
+
+    int v_;
+
+    explicit X( int v ): v_( v ) { ++instances; }
+
+    X( X const& r ) = delete;
+    X( X&& r ): v_( r.v_ ) { r.v_ = 0; ++instances; }
+
+    X& operator=( X const& ) = delete;
+
+    X& operator=( X&& r )
+    {
+        v_ = r.v_;
+        r.v_ = 0;
+
+        return *this;
+    }
+
+    ~X() { --instances; }
+};
+
+bool operator==( X const & x1, X const & x2 )
+{
+    return x1.v_ == x2.v_;
+}
+
+std::ostream& operator<<( std::ostream& os, X const & x )
+{
+    os << "X:" << x.v_;
+    return os;
+}
+
+int X::instances = 0;
+
+struct Y
+{
+    static int instances;
+
+    int v_;
+
+    explicit Y( int v = 0 ): v_( v ) { ++instances; }
+
+    Y( Y const& r ) noexcept: v_( r.v_ ) { ++instances; }
+    Y( Y&& r ) noexcept: v_( r.v_ ) { r.v_ = 0; ++instances; }
+
+    Y& operator=( Y const& ) = default;
+
+    Y& operator=( Y&& r )
+    {
+        v_ = r.v_;
+        r.v_ = 0;
+
+        return *this;
+    }
+
+    ~Y() { --instances; }
+};
+
+bool operator==( Y const & y1, Y const & y2 )
+{
+    return y1.v_ == y2.v_;
+}
+
+std::ostream& operator<<( std::ostream& os, Y const & y )
+{
+    os << "Y:" << y.v_;
+    return os;
+}
+
+int Y::instances = 0;
+
+int main()
+{
+    {
+        result<int> r1( 1 ), r1c( r1 );
+        result<int> r2( 2 ), 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 );
+    }
+
+    {
+        result<int> r1( 1 ), 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 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+    BOOST_TEST_EQ( Y::instances, 0 );
+
+    {
+        result<X, Y> r1( in_place_value, 1 ), r1c( in_place_value, 1 );
+        result<X, Y> r2( in_place_value, 2 ), r2c( in_place_value, 2 );
+
+        BOOST_TEST_EQ( X::instances, 4 );
+        BOOST_TEST_EQ( Y::instances, 0 );
+
+        r1.swap( r2 );
+
+        BOOST_TEST_EQ( r1, r2c );
+        BOOST_TEST_EQ( r2, r1c );
+
+        BOOST_TEST_EQ( X::instances, 4 );
+        BOOST_TEST_EQ( Y::instances, 0 );
+
+        swap( r1, r2 );
+
+        BOOST_TEST_EQ( r1, r1c );
+        BOOST_TEST_EQ( r2, r2c );
+
+        BOOST_TEST_EQ( X::instances, 4 );
+        BOOST_TEST_EQ( Y::instances, 0 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+    BOOST_TEST_EQ( Y::instances, 0 );
+
+    {
+        result<X, Y> r1( in_place_error, 1 ), r1c( in_place_error, 1 );
+        result<X, Y> r2( in_place_error, 2 ), r2c( in_place_error, 2 );
+
+        BOOST_TEST_EQ( X::instances, 0 );
+        BOOST_TEST_EQ( Y::instances, 4 );
+
+        r1.swap( r2 );
+
+        BOOST_TEST_EQ( r1, r2c );
+        BOOST_TEST_EQ( r2, r1c );
+
+        BOOST_TEST_EQ( X::instances, 0 );
+        BOOST_TEST_EQ( Y::instances, 4 );
+
+        swap( r1, r2 );
+
+        BOOST_TEST_EQ( r1, r1c );
+        BOOST_TEST_EQ( r2, r2c );
+
+        BOOST_TEST_EQ( X::instances, 0 );
+        BOOST_TEST_EQ( Y::instances, 4 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+    BOOST_TEST_EQ( Y::instances, 0 );
+
+    {
+        result<X, Y> r1( in_place_value, 1 ), r1c( in_place_value, 1 );
+        result<X, Y> r2( in_place_error, 2 ), r2c( in_place_error, 2 );
+
+        BOOST_TEST_EQ( X::instances, 2 );
+        BOOST_TEST_EQ( Y::instances, 2 );
+
+        r1.swap( r2 );
+
+        BOOST_TEST_EQ( r1, r2c );
+        BOOST_TEST_EQ( r2, r1c );
+
+        BOOST_TEST_EQ( X::instances, 2 );
+        BOOST_TEST_EQ( Y::instances, 2 );
+
+        swap( r1, r2 );
+
+        BOOST_TEST_EQ( r1, r1c );
+        BOOST_TEST_EQ( r2, r2c );
+
+        BOOST_TEST_EQ( X::instances, 2 );
+        BOOST_TEST_EQ( Y::instances, 2 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+    BOOST_TEST_EQ( Y::instances, 0 );
+
+    {
+        result<void> r1, r1c( r1 );
+        result<void> r2, 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<void> r1( 1, generic_category() ), r1c( r1 );
+        result<void> 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 );
+    }
+
+    {
+        result<void> r1, r1c( r1 );
+        result<void> 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();
+}

test/result_value_access.cpp

@@ -0,0 +1,345 @@
+// 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>
+
+using namespace boost::system;
+
+struct X
+{
+    int v_;
+
+    explicit X( int v ): v_( v ) {}
+
+    X( X const& ) = delete;
+    X& operator=( X const& ) = delete;
+};
+
+struct Y
+{
+};
+
+struct E
+{
+};
+
+BOOST_NORETURN void throw_exception_from_error( Y const & )
+{
+    throw E();
+}
+
+int main()
+{
+    {
+        result<int> r;
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+
+        BOOST_TEST( r );
+        BOOST_TEST_NOT( !r );
+
+        BOOST_TEST_EQ( r.value(), 0 );
+        BOOST_TEST_EQ( *r, 0 );
+
+        BOOST_TEST_EQ( r.operator->(), &*r );
+    }
+
+    {
+        result<int> const r;
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+
+        BOOST_TEST( r );
+        BOOST_TEST_NOT( !r );
+
+        BOOST_TEST_EQ( r.value(), 0 );
+        BOOST_TEST_EQ( *r, 0 );
+
+        BOOST_TEST_EQ( r.operator->(), &*r );
+    }
+
+    {
+        BOOST_TEST( result<int>().has_value() );
+        BOOST_TEST( !result<int>().has_error() );
+
+        BOOST_TEST( result<int>() );
+        BOOST_TEST_NOT( !result<int>() );
+
+        BOOST_TEST_EQ( result<int>().value(), 0 );
+        BOOST_TEST_EQ( *result<int>(), 0 );
+
+        BOOST_TEST( result<int>().operator->() != 0 );
+    }
+
+    {
+        result<int> r( 1 );
+
+        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 );
+    }
+
+    {
+        result<int> const r( 1 );
+
+        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 );
+    }
+
+    {
+        BOOST_TEST( result<int>( 1 ).has_value() );
+        BOOST_TEST( !result<int>( 1 ).has_error() );
+
+        BOOST_TEST( result<int>( 1 ) );
+        BOOST_TEST_NOT( !result<int>( 1 ) );
+
+        BOOST_TEST_EQ( result<int>( 1 ).value(), 1 );
+        BOOST_TEST_EQ( *result<int>( 1 ), 1 );
+
+        BOOST_TEST( result<int>( 1 ).operator->() != 0 );
+    }
+
+    {
+        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) );
+    }
+
+    {
+        result<X> r( 1 );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+
+        BOOST_TEST( r );
+        BOOST_TEST_NOT( !r );
+
+        BOOST_TEST_EQ( r.value().v_, 1 );
+        BOOST_TEST_EQ( (*r).v_, 1 );
+        BOOST_TEST_EQ( r->v_, 1 );
+
+        BOOST_TEST_EQ( r.operator->(), &*r );
+    }
+
+    {
+        result<X> const r( 1 );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+
+        BOOST_TEST( r );
+        BOOST_TEST_NOT( !r );
+
+        BOOST_TEST_EQ( r.value().v_, 1 );
+        BOOST_TEST_EQ( (*r).v_, 1 );
+        BOOST_TEST_EQ( r->v_, 1 );
+
+        BOOST_TEST_EQ( r.operator->(), &*r );
+    }
+
+    {
+        BOOST_TEST( result<X>( 1 ).has_value() );
+        BOOST_TEST( !result<X>( 1 ).has_error() );
+
+        BOOST_TEST( result<X>( 1 ) );
+        BOOST_TEST_NOT( !result<X>( 1 ) );
+
+        BOOST_TEST_EQ( result<X>( 1 ).value().v_, 1 );
+        BOOST_TEST_EQ( (*result<X>( 1 )).v_, 1 );
+        BOOST_TEST_EQ( result<X>( 1 )->v_, 1 );
+    }
+
+    {
+        auto ec = Y();
+
+        result<X, Y> r( ec );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_NOT( r );
+        BOOST_TEST( !r );
+
+        BOOST_TEST_THROWS( r.value(), E );
+
+        BOOST_TEST_EQ( r.operator->(), static_cast<X*>(0) );
+    }
+
+    {
+        auto ec = Y();
+
+        result<X, Y> 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(), E );
+
+        BOOST_TEST_EQ( r.operator->(), static_cast<X*>(0) );
+    }
+
+    {
+        auto ec = Y();
+
+        BOOST_TEST(( !result<X, Y>( ec ).has_value() ));
+        BOOST_TEST(( result<X, Y>( ec ).has_error() ));
+
+        BOOST_TEST_NOT(( result<X, Y>( ec ) ));
+        BOOST_TEST(( !result<X, Y>( ec ) ));
+
+        BOOST_TEST_THROWS( (result<X, Y>( ec ).value()), E );
+
+        BOOST_TEST_EQ( (result<X, Y>( ec ).operator->()), static_cast<X*>(0) );
+    }
+
+    {
+        result<void> r;
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+
+        BOOST_TEST( r );
+        BOOST_TEST_NOT( !r );
+
+        BOOST_TEST_NO_THROW( r.value() );
+
+        BOOST_TEST( r.operator->() != 0 );
+    }
+
+    {
+        result<void> const r;
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+
+        BOOST_TEST( r );
+        BOOST_TEST_NOT( !r );
+
+        BOOST_TEST_NO_THROW( r.value() );
+
+        BOOST_TEST( r.operator->() != 0 );
+    }
+
+    {
+        BOOST_TEST( result<void>().has_value() );
+        BOOST_TEST( !result<void>().has_error() );
+
+        BOOST_TEST( result<void>() );
+        BOOST_TEST_NOT( !result<void>() );
+
+        BOOST_TEST_NO_THROW( result<void>().value() );
+
+        BOOST_TEST( result<void>().operator->() != 0 );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<void> 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<void*>(0) );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<void> 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<void*>(0) );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        BOOST_TEST( !result<void>( ec ).has_value() );
+        BOOST_TEST( result<void>( ec ).has_error() );
+
+        BOOST_TEST_NOT( result<void>( ec ) );
+        BOOST_TEST( !result<void>( ec ) );
+
+        BOOST_TEST_THROWS( result<void>( ec ).value(), system_error );
+
+        BOOST_TEST_EQ( result<void>( ec ).operator->(), static_cast<void*>(0) );
+    }
+
+    return boost::report_errors();
+}

test/result_value_construct.cpp

@@ -0,0 +1,132 @@
+// 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>
+
+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()
+{
+    {
+        result<int> r( 0 );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+
+        BOOST_TEST_EQ( r.value(), 0 );
+    }
+
+    {
+        result<int> r = 0;
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+
+        BOOST_TEST_EQ( r.value(), 0 );
+    }
+
+    {
+        result<int, int> 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 );
+
+    {
+        result<X> r( 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 );
+
+    {
+        result<X> r( 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 );
+
+    {
+        result<X> r( 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 );
+
+    {
+        result<X, X> 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 );
+
+    {
+        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>, int>));
+        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int, float>, int>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_constructible<result<X>, int>));
+        BOOST_TEST_TRAIT_FALSE((std::is_convertible<int, result<X>>));
+    }
+
+    {
+        result<void> r( in_place_value );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+    }
+
+    return boost::report_errors();
+}

test/std_interop_test.cpp

@@ -44,7 +44,8 @@ static void test_generic_category()
 
     int ev = ENOENT;
 
-    BOOST_TEST_EQ( bt.message( ev ), st.message( ev ) );
+    // Under MSVC, it's "no such file or directory" instead of "No such file or directory"
+    BOOST_TEST_EQ( bt.message( ev ).substr( 1 ), st.message( ev ).substr( 1 ) );
 
     {
         boost::system::error_code bc( ev, bt );

test/std_interop_test6.cpp

@@ -30,7 +30,7 @@ int main()
         BOOST_TEST_EQ( e2, e1 );
         BOOST_TEST_NOT( e2 != e1 );
 
-        BOOST_TEST( e2 == en );
+        BOOST_TEST_EQ( e2, en );
         BOOST_TEST_NOT( e2 != en );
 
         boost::system::error_code e3( e2 );
@@ -51,7 +51,7 @@ int main()
         BOOST_TEST_EQ( e2, e1 );
         BOOST_TEST_NOT( e2 != e1 );
 
-        BOOST_TEST( e2 == en );
+        BOOST_TEST_EQ( e2, en );
         BOOST_TEST_NOT( e2 != en );
 
         boost::system::error_code e3( e2 );
@@ -72,7 +72,7 @@ int main()
         BOOST_TEST_EQ( e2, e1 );
         BOOST_TEST_NOT( e2 != e1 );
 
-        BOOST_TEST( e2 == en );
+        BOOST_TEST_EQ( e2, en );
         BOOST_TEST_NOT( e2 != en );
 
         boost::system::error_code e3( e2 );
@@ -93,7 +93,7 @@ int main()
         BOOST_TEST_EQ( e2, e1 );
         BOOST_TEST_NOT( e2 != e1 );
 
-        BOOST_TEST( e2 == en );
+        BOOST_TEST_EQ( e2, en );
         BOOST_TEST_NOT( e2 != en );
 
         boost::system::error_code e3( e2 );
@@ -114,7 +114,7 @@ int main()
         BOOST_TEST_EQ( e2, e1 );
         BOOST_TEST_NOT( e2 != e1 );
 
-        BOOST_TEST( e2 == en );
+        BOOST_TEST_EQ( e2, en );
         BOOST_TEST_NOT( e2 != en );
 
         boost::system::error_code e3( e2 );

test/system_category_test.cpp

@@ -59,6 +59,7 @@ std::string sys_strerror( int ev )
     };
 
     local_free lf_ = { lpMsgBuf };
+    (void)lf_;
 
     if( retval == 0 )
     {

test/system_error_test.cpp

@@ -51,6 +51,7 @@ namespace
           << ex.what() << "\"\n";
     }
 # endif
+    (void)str;
   }
 
   const boost::uint_least32_t uvalue = 2u;

test/system_error_test2.cpp

@@ -0,0 +1,41 @@
+// Copyright 2021 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/system_error.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <cerrno>
+
+namespace sys = boost::system;
+
+int main()
+{
+    {
+        sys::error_code ec( 5, sys::generic_category() );
+        sys::system_error x1( ec );
+        (void)x1;
+    }
+
+    {
+        sys::error_code ec( 5, sys::system_category() );
+        sys::system_error x1( ec );
+        (void)x1;
+    }
+
+    {
+        sys::system_error x1( make_error_code( sys::errc::invalid_argument ) );
+        (void)x1;
+    }
+
+    {
+        sys::system_error x1( 5, sys::generic_category() );
+        (void)x1;
+    }
+
+    {
+        sys::system_error x1( 5, sys::system_category() );
+        (void)x1;
+    }
+
+    return boost::report_errors();
+}