Add result<U&, E> specialization. Fixes #72.

test/CMakeLists.txt

@@ -164,3 +164,6 @@ boost_test(TYPE run SOURCES result_error_construct4.cpp)
 boost_test(TYPE run SOURCES result_value_construct4.cpp)
 boost_test(TYPE run SOURCES result_value_construct5.cpp)
 boost_test(TYPE run SOURCES result_error_move.cpp)
+boost_test(TYPE run SOURCES result_value_construct6.cpp)
+boost_test(TYPE run SOURCES result_value_construct7.cpp)
+boost_test(TYPE run SOURCES result_error_construct5.cpp)

test/Jamfile.v2

@@ -194,3 +194,6 @@ run result_error_construct4.cpp : : : $(CPP11) ;
 run result_value_construct4.cpp : : : $(CPP11) ;
 run result_value_construct5.cpp : : : $(CPP11) ;
 run result_error_move.cpp : : : $(CPP11) ;
+run result_value_construct6.cpp : : : $(CPP11) ;
+run result_value_construct7.cpp : : : $(CPP11) ;
+run result_error_construct5.cpp : : : $(CPP11) ;

test/result_convert_construct.cpp

@@ -181,6 +181,34 @@ int main()
 
     BOOST_TEST_EQ( X::instances, 0 );
 
+    //
+
+    {
+        int x = 5;
+
+        result<int&> r( x );
+        result<int const&> r2 = r;
+
+        BOOST_TEST( r2 ) && BOOST_TEST_EQ( *r2, 5 );
+    }
+
+    {
+        int x = 6;
+
+        result<int&> const r( x );
+        result<int const&> r2 = r;
+
+        BOOST_TEST( r2 ) && BOOST_TEST_EQ( *r2, 6 );
+    }
+
+    {
+        int x = 7;
+
+        result<int const&> r2 = result<int&>( x );
+
+        BOOST_TEST( r2 ) && BOOST_TEST_EQ( *r2, 7 );
+    }
+
     {
         BOOST_TEST_TRAIT_TRUE((std::is_constructible<result<long>, result<int>>));
         BOOST_TEST_TRAIT_TRUE((std::is_convertible<result<int>, result<long>>));
@@ -196,6 +224,18 @@ int main()
 
         BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int, void*>, result<int, int>>));
         BOOST_TEST_TRAIT_FALSE((std::is_convertible<result<int, int>, result<int, void*>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_constructible<result<int const&>, result<int&>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_convertible<result<int&>, result<int const&>>));
+
+        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int const&>, result<int>>));
+        BOOST_TEST_TRAIT_FALSE((std::is_convertible<result<int>, result<int const&>>));
+
+        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int const&>, result<long&>>));
+        BOOST_TEST_TRAIT_FALSE((std::is_convertible<result<long&>, result<int const&>>));
+
+        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int const&>, result<long const&>>));
+        BOOST_TEST_TRAIT_FALSE((std::is_convertible<result<long const&>, result<int const&>>));
     }
 
     return boost::report_errors();

test/result_copy_assign.cpp

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

test/result_copy_construct.cpp

@@ -145,6 +145,8 @@ int main()
 
     BOOST_TEST_EQ( X::instances, 0 );
 
+    //
+
     {
         result<void> r;
         result<void> r2( r );
@@ -177,5 +179,121 @@ int main()
         BOOST_TEST_EQ( r, r2 );
     }
 
+    //
+
+    {
+        int x1 = 1;
+
+        result<int&> r1( x1 );
+        result<int&> r2( r1 );
+
+        BOOST_TEST_EQ( r1, r2 );
+        BOOST_TEST_EQ( &*r2, &x1 );
+    }
+
+    {
+        int x1 = 1;
+
+        result<int&> const r1( x1 );
+        result<int&> r2( r1 );
+
+        BOOST_TEST_EQ( r1, r2 );
+        BOOST_TEST_EQ( &*r2, &x1 );
+    }
+
+    {
+        int const x1 = 1;
+
+        result<int const&> r1( x1 );
+        result<int const&> r2( r1 );
+
+        BOOST_TEST_EQ( r1, r2 );
+        BOOST_TEST_EQ( &*r2, &x1 );
+    }
+
+    {
+        int const x1 = 1;
+
+        result<int const&> const r1( x1 );
+        result<int const&> r2( r1 );
+
+        BOOST_TEST_EQ( r1, r2 );
+        BOOST_TEST_EQ( &*r2, &x1 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        X x1( 1 );
+
+        result<X&> r1( x1 );
+        result<X&> r2( r1 );
+
+        BOOST_TEST_EQ( r1, r2 );
+        BOOST_TEST_EQ( &*r2, &x1 );
+        BOOST_TEST_EQ( X::instances, 1 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        X x1( 1 );
+
+        result<X&> const r1( x1 );
+        result<X&> r2( r1 );
+
+        BOOST_TEST_EQ( r1, r2 );
+        BOOST_TEST_EQ( &*r2, &x1 );
+        BOOST_TEST_EQ( X::instances, 1 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        X const x1( 1 );
+
+        result<X const&> r1( x1 );
+        result<X const&> r2( r1 );
+
+        BOOST_TEST_EQ( r1, r2 );
+        BOOST_TEST_EQ( &*r2, &x1 );
+        BOOST_TEST_EQ( X::instances, 1 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        X const x1( 1 );
+
+        result<X const&> const r1( x1 );
+        result<X const&> r2( r1 );
+
+        BOOST_TEST_EQ( r1, r2 );
+        BOOST_TEST_EQ( &*r2, &x1 );
+        BOOST_TEST_EQ( X::instances, 1 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<int&> r1( ec );
+        result<int&> r2( r1 );
+
+        BOOST_TEST_EQ( r1, r2 );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<int&> const r1( ec );
+        result<int&> r2( r1 );
+
+        BOOST_TEST_EQ( r1, r2 );
+    }
+
+    //
+
     return boost::report_errors();
 }

test/result_default_construct.cpp

@@ -52,6 +52,9 @@ int main()
 
         BOOST_TEST_TRAIT_FALSE((std::is_default_constructible<result<Y>>));
         BOOST_TEST_TRAIT_FALSE((std::is_default_constructible<result<Y, int>>));
+
+        BOOST_TEST_TRAIT_FALSE((std::is_default_constructible<result<int&>>));
+        BOOST_TEST_TRAIT_FALSE((std::is_default_constructible<result<int&, int>>));
     }
 
     return boost::report_errors();

test/result_emplace.cpp

@@ -172,5 +172,47 @@ int main()
         BOOST_TEST_EQ( Y::instances, 0 );
     }
 
+    {
+        int x1 = 1;
+        result<int&> r( x1 );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST_EQ( r.value(), 1 );
+
+        int x2 = 2;
+        r.emplace( x2 );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST_EQ( r.value(), 2 );
+    }
+
+    {
+        result<int&> r( ENOENT, generic_category() );
+
+        BOOST_TEST( !r.has_value() );
+
+        int x2 = 2;
+        r.emplace( x2 );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST_EQ( r.value(), 2 );
+    }
+
+    BOOST_TEST_EQ( Y::instances, 0 );
+
+    {
+        result<int&, Y> r( in_place_error );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST_EQ( Y::instances, 1 );
+
+        int x2 = 2;
+        r.emplace( x2 );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST_EQ( *r, 2 );
+        BOOST_TEST_EQ( Y::instances, 0 );
+    }
+
     return boost::report_errors();
 }

test/result_eq.cpp

@@ -149,5 +149,83 @@ int main()
         BOOST_TEST_NE( r1, r2 );
     }
 
+    {
+        int x1 = 1;
+        int x2 = 2;
+
+        result<int&> r1( x1 );
+        result<int&> r2( x2 );
+
+        BOOST_TEST_EQ( r1, r1 );
+        BOOST_TEST_NE( r1, r2 );
+    }
+
+    {
+        int x1 = 1;
+        int x2 = 1;
+
+        result<int&> r1( x1 );
+        result<int&> r2( x2 );
+
+        BOOST_TEST_EQ( r1, r2 );
+    }
+
+    {
+        result<int&> r1( 1, generic_category() );
+        result<int&> r2( 2, generic_category() );
+
+        BOOST_TEST_EQ( r1, r1 );
+        BOOST_TEST_NE( r1, r2 );
+    }
+
+    {
+        int x1 = 1;
+
+        result<int&> r1( x1 );
+        result<int&> r2( 2, generic_category() );
+
+        BOOST_TEST_EQ( r1, r1 );
+        BOOST_TEST_NE( r1, r2 );
+    }
+
+    {
+        X x1( 1 );
+        X x2( 2 );
+
+        result<X&, Y> r1( x1 );
+        result<X&, Y> r2( x2 );
+
+        BOOST_TEST_EQ( r1, r1 );
+        BOOST_TEST_NE( r1, r2 );
+    }
+
+    {
+        X x1( 1 );
+        X x2( 1 );
+
+        result<X&, Y> r1( x1 );
+        result<X&, Y> r2( x2 );
+
+        BOOST_TEST_EQ( r1, r2 );
+    }
+
+    {
+        result<X&, Y> r1( in_place_error, 1 );
+        result<X&, Y> r2( in_place_error, 2 );
+
+        BOOST_TEST_EQ( r1, r1 );
+        BOOST_TEST_NE( r1, r2 );
+    }
+
+    {
+        X x1( 1 );
+
+        result<X&, Y> r1( x1 );
+        result<X&, Y> r2( in_place_error, 2 );
+
+        BOOST_TEST_EQ( r1, r1 );
+        BOOST_TEST_NE( r1, r2 );
+    }
+
     return boost::report_errors();
 }

test/result_errc_construct.cpp

@@ -19,5 +19,14 @@ int main()
     BOOST_TEST_TRAIT_FALSE((std::is_convertible<errc::errc_t, result<bool>>));
     BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<bool>, errc::errc_t>));
 
+    BOOST_TEST_TRAIT_FALSE((std::is_convertible<errc::errc_t, result<int const&>>));
+    BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int const&>, errc::errc_t>));
+
+    BOOST_TEST_TRAIT_FALSE((std::is_convertible<errc::errc_t, result<double const&>>));
+    BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<double const&>, errc::errc_t>));
+
+    BOOST_TEST_TRAIT_FALSE((std::is_convertible<errc::errc_t, result<bool const&>>));
+    BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<bool const&>, errc::errc_t>));
+
     return boost::report_errors();
 }

test/result_error_access.cpp

@@ -152,6 +152,8 @@ int main()
         BOOST_TEST_EQ( (result<std::string, X>( "s" ).error().v_), 0 );
     }
 
+    //
+
     {
         result<void> r;
 
@@ -208,5 +210,71 @@ int main()
         BOOST_TEST_EQ( result<void>( ec ).error(), ec );
     }
 
+    //
+
+    {
+        int x1 = 1;
+
+        result<int&> r( x1 );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+
+        BOOST_TEST_EQ( r.error(), error_code() );
+    }
+
+    {
+        int x1 = 1;
+
+        result<int&> const r( x1 );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+
+        BOOST_TEST_EQ( r.error(), error_code() );
+    }
+
+    {
+        int x1 = 1;
+
+        BOOST_TEST( result<int&>( x1 ).has_value() );
+        BOOST_TEST( !result<int&>( x1 ).has_error() );
+
+        BOOST_TEST_EQ( result<int&>( x1 ).error(), error_code() );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<int&> r( ec );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_EQ( r.error(), ec );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<int&> const r( ec );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_EQ( r.error(), ec );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        BOOST_TEST( !result<int&>( ec ).has_value() );
+        BOOST_TEST( result<int&>( ec ).has_error() );
+
+        BOOST_TEST_EQ( result<int&>( ec ).error(), ec );
+    }
+
+    //
+
     return boost::report_errors();
 }

test/result_error_construct3.cpp

@@ -157,5 +157,27 @@ int main()
         BOOST_TEST_EQ( r.error(), error_code( EINVAL, generic_category() ) );
     }
 
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        using R = result<int&>;
+        R r( R::in_place_error, ec );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_EQ( r.error(), ec );
+    }
+
+    {
+        using R = result<int&>;
+        R r( R::in_place_error, EINVAL, generic_category() );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_EQ( r.error(), error_code( EINVAL, generic_category() ) );
+    }
+
     return boost::report_errors();
 }

test/result_error_construct5.cpp

@@ -0,0 +1,160 @@
+// Copyright 2017, 2021 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/result.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <string>
+#include <cerrno>
+
+using namespace boost::system;
+
+struct X
+{
+    static int instances;
+
+    int v_;
+
+    X(): v_() { ++instances; }
+
+    explicit X( int v ): v_( v ) { ++instances; }
+
+    X( int v1, int v2 ): v_( v1+v2 ) { ++instances; }
+    X( int v1, int v2, int v3 ): v_( v1+v2+v3 ) { ++instances; }
+
+    X( X const& r ): v_( r.v_ ) { ++instances; }
+
+    X& operator=( X const& ) = delete;
+
+    ~X() { --instances; }
+};
+
+int X::instances = 0;
+
+int main()
+{
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<int&> r( ec );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_EQ( r.error(), ec );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<int&> r = ec;
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_EQ( r.error(), ec );
+    }
+
+    {
+        result<int&> r( EINVAL, generic_category() );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_EQ( r.error(), error_code( EINVAL, generic_category() ) );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<error_code&> r( in_place_error, ec );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_EQ( r.error(), ec );
+    }
+
+    {
+        result<error_code&> r( in_place_error, EINVAL, generic_category() );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_EQ( r.error(), error_code( EINVAL, generic_category() ) );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        result<std::string&, X> r( 1 );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_EQ( r.error().v_, 1 );
+
+        BOOST_TEST_EQ( X::instances, 1 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        result<int&, X> r( 1, 2 );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_EQ( r.error().v_, 1+2 );
+
+        BOOST_TEST_EQ( X::instances, 1 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        result<int&, X> r( 1, 2, 3 );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_EQ( r.error().v_, 1+2+3 );
+
+        BOOST_TEST_EQ( X::instances, 1 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        result<X&, X> r( in_place_error, 1 );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_EQ( r.error().v_, 1 );
+
+        BOOST_TEST_EQ( X::instances, 1 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        BOOST_TEST_TRAIT_TRUE((std::is_constructible<result<int&>, error_code>));
+        BOOST_TEST_TRAIT_TRUE((std::is_convertible<error_code, result<int&>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_constructible<result<std::string&, X>, int>));
+        BOOST_TEST_TRAIT_FALSE((std::is_convertible<int, result<std::string&, X>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_constructible<result<int&, X>, int>));
+        BOOST_TEST_TRAIT_FALSE((std::is_convertible<int, result<int&, X>>));
+
+        // There's an ambiguity here between int& and X, but since is_convertible
+        // is true, is_constructible can't be false.
+
+        // BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int&, X>, int&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_convertible<int&, result<int&, X>>));
+    }
+
+    return boost::report_errors();
+}

test/result_error_move.cpp

@@ -55,7 +55,9 @@ int main()
         BOOST_TEST_EQ( (result<std::string, X>( "s" ).error().v_), 0 );
     }
 
-      {
+    //
+
+    {
         result<void, X> r( 1 );
 
         BOOST_TEST( !r.has_value() );
@@ -87,5 +89,45 @@ int main()
         BOOST_TEST_EQ( (result<void, X>().error().v_), 0 );
     }
 
+    //
+
+    {
+        result<double&, X> r( 1 );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_EQ( std::move( r ).error().v_, 1 );
+    }
+
+    {
+        BOOST_TEST(( !result<double&, X>( 1 ).has_value() ));
+        BOOST_TEST(( result<double&, X>( 1 ).has_error() ));
+
+        BOOST_TEST_EQ( (result<double&, X>( 1 ).error().v_), 1 );
+    }
+
+    {
+        double x = 1.0;
+
+        result<double&, X> r( x );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+
+        BOOST_TEST_EQ( std::move( r ).error().v_, 0 );
+    }
+
+    {
+        double x = 1.0;
+
+        BOOST_TEST(( result<double&, X>( x ).has_value() ));
+        BOOST_TEST(( !result<double&, X>( x ).has_error() ));
+
+        BOOST_TEST_EQ( (result<double&, X>( x ).error().v_), 0 );
+    }
+
+    //
+
     return boost::report_errors();
 }

test/result_move_assign.cpp

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

test/result_move_construct.cpp

@@ -207,6 +207,8 @@ int main()
 
     BOOST_TEST_EQ( X::instances, 0 );
 
+    //
+
     {
         result<void> r;
         result<void> r2( std::move( r ) );
@@ -245,5 +247,149 @@ int main()
         BOOST_TEST_EQ( r2.error(), ec );
     }
 
+    //
+
+    {
+        int x1 = 1;
+
+        result<int&> r1( x1 );
+        result<int&> r2( std::move( r1 ) );
+
+        BOOST_TEST( r1.has_value() );
+        BOOST_TEST( !r1.has_error() );
+
+        BOOST_TEST_EQ( r1.value(), 1 );
+        BOOST_TEST_EQ( &*r1, &x1 );
+
+        BOOST_TEST( r2.has_value() );
+        BOOST_TEST( !r2.has_error() );
+
+        BOOST_TEST_EQ( r2.value(), 1 );
+        BOOST_TEST_EQ( &*r2, &x1 );
+    }
+
+    {
+        int const x1 = 1;
+
+        result<int const&> r1( x1 );
+        result<int const&> r2( std::move( r1 ) );
+
+        BOOST_TEST( r1.has_value() );
+        BOOST_TEST( !r1.has_error() );
+
+        BOOST_TEST_EQ( r1.value(), 1 );
+        BOOST_TEST_EQ( &*r1, &x1 );
+
+        BOOST_TEST( r2.has_value() );
+        BOOST_TEST( !r2.has_error() );
+
+        BOOST_TEST_EQ( r2.value(), 1 );
+        BOOST_TEST_EQ( &*r2, &x1 );
+    }
+
+    {
+        int x1 = 1;
+
+        result<int&> r2(( result<int&>( x1 ) ));
+
+        BOOST_TEST( r2.has_value() );
+        BOOST_TEST( !r2.has_error() );
+
+        BOOST_TEST_EQ( r2.value(), 1 );
+        BOOST_TEST_EQ( &*r2, &x1 );
+    }
+
+    {
+        int const x1 = 1;
+
+        result<int const&> r2(( result<int const&>( x1 ) ));
+
+        BOOST_TEST( r2.has_value() );
+        BOOST_TEST( !r2.has_error() );
+
+        BOOST_TEST_EQ( r2.value(), 1 );
+        BOOST_TEST_EQ( &*r2, &x1 );
+    }
+
+    {
+        X x1( 1 );
+
+        result<X&> r1( x1 );
+        result<X&> r2( std::move( r1 ) );
+
+        BOOST_TEST( r1.has_value() );
+        BOOST_TEST( !r1.has_error() );
+
+        BOOST_TEST_EQ( r1.value().v_, 1 );
+        BOOST_TEST_EQ( &*r1, &x1 );
+
+        BOOST_TEST( r2.has_value() );
+        BOOST_TEST( !r2.has_error() );
+
+        BOOST_TEST_EQ( r2.value().v_, 1 );
+        BOOST_TEST_EQ( &*r2, &x1 );
+
+        BOOST_TEST_EQ( X::instances, 1 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        X x1( 1 );
+
+        result<X&> r2(( result<X&>( x1 ) ));
+
+        BOOST_TEST( r2.has_value() );
+        BOOST_TEST( !r2.has_error() );
+
+        BOOST_TEST_EQ( r2.value().v_, 1 );
+        BOOST_TEST_EQ( &*r2, &x1 );
+
+        BOOST_TEST_EQ( X::instances, 1 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        X const x1( 1 );
+
+        result<X const&> r1( x1 );
+        result<X const&> r2( std::move( r1 ) );
+
+        BOOST_TEST( r1.has_value() );
+        BOOST_TEST( !r1.has_error() );
+
+        BOOST_TEST_EQ( r1.value().v_, 1 );
+        BOOST_TEST_EQ( &*r1, &x1 );
+
+        BOOST_TEST( r2.has_value() );
+        BOOST_TEST( !r2.has_error() );
+
+        BOOST_TEST_EQ( r2.value().v_, 1 );
+        BOOST_TEST_EQ( &*r2, &x1 );
+
+        BOOST_TEST_EQ( X::instances, 1 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        X const x1( 1 );
+
+        result<X const&> r2(( result<X const&>( x1 ) ));
+
+        BOOST_TEST( r2.has_value() );
+        BOOST_TEST( !r2.has_error() );
+
+        BOOST_TEST_EQ( r2.value().v_, 1 );
+        BOOST_TEST_EQ( &*r2, &x1 );
+
+        BOOST_TEST_EQ( X::instances, 1 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    //
+
     return boost::report_errors();
 }

test/result_swap.cpp

@@ -259,5 +259,55 @@ int main()
         BOOST_TEST_EQ( r2, r2c );
     }
 
+    {
+        int x1 = 1;
+        int x2 = 2;
+
+        result<int&> r1( x1 ), r1c( r1 );
+        result<int&> r2( x2 ), r2c( r2 );
+
+        r1.swap( r2 );
+
+        BOOST_TEST_EQ( r1, r2c );
+        BOOST_TEST_EQ( r2, r1c );
+
+        swap( r1, r2 );
+
+        BOOST_TEST_EQ( r1, r1c );
+        BOOST_TEST_EQ( r2, r2c );
+    }
+
+    {
+        result<int&> r1( 1, generic_category() ), r1c( r1 );
+        result<int&> r2( 2, generic_category() ), r2c( r2 );
+
+        r1.swap( r2 );
+
+        BOOST_TEST_EQ( r1, r2c );
+        BOOST_TEST_EQ( r2, r1c );
+
+        swap( r1, r2 );
+
+        BOOST_TEST_EQ( r1, r1c );
+        BOOST_TEST_EQ( r2, r2c );
+    }
+
+    {
+        int x1 = 1;
+
+        result<int&> r1( x1 ), r1c( r1 );
+        result<int&> r2( 2, generic_category() ), r2c( r2 );
+
+        r1.swap( r2 );
+
+        BOOST_TEST_EQ( r1, r2c );
+        BOOST_TEST_EQ( r2, r1c );
+
+        swap( r1, r2 );
+
+        BOOST_TEST_EQ( r1, r1c );
+        BOOST_TEST_EQ( r2, r2c );
+    }
+
     return boost::report_errors();
 }

test/result_typedefs.cpp

@@ -12,11 +12,28 @@ struct X {};
 int main()
 {
     BOOST_TEST_TRAIT_SAME( result<int>::value_type, int );
-    BOOST_TEST_TRAIT_SAME( result<X>::value_type, X );
-    BOOST_TEST_TRAIT_SAME( result<void>::value_type, void );
-
     BOOST_TEST_TRAIT_SAME( result<int>::error_type, error_code );
+
+    BOOST_TEST_TRAIT_SAME( result<X>::value_type, X );
+    BOOST_TEST_TRAIT_SAME( result<X>::error_type, error_code );
+
+    BOOST_TEST_TRAIT_SAME( result<void>::value_type, void );
+    BOOST_TEST_TRAIT_SAME( result<void>::error_type, error_code );
+
+    BOOST_TEST_TRAIT_SAME( result<int&>::value_type, int& );
+    BOOST_TEST_TRAIT_SAME( result<int&>::error_type, error_code );
+
+    BOOST_TEST_TRAIT_SAME( result<int, X>::value_type, int );
     BOOST_TEST_TRAIT_SAME( result<int, X>::error_type, X );
 
+    BOOST_TEST_TRAIT_SAME( result<X, X>::value_type, X );
+    BOOST_TEST_TRAIT_SAME( result<X, X>::error_type, X );
+
+    BOOST_TEST_TRAIT_SAME( result<void, X>::value_type, void );
+    BOOST_TEST_TRAIT_SAME( result<void, X>::error_type, X );
+
+    BOOST_TEST_TRAIT_SAME( result<int&, X>::value_type, int& );
+    BOOST_TEST_TRAIT_SAME( result<int&, X>::error_type, X );
+
     return boost::report_errors();
 }

test/result_value_access.cpp

@@ -336,6 +336,8 @@ int main()
         BOOST_TEST_EQ( (result<X, Y>( ec ).operator->()), static_cast<X*>(0) );
     }
 
+    //
+
     {
         result<void> r;
 
@@ -497,5 +499,179 @@ int main()
         BOOST_TEST_EQ( r.operator->(), static_cast<void*>(0) );
     }
 
+    //
+
+    {
+        int x1 = 1;
+
+        result<int&> r( x1 );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+
+        BOOST_TEST( r );
+        BOOST_TEST_NOT( !r );
+
+        BOOST_TEST_EQ( r.value(), 1 );
+        BOOST_TEST_EQ( *r, 1 );
+
+        BOOST_TEST_EQ( r.operator->(), &*r );
+    }
+
+    {
+        int x1 = 1;
+
+        result<int&> const r( x1 );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+
+        BOOST_TEST( r );
+        BOOST_TEST_NOT( !r );
+
+        BOOST_TEST_EQ( r.value(), 1 );
+        BOOST_TEST_EQ( *r, 1 );
+
+        BOOST_TEST_EQ( r.operator->(), &*r );
+    }
+
+    {
+        int x1 = 1;
+
+        BOOST_TEST( result<int&>( x1 ).has_value() );
+        BOOST_TEST( !result<int&>( x1 ).has_error() );
+
+        BOOST_TEST( result<int&>( x1 ) );
+        BOOST_TEST_NOT( !result<int&>( x1 ) );
+
+        BOOST_TEST_EQ( result<int&>( x1 ).value(), 1 );
+        BOOST_TEST_EQ( *result<int&>( x1 ), 1 );
+
+        BOOST_TEST_EQ( result<int&>( x1 ).operator->(), &x1 );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<int&> r( ec );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_NOT( r );
+        BOOST_TEST( !r );
+
+        BOOST_TEST_THROWS( r.value(), system_error );
+
+        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<int&> const r( ec );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_NOT( r );
+        BOOST_TEST( !r );
+
+        BOOST_TEST_THROWS( r.value(), system_error );
+
+        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        BOOST_TEST( !result<int&>( ec ).has_value() );
+        BOOST_TEST( result<int&>( ec ).has_error() );
+
+        BOOST_TEST_NOT( result<int&>( ec ) );
+        BOOST_TEST( !result<int&>( ec ) );
+
+        BOOST_TEST_THROWS( result<int&>( ec ).value(), system_error );
+
+        BOOST_TEST_EQ( result<int&>( ec ).operator->(), static_cast<int*>(0) );
+    }
+
+    {
+        auto ec = make_error_code( std::errc::invalid_argument );
+
+        result<int&, std::error_code> const r( ec );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_NOT( r );
+        BOOST_TEST( !r );
+
+        BOOST_TEST_THROWS( r.value(), std::system_error );
+
+        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
+    }
+
+    {
+        result<int&, errc::errc_t> const r( in_place_error, errc::invalid_argument );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_NOT( r );
+        BOOST_TEST( !r );
+
+        BOOST_TEST_THROWS( r.value(), system_error );
+
+        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
+    }
+
+    {
+        result<int&, std::errc> const r( std::errc::invalid_argument );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_NOT( r );
+        BOOST_TEST( !r );
+
+        BOOST_TEST_THROWS( r.value(), std::system_error );
+
+        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
+    }
+
+    {
+        result<int&, std::exception_ptr> const r( std::make_exception_ptr( E2() ) );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_NOT( r );
+        BOOST_TEST( !r );
+
+#if defined(BOOST_CLANG_VERSION) && BOOST_CLANG_VERSION < 30600
+#else
+        BOOST_TEST_THROWS( r.value(), E2 );
+#endif
+
+        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
+    }
+
+    {
+        result<int&, std::exception_ptr> const r( in_place_error );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_NOT( r );
+        BOOST_TEST( !r );
+
+        BOOST_TEST_THROWS( r.value(), std::bad_exception );
+
+        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
+    }
+
+    //
+
     return boost::report_errors();
 }

test/result_value_construct3.cpp

@@ -114,5 +114,29 @@ int main()
         BOOST_TEST( !r.has_error() );
     }
 
+    {
+        int x1 = 1;
+
+        using R = result<int&>;
+        R r( R::in_place_value, x1 );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+
+        BOOST_TEST_EQ( r.value(), 1 );
+    }
+
+    {
+        int x1 = 1;
+
+        using R = result<int&, int>;
+        R r( R::in_place_value, x1 );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+
+        BOOST_TEST_EQ( *r, 1 );
+    }
+
     return boost::report_errors();
 }

test/result_value_construct6.cpp

@@ -0,0 +1,121 @@
+// Copyright 2017, 2021, 2023 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/result.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+
+using namespace boost::system;
+
+struct X
+{
+    static int instances;
+
+    int v_;
+
+    explicit X( int v ): v_( v ) { ++instances; }
+
+    X( X const& ) = delete;
+    X& operator=( X const& ) = delete;
+
+    ~X() { --instances; }
+};
+
+int X::instances = 0;
+
+int main()
+{
+    {
+        int x = 0;
+        result<int&> r( x );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+
+        BOOST_TEST_EQ( r.value(), 0 );
+    }
+
+    {
+        int x = 0;
+        result<int&> r = x;
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+
+        BOOST_TEST_EQ( r.value(), 0 );
+    }
+
+    {
+        int x = 1;
+        result<int&, int> r( in_place_value, x );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+
+        BOOST_TEST_EQ( *r, 1 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        X x( 1 );
+        result<X&> r( x );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+
+        BOOST_TEST_EQ( r.value().v_, 1 );
+
+        BOOST_TEST_EQ( X::instances, 1 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        X x( 1 );
+        result<X&> r = x;
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+
+        BOOST_TEST_EQ( r.value().v_, 1 );
+
+        BOOST_TEST_EQ( X::instances, 1 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        X x( 1 );
+        result<X&, X> r( in_place_value, x );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+
+        BOOST_TEST_EQ( r->v_, 1 );
+
+        BOOST_TEST_EQ( X::instances, 1 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        BOOST_TEST_TRAIT_TRUE((std::is_constructible<result<int&>, int&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_convertible<int&, result<int&>>));
+
+        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int&>, int const&>));
+        BOOST_TEST_TRAIT_FALSE((std::is_convertible<int const&, result<int&>>));
+
+        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int&>, int>));
+        BOOST_TEST_TRAIT_FALSE((std::is_convertible<int, result<int&>>));
+
+        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int&, int>, int&>));
+        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int&, float>, int&>));
+
+        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<X&>, int>));
+        BOOST_TEST_TRAIT_FALSE((std::is_convertible<int, result<X&>>));
+    }
+
+    return boost::report_errors();
+}

test/result_value_construct7.cpp

@@ -0,0 +1,211 @@
+// Copyright 2017, 2021, 2023 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/result.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+
+using namespace boost::system;
+
+struct X
+{
+    static int instances;
+
+    int v_;
+
+    explicit X( int v ): v_( v ) { ++instances; }
+
+    X( X const& ) = delete;
+    X& operator=( X const& ) = delete;
+
+    ~X() { --instances; }
+};
+
+int X::instances = 0;
+
+int main()
+{
+    {
+        int x = 0;
+        result<int const&> r( x );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+
+        BOOST_TEST_EQ( r.value(), 0 );
+    }
+
+    {
+        int const x = 0;
+        result<int const&> r( x );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+
+        BOOST_TEST_EQ( r.value(), 0 );
+    }
+
+    {
+        int x = 0;
+        result<int const&> r = x;
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+
+        BOOST_TEST_EQ( r.value(), 0 );
+    }
+
+    {
+        int const x = 0;
+        result<int const&> r = x;
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+
+        BOOST_TEST_EQ( r.value(), 0 );
+    }
+
+    {
+        int x = 1;
+        result<int const&, int> r( in_place_value, x );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+
+        BOOST_TEST_EQ( *r, 1 );
+    }
+
+    {
+        int const x = 1;
+        result<int const&, int> r( in_place_value, x );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+
+        BOOST_TEST_EQ( *r, 1 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        X x( 1 );
+        result<X const&> r( x );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+
+        BOOST_TEST_EQ( r.value().v_, 1 );
+
+        BOOST_TEST_EQ( X::instances, 1 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        X const x( 1 );
+        result<X const&> r( x );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+
+        BOOST_TEST_EQ( r.value().v_, 1 );
+
+        BOOST_TEST_EQ( X::instances, 1 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        X x( 1 );
+        result<X const&> r = x;
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+
+        BOOST_TEST_EQ( r.value().v_, 1 );
+
+        BOOST_TEST_EQ( X::instances, 1 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        X const x( 1 );
+        result<X const&> r = x;
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+
+        BOOST_TEST_EQ( r.value().v_, 1 );
+
+        BOOST_TEST_EQ( X::instances, 1 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        X x( 1 );
+        result<X const&, X> r( in_place_value, x );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+
+        BOOST_TEST_EQ( r->v_, 1 );
+
+        BOOST_TEST_EQ( X::instances, 1 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        X const x( 1 );
+        result<X const&, X> r( in_place_value, x );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+
+        BOOST_TEST_EQ( r->v_, 1 );
+
+        BOOST_TEST_EQ( X::instances, 1 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        BOOST_TEST_TRAIT_TRUE((std::is_constructible<result<int const&>, int&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_convertible<int&, result<int const&>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_constructible<result<int const&>, int const&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_convertible<int const&, result<int const&>>));
+
+        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int const&>, int>));
+        BOOST_TEST_TRAIT_FALSE((std::is_convertible<int, result<int const&>>));
+
+        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<double const&>, int&>));
+        BOOST_TEST_TRAIT_FALSE((std::is_convertible<int&, result<double const&>>));
+
+        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<double const&>, int const&>));
+        BOOST_TEST_TRAIT_FALSE((std::is_convertible<int const&, result<double const&>>));
+
+        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<double const&>, int>));
+        BOOST_TEST_TRAIT_FALSE((std::is_convertible<int, result<double const&>>));
+
+        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int const&, int>, int&>));
+        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int const&, float>, int&>));
+
+        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int const&, int>, int const&>));
+        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int const&, float>, int const&>));
+
+        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int const&, int>, int>));
+        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int const&, float>, int>));
+
+        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<X const&>, int>));
+        BOOST_TEST_TRAIT_FALSE((std::is_convertible<int, result<X const&>>));
+
+        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<X const&>, X const>));
+        BOOST_TEST_TRAIT_FALSE((std::is_convertible<X const, result<X const&>>));
+    }
+
+    return boost::report_errors();
+}