Update documentation

doc/system/changes.adoc

@@ -15,6 +15,10 @@ https://www.boost.org/LICENSE_1_0.txt
 * A CMake config file is now installed, even though the library is header-only. This
   avoids breaking third-party `CMakeLists.txt` files that contain
   `find_package(Boost COMPONENTS system ...)`.
+* `error_code` is now even more `constexpr` under {cpp}20 and later.
+* Added `unsafe_value` to `result`.
+* Changed `result<>::operator*` and `result<>::operator\->` to throw when `!has_value()`,
+  instead of having that as a precondition. The old behavior is now spelled `unsafe_value()`.
 
 ## Changes in Boost 1.89
 

doc/system/reference.adoc

@@ -1670,15 +1670,20 @@ public:
     constexpr T const&& value( boost::source_location const & loc =
       BOOST_CURRENT_LOCATION ) const&& ;
 
+    constexpr T* operator->();
+    constexpr T const* operator->() const;
+
+    constexpr T& operator*() &;
+    constexpr T const& operator*() const &;
+    constexpr T&& operator*() &&;
+    constexpr T const&& operator*() const &&;
+
     // unchecked value access
 
-    constexpr T* operator->() noexcept;
-    constexpr T const* operator->() const noexcept;
-
-    constexpr T& operator*() & noexcept;
-    constexpr T const& operator*() const & noexcept;
-    constexpr T&& operator*() && noexcept;
-    constexpr T const&& operator*() const && noexcept;
+    constexpr T& unsafe_value() & ;
+    constexpr T const& unsafe_value() const& ;
+    constexpr T&& unsafe_value() && ;
+    constexpr T const&& unsafe_value() const&& ;
 
     // error access
 
@@ -1840,39 +1845,50 @@ Effects: ::
   calls `throw_exception_from_error`, passing it a reference to
   the held error, and `loc`.
 
+```
+constexpr T* operator->();
+constexpr T const* operator->() const;
+```
+[none]
+* {blank}
++
+Returns: ::
+  `&value()`.
+
+```
+constexpr T& operator*() &;
+constexpr T const& operator*() const &;
+```
+[none]
+* {blank}
++
+Returns: ::
+  `value()`.
+
+```
+constexpr T&& operator*() &&;
+constexpr T const&& operator*() const &&;
+```
+[none]
+* {blank}
++
+Returns: ::
+  `std::move( value() )`.
+
 #### Unchecked Value Access
 
 ```
-constexpr T* operator->() noexcept;
-constexpr T const* operator->() const noexcept;
-```
-[none]
-* {blank}
-+
-Returns: ::
-  If `*this` holds a value, a pointer to it. Otherwise, `nullptr`.
-
-```
-constexpr T& operator*() & noexcept;
-constexpr T const& operator*() const & noexcept;
+constexpr T& unsafe_value() &;
+constexpr T const& unsafe_value() const &;
+constexpr T&& unsafe_value() &&;
+constexpr T const&& unsafe_value() const &&;
 ```
 [none]
 * {blank}
 +
 Requires: :: `*this` holds a value.
 Returns: ::
-  `*operator\->()`.
-
-```
-constexpr T&& operator*() && noexcept;
-constexpr T const&& operator*() const && noexcept;
-```
-[none]
-* {blank}
-+
-Requires: :: `*this` holds a value.
-Returns: ::
-  `std::move( *operator\->() )`.
+  A reference to the held value.
 
 #### Error Access
 
@@ -2000,12 +2016,14 @@ public:
     constexpr void value( boost::source_location const & loc =
       BOOST_CURRENT_LOCATION ) const;
 
+    constexpr void* operator->();
+    constexpr void const* operator->() const;
+
+    constexpr void operator*() const;
+
     // unchecked value access
 
-    constexpr void* operator->() noexcept;
-    constexpr void const* operator->() const noexcept;
-
-    constexpr void operator*() const noexcept;
+    constexpr void unsafe_value() const;
 
     // error access
 
@@ -2138,8 +2156,6 @@ Effects: ::
   If `*this` doesn't hold a value, calls `throw_exception_from_error`,
   passing it a reference to the held error, and `loc`.
 
-#### Unchecked Value Access
-
 ```
 constexpr void* operator->() noexcept;
 constexpr void const* operator->() const noexcept;
@@ -2147,8 +2163,8 @@ constexpr void const* operator->() const noexcept;
 [none]
 * {blank}
 +
-Returns: ::
-  If `*this` holds a value, a pointer to it. Otherwise, `nullptr`.
+Effects: ::
+  If `*this` holds a value, returns a pointer to it. Otherwise, calls `value()`.
 
 ```
 constexpr void operator*() const noexcept;
@@ -2156,6 +2172,17 @@ constexpr void operator*() const noexcept;
 [none]
 * {blank}
 +
+Returns: ::
+  `value()`.
+
+#### Unchecked Value Access
+
+```
+constexpr void unsafe_value() const;
+```
+[none]
+* {blank}
++
 Requires: :: `*this` holds a value.
 Effects: ::
   none.
@@ -2285,10 +2312,12 @@ public:
     constexpr U& value( boost::source_location const & loc =
       BOOST_CURRENT_LOCATION ) const;
 
+    constexpr U* operator->() const;
+    constexpr U& operator*() const;
+
     // unchecked value access
 
-    constexpr U* operator->() const noexcept;
-    constexpr U& operator*() const noexcept;
+    constexpr U& unsafe_value() const;
 
     // error access
 
@@ -2422,26 +2451,35 @@ Effects: ::
   calls `throw_exception_from_error`, passing it a reference to
   the held error, and `loc`.
 
-#### Unchecked Value Access
-
 ```
-constexpr U* operator->() const noexcept;
+constexpr U* operator->() const;
 ```
 [none]
 * {blank}
 +
 Returns: ::
-  If `*this` holds a reference, a pointer to its referent. Otherwise, `nullptr`.
+  `&value()`.
 
 ```
-constexpr U& operator*() const noexcept;
+constexpr U& operator*() const;
+```
+[none]
+* {blank}
++
+Returns: ::
+  `value()`.
+
+#### Unchecked Value Access
+
+```
+constexpr U& unsafe_value() const;
 ```
 [none]
 * {blank}
 +
 Requires: :: `*this` holds a reference.
 Returns: ::
-  `*operator\->()`.
+  The held reference.
 
 #### Error Access
 

include/boost/system/result.hpp

@@ -205,7 +205,7 @@ public:
     {
         if( r2 )
         {
-            v_.template emplace<0>( *r2 );
+            v_.template emplace<0>( r2.unsafe_value() );
         }
     }
 
@@ -224,7 +224,7 @@ public:
     {
         if( r2 )
         {
-            v_.template emplace<0>( std::move( *r2 ) );
+            v_.template emplace<0>( std::move( r2 ).unsafe_value() );
         }
     }
 
@@ -317,73 +317,133 @@ public:
 
 #endif
 
-    // unchecked value access
+    // checked value access
 
-    BOOST_CXX14_CONSTEXPR T* operator->() noexcept
+    BOOST_CXX14_CONSTEXPR T* operator->()
     {
-        return variant2::get_if<0>( &v_ );
+        return &value();
     }
 
-    BOOST_CXX14_CONSTEXPR T const* operator->() const noexcept
+    BOOST_CXX14_CONSTEXPR T const* operator->() const
     {
-        return variant2::get_if<0>( &v_ );
+        return &value();
     }
 
 #if defined( BOOST_NO_CXX11_REF_QUALIFIERS )
 
-    BOOST_CXX14_CONSTEXPR T& operator*() noexcept
+    BOOST_CXX14_CONSTEXPR T& operator*()
     {
-        BOOST_ASSERT( has_value() );
-        return *operator->();
+        return value();
     }
 
-    BOOST_CXX14_CONSTEXPR T const& operator*() const noexcept
+    BOOST_CXX14_CONSTEXPR T const& operator*() const
     {
-        BOOST_ASSERT( has_value() );
-        return *operator->();
+        return value();
     }
 
 #else
 
-    BOOST_CXX14_CONSTEXPR T& operator*() & noexcept
+    BOOST_CXX14_CONSTEXPR T& operator*() &
     {
-        BOOST_ASSERT( has_value() );
-        return *operator->();
+        return value();
     }
 
-    BOOST_CXX14_CONSTEXPR T const& operator*() const & noexcept
+    BOOST_CXX14_CONSTEXPR T const& operator*() const &
     {
-        BOOST_ASSERT( has_value() );
-        return *operator->();
+        return value();
     }
 
     template<class U = T>
         BOOST_CXX14_CONSTEXPR
         typename std::enable_if<std::is_move_constructible<U>::value, T>::type
-        operator*() && noexcept(std::is_nothrow_move_constructible<T>::value)
+        operator*() &&
     {
-        return std::move(**this);
+        return std::move( value() );
     }
 
     template<class U = T>
         BOOST_CXX14_CONSTEXPR
         typename std::enable_if<!std::is_move_constructible<U>::value, T&&>::type
-        operator*() && noexcept
+        operator*() &&
     {
-        return std::move(**this);
+        return std::move( value() );
     }
 
     template<class U = T>
         BOOST_CXX14_CONSTEXPR
         typename std::enable_if<std::is_move_constructible<U>::value, T>::type
-        operator*() const && noexcept = delete;
+        operator*() const && = delete;
 
     template<class U = T>
         BOOST_CXX14_CONSTEXPR
         typename std::enable_if<!std::is_move_constructible<U>::value, T const&&>::type
-        operator*() const && noexcept
+        operator*() const &&
     {
-        return std::move(**this);
+        return std::move( value() );
+    }
+
+#endif
+
+    // unchecked value access
+
+#if defined( BOOST_NO_CXX11_REF_QUALIFIERS )
+
+    BOOST_CXX14_CONSTEXPR T& unsafe_value()
+    {
+        BOOST_ASSERT( has_value() );
+        return *variant2::get_if<0>( &v_ );
+    }
+
+    BOOST_CXX14_CONSTEXPR T const& unsafe_value() const
+    {
+        BOOST_ASSERT( has_value() );
+        return *variant2::get_if<0>( &v_ );
+    }
+
+#else
+
+    BOOST_CXX14_CONSTEXPR T& unsafe_value() &
+    {
+        BOOST_ASSERT( has_value() );
+        return *variant2::get_if<0>( &v_ );
+    }
+
+    BOOST_CXX14_CONSTEXPR T const& unsafe_value() const &
+    {
+        BOOST_ASSERT( has_value() );
+        return *variant2::get_if<0>( &v_ );
+    }
+
+    template<class U = T>
+        BOOST_CXX14_CONSTEXPR
+        typename std::enable_if<std::is_move_constructible<U>::value, T>::type
+        unsafe_value() &&
+    {
+        BOOST_ASSERT( has_value() );
+        return std::move( *variant2::get_if<0>( &v_ ) );
+    }
+
+    template<class U = T>
+        BOOST_CXX14_CONSTEXPR
+        typename std::enable_if<!std::is_move_constructible<U>::value, T&&>::type
+        unsafe_value() &&
+    {
+        BOOST_ASSERT( has_value() );
+        return std::move( *variant2::get_if<0>( &v_ ) );
+    }
+
+    template<class U = T>
+        BOOST_CXX14_CONSTEXPR
+        typename std::enable_if<std::is_move_constructible<U>::value, T>::type
+        unsafe_value() const && = delete;
+
+    template<class U = T>
+        BOOST_CXX14_CONSTEXPR
+        typename std::enable_if<!std::is_move_constructible<U>::value, T const&&>::type
+        unsafe_value() const &&
+    {
+        BOOST_ASSERT( has_value() );
+        return std::move( *variant2::get_if<0>( &v_ ) );
     }
 
 #endif
@@ -450,7 +510,7 @@ template<class Ch, class Tr, class T, class E> std::basic_ostream<Ch, Tr>& opera
 {
     if( r.has_value() )
     {
-        os << "value:" << *r;
+        os << "value:" << r.unsafe_value();
     }
     else
     {
@@ -581,19 +641,28 @@ public:
         }
     }
 
+    // checked value access
+
+    BOOST_CXX14_CONSTEXPR void* operator->()
+    {
+        value();
+        return &variant2::unsafe_get<0>( v_ );
+    }
+
+    BOOST_CXX14_CONSTEXPR void const* operator->() const
+    {
+        value();
+        return &variant2::unsafe_get<0>( v_ );
+    }
+
+    BOOST_CXX14_CONSTEXPR void operator*() const
+    {
+        return value();
+    }
+
     // unchecked value access
 
-    BOOST_CXX14_CONSTEXPR void* operator->() noexcept
-    {
-        return variant2::get_if<0>( &v_ );
-    }
-
-    BOOST_CXX14_CONSTEXPR void const* operator->() const noexcept
-    {
-        return variant2::get_if<0>( &v_ );
-    }
-
-    BOOST_CXX14_CONSTEXPR void operator*() const noexcept
+    BOOST_CXX14_CONSTEXPR void unsafe_value() const
     {
         BOOST_ASSERT( has_value() );
     }
@@ -783,7 +852,7 @@ public:
     {
         if( r2 )
         {
-            this->emplace( *r2 );
+            this->emplace( r2.unsafe_value() );
         }
     }
 
@@ -818,17 +887,24 @@ public:
         }
     }
 
-    // unchecked value access
+    // checked value access
 
-    BOOST_CXX14_CONSTEXPR U* operator->() const noexcept
+    BOOST_CXX14_CONSTEXPR U* operator->() const
     {
-        return has_value()? variant2::unsafe_get<0>( v_ ): 0;
+        return &value();
     }
 
-    BOOST_CXX14_CONSTEXPR U& operator*() const noexcept
+    BOOST_CXX14_CONSTEXPR U& operator*() const
+    {
+        return value();
+    }
+
+    // unchecked value access
+
+    BOOST_CXX14_CONSTEXPR U& unsafe_value() const
     {
         BOOST_ASSERT( has_value() );
-        return *operator->();
+        return *( has_value()? variant2::unsafe_get<0>( v_ ): 0 );
     }
 
     // error access
@@ -873,9 +949,9 @@ public:
     // equality
 
     friend constexpr bool operator==( result const & r1, result const & r2 )
-        noexcept( noexcept( r1 && r2? *r1 == *r2: r1.v_ == r2.v_ ) )
+        noexcept( noexcept( r1 && r2? r1.unsafe_value() == r2.unsafe_value(): r1.v_ == r2.v_ ) )
     {
-        return r1 && r2? *r1 == *r2: r1.v_ == r2.v_;
+        return r1 && r2? r1.unsafe_value() == r2.unsafe_value(): r1.v_ == r2.v_;
     }
 
     friend constexpr bool operator!=( result const & r1, result const & r2 )
@@ -927,7 +1003,7 @@ operator|( result<T, E> const& r, U&& u )
 {
     if( r )
     {
-        return *r;
+        return r.unsafe_value();
     }
     else
     {
@@ -943,7 +1019,7 @@ operator|( result<T, E>&& r, U&& u )
 {
     if( r )
     {
-        return *std::move( r );
+        return std::move( r ).unsafe_value();
     }
     else
     {
@@ -961,7 +1037,7 @@ T operator|( result<T, E> const& r, F&& f )
 {
     if( r )
     {
-        return *r;
+        return r.unsafe_value();
     }
     else
     {
@@ -977,7 +1053,7 @@ T operator|( result<T, E>&& r, F&& f )
 {
     if( r )
     {
-        return *std::move( r );
+        return std::move( r ).unsafe_value();
     }
     else
     {
@@ -997,7 +1073,7 @@ operator|( result<T&, E> const& r, F&& f )
 {
     if( r )
     {
-        return *r;
+        return r.unsafe_value();
     }
     else
     {
@@ -1016,7 +1092,7 @@ U operator|( result<T, E> const& r, F&& f )
 {
     if( r )
     {
-        return *r;
+        return r.unsafe_value();
     }
     else
     {
@@ -1033,7 +1109,7 @@ U operator|( result<T, E>&& r, F&& f )
 {
     if( r )
     {
-        return *std::move( r );
+        return std::move( r ).unsafe_value();
     }
     else
     {
@@ -1143,7 +1219,7 @@ result<U, E> operator&( result<T, E>& r, F&& f )
     }
     else
     {
-        return compat::invoke( std::forward<F>( f ), *r );
+        return compat::invoke( std::forward<F>( f ), r.unsafe_value() );
     }
 }
 
@@ -1160,7 +1236,7 @@ result<U, E> operator&( result<T, E> const& r, F&& f )
     }
     else
     {
-        return compat::invoke( std::forward<F>( f ), *r );
+        return compat::invoke( std::forward<F>( f ), r.unsafe_value() );
     }
 }
 
@@ -1177,7 +1253,7 @@ result<U, E> operator&( result<T, E>&& r, F&& f )
     }
     else
     {
-        return compat::invoke( std::forward<F>( f ), *std::move( r ) );
+        return compat::invoke( std::forward<F>( f ), std::move( r ).unsafe_value() );
     }
 }
 
@@ -1194,7 +1270,7 @@ result<U, E> operator&( result<T&, E>&& r, F&& f )
     }
     else
     {
-        return compat::invoke( std::forward<F>( f ), *std::move( r ) );
+        return compat::invoke( std::forward<F>( f ), std::move( r ).unsafe_value() );
     }
 }
 
@@ -1210,7 +1286,7 @@ result<U, E> operator&( result<T, E> const& r, F&& f )
     }
     else
     {
-        compat::invoke( std::forward<F>( f ), *r );
+        compat::invoke( std::forward<F>( f ), r.unsafe_value() );
         return {};
     }
 }
@@ -1227,7 +1303,7 @@ result<U, E> operator&( result<T, E>&& r, F&& f )
     }
     else
     {
-        compat::invoke( std::forward<F>( f ), *std::move( r ) );
+        compat::invoke( std::forward<F>( f ), std::move( r ).unsafe_value() );
         return {};
     }
 }
@@ -1281,7 +1357,7 @@ U operator&( result<T, E>& r, F&& f )
     }
     else
     {
-        return compat::invoke( std::forward<F>( f ), *r );
+        return compat::invoke( std::forward<F>( f ), r.unsafe_value() );
     }
 }
 
@@ -1298,7 +1374,7 @@ U operator&( result<T, E> const& r, F&& f )
     }
     else
     {
-        return compat::invoke( std::forward<F>( f ), *r );
+        return compat::invoke( std::forward<F>( f ), r.unsafe_value() );
     }
 }
 
@@ -1315,7 +1391,7 @@ U operator&( result<T, E>&& r, F&& f )
     }
     else
     {
-        return compat::invoke( std::forward<F>( f ), *std::move( r ) );
+        return compat::invoke( std::forward<F>( f ), std::move( r ).unsafe_value() );
     }
 }
 
@@ -1349,7 +1425,7 @@ result<T, E>& operator&=( result<T, E>& r, F&& f )
 {
     if( r )
     {
-        r = std::forward<F>( f )( *std::move( r ) );
+        r = std::forward<F>( f )( std::move( r ).unsafe_value() );
     }
 
     return r;
@@ -1381,7 +1457,7 @@ result<T, E>& operator&=( result<T, E>& r, F&& f )
 {
     if( r )
     {
-        r = std::forward<F>( f )( *std::move( r ) );
+        r = std::forward<F>( f )( std::move( r ).unsafe_value() );
     }
 
     return r;

test/CMakeLists.txt

@@ -184,3 +184,6 @@ boost_test(TYPE run SOURCES result_and_mfn1r.cpp)
 boost_test(TYPE compile SOURCES result_value_construct_cx.cpp)
 boost_test(TYPE compile SOURCES result_error_construct_cx.cpp)
 boost_test(TYPE compile SOURCES result_error_construct_cx2.cpp)
+
+boost_test(TYPE run SOURCES result_unsafe_value_access.cpp)
+boost_test(TYPE run SOURCES result_unsafe_value_access2.cpp)

test/Jamfile.v2

@@ -217,3 +217,6 @@ run result_and_mfn1r.cpp ;
 compile result_value_construct_cx.cpp ;
 compile result_error_construct_cx.cpp ;
 compile result_error_construct_cx2.cpp ;
+
+run result_unsafe_value_access.cpp ;
+run result_unsafe_value_access2.cpp ;

test/result_and_eq_fn1r.cpp

@@ -96,7 +96,7 @@ int main()
         result<int, E2> r( 1 );
 
         r &= fi;
-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( *r, 3 );
+        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( r.unsafe_value(), 3 );
 
         r &= fi2;
         BOOST_TEST( r.has_error() );
@@ -109,7 +109,7 @@ int main()
         result<Y, E2> r( in_place_value, 1 );
 
         r &= fy;
-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( r->v_, 3 );
+        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( r.unsafe_value().v_, 3 );
 
         r &= fy2;
         BOOST_TEST( r.has_error() );
@@ -123,7 +123,7 @@ int main()
         result<int&, E2> r( x1 );
 
         r &= fri;
-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( &*r, &*fri( x1 ) );
+        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( &r.unsafe_value(), &fri( x1 ).unsafe_value() );
 
         r &= fri2;
         BOOST_TEST( r.has_error() );

test/result_and_fn1r.cpp

@@ -112,7 +112,7 @@ int main()
 
         {
             result<int, E2> r2 = r & fi;
-            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 3 );
+            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2.unsafe_value(), 3 );
         }
 
         {
@@ -131,7 +131,7 @@ int main()
 
         {
             result<int, E2> r2 = r & fi;
-            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 3 );
+            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2.unsafe_value(), 3 );
         }
 
         {
@@ -147,7 +147,7 @@ int main()
 
     {
         result<int, E2> r2 = result<int, E>( 1 ) & fi;
-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 3 );
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2.unsafe_value(), 3 );
     }
 
     {
@@ -216,7 +216,7 @@ int main()
     {
         result<X, E2> r2 = result<Y, E>( in_place_value, 1 ) & fy;
 
-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2->v_, 3 );
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2.unsafe_value().v_, 3 );
     }
 
     {
@@ -255,7 +255,7 @@ int main()
 
         {
             result<int, E2> r2 = r & fri;
-            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 3 );
+            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2.unsafe_value(), 3 );
         }
 
         {
@@ -275,7 +275,7 @@ int main()
 
         {
             result<int, E2> r2 = r & fri;
-            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 3 );
+            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2.unsafe_value(), 3 );
         }
 
         {
@@ -293,7 +293,7 @@ int main()
         int x1 = 1;
 
         result<int, E2> r2 = result<int&, E>( x1 ) & fri;
-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 3 );
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2.unsafe_value(), 3 );
     }
 
     {
@@ -368,7 +368,7 @@ int main()
 
         {
             result<int, E2> r2 = r & fk;
-            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 7 );
+            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2.unsafe_value(), 7 );
         }
 
         {
@@ -392,7 +392,7 @@ int main()
 
         {
             result<int, E2> r2 = r & fk;
-            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 7 );
+            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2.unsafe_value(), 7 );
         }
 
         {
@@ -413,7 +413,7 @@ int main()
 
     {
         result<int, E2> r2 = result<void, E>() & fk;
-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 7 );
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2.unsafe_value(), 7 );
     }
 
     {

test/result_and_mfn1r.cpp

@@ -41,7 +41,7 @@ int main()
 
         {
             result<int, E2> r2 = r & &X::f;
-            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 1 );
+            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2.unsafe_value(), 1 );
         }
 
         {
@@ -51,12 +51,12 @@ int main()
 
         {
             result<int&, E2> r2 = r & &X::g;
-            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &*r2, &r->v_ );
+            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &r2.unsafe_value(), &r.unsafe_value().v_ );
         }
 
         {
             result<int const&, E2> r2 = r & &X::g2;
-            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &*r2, &r->v_ );
+            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &r2.unsafe_value(), &r.unsafe_value().v_ );
         }
 
         {
@@ -75,7 +75,7 @@ int main()
 
         {
             result<int, E2> r2 = r & &X::f;
-            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 1 );
+            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2.unsafe_value(), 1 );
         }
 
         {
@@ -85,7 +85,7 @@ int main()
 
         {
             result<int const&, E2> r2 = r & &X::g2;
-            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &*r2, &r->v_ );
+            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &r2.unsafe_value(), &r.unsafe_value().v_ );
         }
 
         {
@@ -102,7 +102,7 @@ int main()
     {
         {
             result<int, E2> r2 = result<X, E>( 1 ) & &X::f;
-            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 1 );
+            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2.unsafe_value(), 1 );
         }
 
         {

test/result_convert_construct.cpp

@@ -126,7 +126,7 @@ int main()
         result<char const*, int> r( "test" );
         result<std::string, X> r2 = r;
 
-        BOOST_TEST( r2 ) && BOOST_TEST_EQ( *r2, std::string( "test" ) );
+        BOOST_TEST( r2 ) && BOOST_TEST_EQ( r2.unsafe_value(), std::string( "test" ) );
         BOOST_TEST_EQ( X::instances, 0 );
     }
 
@@ -136,7 +136,7 @@ int main()
         result<char const*, int> const r( "test" );
         result<std::string, X> r2 = r;
 
-        BOOST_TEST( r2 ) && BOOST_TEST_EQ( *r2, std::string( "test" ) );
+        BOOST_TEST( r2 ) && BOOST_TEST_EQ( r2.unsafe_value(), std::string( "test" ) );
         BOOST_TEST_EQ( X::instances, 0 );
     }
 
@@ -145,7 +145,7 @@ int main()
     {
         result<std::string, X> r2 = result<char const*, int>( "test" );
 
-        BOOST_TEST( r2 ) && BOOST_TEST_EQ( *r2, std::string( "test" ) );
+        BOOST_TEST( r2 ) && BOOST_TEST_EQ( r2.unsafe_value(), std::string( "test" ) );
         BOOST_TEST_EQ( X::instances, 0 );
     }
 

test/result_emplace.cpp

@@ -42,6 +42,15 @@ struct Y
 
 int Y::instances = 0;
 
+struct E
+{
+};
+
+BOOST_NORETURN void throw_exception_from_error( Y const &, boost::source_location const& )
+{
+    throw E();
+}
+
 int main()
 {
     {

test/result_or_eq_fn0r.cpp

@@ -87,11 +87,11 @@ int main()
 
         r |= fi;
 
-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( *r, 1 );
+        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( r.unsafe_value(), 1 );
 
         r |= fi2;
 
-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( *r, 1 );
+        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( r.unsafe_value(), 1 );
     }
 
     {
@@ -103,7 +103,7 @@ int main()
 
         r |= fi;
 
-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( *r, 2 );
+        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( r.unsafe_value(), 2 );
     }
 
     {
@@ -111,11 +111,11 @@ int main()
 
         r |= fy;
 
-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( r->v_, 1 );
+        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( r.unsafe_value().v_, 1 );
 
         r |= fy2;
 
-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( r->v_, 1 );
+        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( r.unsafe_value().v_, 1 );
     }
 
     {
@@ -127,7 +127,7 @@ int main()
 
         r |= fy;
 
-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( r->v_, 2 );
+        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( r.unsafe_value().v_, 2 );
     }
 
     {
@@ -137,11 +137,11 @@ int main()
 
         r |= fri;
 
-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( &*r, &x1 );
+        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( &r.unsafe_value(), &x1 );
 
         r |= fri2;
 
-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( &*r, &x1 );
+        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( &r.unsafe_value(), &x1 );
     }
 
     {
@@ -153,7 +153,7 @@ int main()
 
         r |= fri;
 
-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( &*r, &*fri() );
+        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( &r.unsafe_value(), &fri().unsafe_value() );
     }
 
     return boost::report_errors();

test/result_or_eq_fn0v.cpp

@@ -74,7 +74,7 @@ int main()
 
         r |= f;
 
-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( *r, 2 );
+        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( r.unsafe_value(), 2 );
     }
 
     {
@@ -90,7 +90,7 @@ int main()
 
         r |= g;
 
-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( r->v_, 2 );
+        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( r.unsafe_value().v_, 2 );
     }
 
     {
@@ -108,7 +108,7 @@ int main()
 
         r |= h;
 
-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( &*r, &h() );
+        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( &r.unsafe_value(), &h() );
     }
 
     return boost::report_errors();

test/result_or_eq_value.cpp

@@ -58,7 +58,7 @@ int main()
 
         r |= 2;
 
-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( *r, 2 );
+        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( r.unsafe_value(), 2 );
     }
 
     {
@@ -74,7 +74,7 @@ int main()
 
         r |= X{2};
 
-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( r->v_, 2 );
+        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( r.unsafe_value().v_, 2 );
     }
 
     {
@@ -85,7 +85,7 @@ int main()
 
         r |= x2;
 
-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( &*r, &x1 );
+        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( &r.unsafe_value(), &x1 );
     }
 
     {
@@ -95,7 +95,7 @@ int main()
 
         r |= x2;
 
-        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( &*r, &x2 );
+        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( &r.unsafe_value(), &x2 );
     }
 
     return boost::report_errors();

test/result_or_fn0r.cpp

@@ -196,7 +196,7 @@ int main()
 
         auto r2 = r | fri;
 
-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &*r2, &x1 );
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &r2.unsafe_value(), &x1 );
     }
 
     {
@@ -206,7 +206,7 @@ int main()
 
         auto r2 = r | fri;
 
-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &*r2, &x1 );
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &r2.unsafe_value(), &x1 );
     }
 
     {
@@ -214,7 +214,7 @@ int main()
 
         auto r2 = result<int&>( x1 ) | fri;
 
-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &*r2, &x1 );
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &r2.unsafe_value(), &x1 );
     }
 
     {
@@ -224,7 +224,7 @@ int main()
 
         auto r2 = r | fri2;
 
-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &*r2, &x1 );
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &r2.unsafe_value(), &x1 );
     }
 
     {
@@ -234,7 +234,7 @@ int main()
 
         auto r2 = r | fri2;
 
-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &*r2, &x1 );
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &r2.unsafe_value(), &x1 );
     }
 
     {
@@ -242,7 +242,7 @@ int main()
 
         auto r2 = result<int&>( x1 ) | fri2;
 
-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &*r2, &x1 );
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &r2.unsafe_value(), &x1 );
     }
 
     {
@@ -250,7 +250,7 @@ int main()
 
         auto r2 = r | fri;
 
-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &*r2, &*fri() );
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &r2.unsafe_value(), &fri().unsafe_value() );
     }
 
     {
@@ -258,13 +258,13 @@ int main()
 
         auto r2 = r | fri;
 
-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &*r2, &*fri() );
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &r2.unsafe_value(), &fri().unsafe_value() );
     }
 
     {
         auto r2 = result<int&, E>( in_place_error ) | fri;
 
-        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &*r2, &*fri() );
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &r2.unsafe_value(), &fri().unsafe_value() );
     }
 
     {

test/result_unsafe_value_access.cpp

@@ -0,0 +1,137 @@
+// Copyright 2017, 2021, 2022, 2026 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/result.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/config.hpp>
+
+using namespace boost::system;
+
+struct X
+{
+    int v_;
+
+    explicit X( int v ): v_( v ) {}
+
+    X( X const& ) = delete;
+    X& operator=( X const& ) = delete;
+};
+
+int main()
+{
+    {
+        result<int> r;
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST_EQ( r.unsafe_value(), 0 );
+    }
+
+    {
+        result<int> const r;
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST_EQ( r.unsafe_value(), 0 );
+    }
+
+    {
+        BOOST_TEST( result<int>().has_value() );
+        BOOST_TEST_EQ( result<int>().unsafe_value(), 0 );
+    }
+
+    {
+        result<int> r( 1 );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST_EQ( r.unsafe_value(), 1 );
+    }
+
+    {
+        result<int> const r( 1 );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST_EQ( r.unsafe_value(), 1 );
+    }
+
+    {
+        BOOST_TEST( result<int>( 1 ).has_value() );
+        BOOST_TEST_EQ( result<int>( 1 ).unsafe_value(), 1 );
+    }
+
+    //
+
+    {
+        result<X> r( 1 );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST_EQ( r.unsafe_value().v_, 1 );
+    }
+
+    {
+        result<X> const r( 1 );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST_EQ( r.unsafe_value().v_, 1 );
+    }
+
+    {
+        BOOST_TEST( result<X>( 1 ).has_value() );
+        BOOST_TEST_EQ( result<X>( 1 ).unsafe_value().v_, 1 );
+    }
+
+    //
+
+    {
+        result<void> r;
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST_NO_THROW( r.unsafe_value() );
+    }
+
+    {
+        result<void> const r;
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST_NO_THROW( r.unsafe_value() );
+    }
+
+    {
+        BOOST_TEST( result<void>().has_value() );
+        BOOST_TEST_NO_THROW( result<void>().unsafe_value() );
+    }
+
+    //
+
+    {
+        int x1 = 1;
+        result<int&> r( x1 );
+
+        BOOST_TEST( r.has_value() );
+
+        BOOST_TEST_EQ( r.unsafe_value(), 1 );
+        BOOST_TEST_EQ( &r.unsafe_value(), &x1 );
+    }
+
+    {
+        int x1 = 1;
+        result<int&> const r( x1 );
+
+        BOOST_TEST( r.has_value() );
+
+        BOOST_TEST_EQ( r.unsafe_value(), 1 );
+        BOOST_TEST_EQ( &r.unsafe_value(), &x1 );
+    }
+
+    {
+        int x1 = 1;
+
+        BOOST_TEST( result<int&>( x1 ).has_value() );
+
+        BOOST_TEST_EQ( result<int&>( x1 ).unsafe_value(), 1 );
+        BOOST_TEST_EQ( &result<int&>( x1 ).unsafe_value(), &x1 );
+    }
+
+    //
+
+    return boost::report_errors();
+}

test/result_unsafe_value_access2.cpp

@@ -0,0 +1,139 @@
+// Copyright 2017, 2021, 2022, 2026 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#define BOOST_ENABLE_ASSERT_HANDLER
+
+#include <boost/system/result.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+struct assertion_failure
+{
+};
+
+namespace boost
+{
+
+void assertion_failed( char const* /*expr*/, char const* /*function*/, char const* /*file*/, long /*line*/ )
+{
+    throw assertion_failure();
+}
+
+} // namespace boost
+
+using namespace boost::system;
+
+struct X
+{
+    int v_;
+
+    explicit X( int v ): v_( v ) {}
+
+    X( X const& ) = delete;
+    X& operator=( X const& ) = delete;
+};
+
+int main()
+{
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+        result<int> r( ec );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST_THROWS( r.unsafe_value(), assertion_failure );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+        result<int> const r( ec );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST_THROWS( r.unsafe_value(), assertion_failure );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        BOOST_TEST( !result<int>( ec ).has_value() );
+        BOOST_TEST_THROWS( result<int>( ec ).unsafe_value(), assertion_failure );
+    }
+
+    //
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+        result<X> r( ec );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST_THROWS( r.unsafe_value(), assertion_failure );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+        result<X> const r( ec );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST_THROWS( r.unsafe_value(), assertion_failure );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        BOOST_TEST(( !result<X>( ec ).has_value() ));
+        BOOST_TEST_THROWS( (result<X>( ec ).unsafe_value()), assertion_failure );
+    }
+
+    //
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+        result<void> r( ec );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST_THROWS( r.unsafe_value(), assertion_failure );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+        result<void> const r( ec );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST_THROWS( r.unsafe_value(), assertion_failure );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        BOOST_TEST( !result<void>( ec ).has_value() );
+        BOOST_TEST_THROWS( result<void>( ec ).unsafe_value(), assertion_failure );
+    }
+
+    //
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+        result<int&> r( ec );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST_THROWS( r.unsafe_value(), assertion_failure );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+        result<int&> const r( ec );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST_THROWS( r.unsafe_value(), assertion_failure );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        BOOST_TEST( !result<int&>( ec ).has_value() );
+        BOOST_TEST_THROWS( result<int&>( ec ).unsafe_value(), assertion_failure );
+    }
+
+    //
+
+    return boost::report_errors();
+}

test/result_value_access.cpp

@@ -138,7 +138,8 @@ int main()
 
         BOOST_TEST_THROWS( r.value(), system_error );
 
-        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
+        BOOST_TEST_THROWS( *r, system_error );
+        BOOST_TEST_THROWS( r.operator->(), system_error );
     }
 
     {
@@ -154,7 +155,8 @@ int main()
 
         BOOST_TEST_THROWS( r.value(), system_error );
 
-        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
+        BOOST_TEST_THROWS( *r, system_error );
+        BOOST_TEST_THROWS( r.operator->(), system_error );
     }
 
     {
@@ -168,7 +170,8 @@ int main()
 
         BOOST_TEST_THROWS( result<int>( ec ).value(), system_error );
 
-        BOOST_TEST_EQ( result<int>( ec ).operator->(), static_cast<int*>(0) );
+        BOOST_TEST_THROWS( *result<int>( ec ), system_error );
+        BOOST_TEST_THROWS( result<int>( ec ).operator->(), system_error );
     }
 
     {
@@ -184,7 +187,8 @@ int main()
 
         BOOST_TEST_THROWS( r.value(), std::system_error );
 
-        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
+        BOOST_TEST_THROWS( *r, std::system_error );
+        BOOST_TEST_THROWS( r.operator->(), std::system_error );
     }
 
     {
@@ -198,7 +202,8 @@ int main()
 
         BOOST_TEST_THROWS( r.value(), system_error );
 
-        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
+        BOOST_TEST_THROWS( *r, system_error );
+        BOOST_TEST_THROWS( r.operator->(), system_error );
     }
 
     {
@@ -212,7 +217,8 @@ int main()
 
         BOOST_TEST_THROWS( r.value(), std::system_error );
 
-        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
+        BOOST_TEST_THROWS( *r, std::system_error );
+        BOOST_TEST_THROWS( r.operator->(), std::system_error );
     }
 
     {
@@ -227,9 +233,9 @@ int main()
 #if defined(BOOST_CLANG_VERSION) && BOOST_CLANG_VERSION < 30600
 #else
         BOOST_TEST_THROWS( r.value(), E2 );
+        BOOST_TEST_THROWS( *r, E2 );
+        BOOST_TEST_THROWS( r.operator->(), E2 );
 #endif
-
-        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
     }
 
     {
@@ -243,7 +249,8 @@ int main()
 
         BOOST_TEST_THROWS( r.value(), std::bad_exception );
 
-        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
+        BOOST_TEST_THROWS( *r, std::bad_exception );
+        BOOST_TEST_THROWS( r.operator->(), std::bad_exception );
     }
 
     {
@@ -303,7 +310,8 @@ int main()
 
         BOOST_TEST_THROWS( r.value(), E );
 
-        BOOST_TEST_EQ( r.operator->(), static_cast<X*>(0) );
+        BOOST_TEST_THROWS( *r, E );
+        BOOST_TEST_THROWS( r.operator->(), E );
     }
 
     {
@@ -319,7 +327,8 @@ int main()
 
         BOOST_TEST_THROWS( r.value(), E );
 
-        BOOST_TEST_EQ( r.operator->(), static_cast<X*>(0) );
+        BOOST_TEST_THROWS( *r, E );
+        BOOST_TEST_THROWS( r.operator->(), E );
     }
 
     {
@@ -333,7 +342,8 @@ int main()
 
         BOOST_TEST_THROWS( (result<X, Y>( ec ).value()), E );
 
-        BOOST_TEST_EQ( (result<X, Y>( ec ).operator->()), static_cast<X*>(0) );
+        BOOST_TEST_THROWS( *(result<X, Y>( ec )), E );
+        BOOST_TEST_THROWS( (result<X, Y>( ec )).operator->(), E );
     }
 
     //
@@ -349,6 +359,9 @@ int main()
 
         BOOST_TEST_NO_THROW( r.value() );
 
+        BOOST_TEST_NO_THROW( *r );
+        BOOST_TEST_NO_THROW( r.operator->() );
+
         BOOST_TEST( r.operator->() != 0 );
     }
 
@@ -363,6 +376,9 @@ int main()
 
         BOOST_TEST_NO_THROW( r.value() );
 
+        BOOST_TEST_NO_THROW( *r );
+        BOOST_TEST_NO_THROW( r.operator->() );
+
         BOOST_TEST( r.operator->() != 0 );
     }
 
@@ -375,6 +391,9 @@ int main()
 
         BOOST_TEST_NO_THROW( result<void>().value() );
 
+        BOOST_TEST_NO_THROW( *result<void>() );
+        BOOST_TEST_NO_THROW( result<void>().operator->() );
+
         BOOST_TEST( result<void>().operator->() != 0 );
     }
 
@@ -391,7 +410,8 @@ int main()
 
         BOOST_TEST_THROWS( r.value(), system_error );
 
-        BOOST_TEST_EQ( r.operator->(), static_cast<void*>(0) );
+        BOOST_TEST_THROWS( *r, system_error );
+        BOOST_TEST_THROWS( r.operator->(), system_error );
     }
 
     {
@@ -407,7 +427,8 @@ int main()
 
         BOOST_TEST_THROWS( r.value(), system_error );
 
-        BOOST_TEST_EQ( r.operator->(), static_cast<void*>(0) );
+        BOOST_TEST_THROWS( *r, system_error );
+        BOOST_TEST_THROWS( r.operator->(), system_error );
     }
 
     {
@@ -421,7 +442,8 @@ int main()
 
         BOOST_TEST_THROWS( result<void>( ec ).value(), system_error );
 
-        BOOST_TEST_EQ( result<void>( ec ).operator->(), static_cast<void*>(0) );
+        BOOST_TEST_THROWS( *result<void>( ec ), system_error );
+        BOOST_TEST_THROWS( result<void>( ec ).operator->(), system_error );
     }
 
     {
@@ -437,7 +459,8 @@ int main()
 
         BOOST_TEST_THROWS( r.value(), std::system_error );
 
-        BOOST_TEST_EQ( r.operator->(), static_cast<void*>(0) );
+        BOOST_TEST_THROWS( *r, std::system_error );
+        BOOST_TEST_THROWS( r.operator->(), std::system_error );
     }
 
     {
@@ -451,7 +474,8 @@ int main()
 
         BOOST_TEST_THROWS( r.value(), system_error );
 
-        BOOST_TEST_EQ( r.operator->(), static_cast<void*>(0) );
+        BOOST_TEST_THROWS( *r, system_error );
+        BOOST_TEST_THROWS( r.operator->(), system_error );
     }
 
     {
@@ -465,7 +489,8 @@ int main()
 
         BOOST_TEST_THROWS( r.value(), std::system_error );
 
-        BOOST_TEST_EQ( r.operator->(), static_cast<void*>(0) );
+        BOOST_TEST_THROWS( *r, std::system_error );
+        BOOST_TEST_THROWS( r.operator->(), std::system_error );
     }
 
     {
@@ -480,9 +505,9 @@ int main()
 #if defined(BOOST_CLANG_VERSION) && BOOST_CLANG_VERSION < 30600
 #else
         BOOST_TEST_THROWS( r.value(), E2 );
+        BOOST_TEST_THROWS( *r, E2 );
+        BOOST_TEST_THROWS( r.operator->(), E2 );
 #endif
-
-        BOOST_TEST_EQ( r.operator->(), static_cast<void*>(0) );
     }
 
     {
@@ -496,7 +521,8 @@ int main()
 
         BOOST_TEST_THROWS( r.value(), std::bad_exception );
 
-        BOOST_TEST_EQ( r.operator->(), static_cast<void*>(0) );
+        BOOST_TEST_THROWS( *r, std::bad_exception );
+        BOOST_TEST_THROWS( r.operator->(), std::bad_exception );
     }
 
     //
@@ -563,7 +589,8 @@ int main()
 
         BOOST_TEST_THROWS( r.value(), system_error );
 
-        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
+        BOOST_TEST_THROWS( *r, system_error );
+        BOOST_TEST_THROWS( r.operator->(), system_error );
     }
 
     {
@@ -579,7 +606,8 @@ int main()
 
         BOOST_TEST_THROWS( r.value(), system_error );
 
-        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
+        BOOST_TEST_THROWS( *r, system_error );
+        BOOST_TEST_THROWS( r.operator->(), system_error );
     }
 
     {
@@ -593,7 +621,8 @@ int main()
 
         BOOST_TEST_THROWS( result<int&>( ec ).value(), system_error );
 
-        BOOST_TEST_EQ( result<int&>( ec ).operator->(), static_cast<int*>(0) );
+        BOOST_TEST_THROWS( *result<int&>( ec ), system_error );
+        BOOST_TEST_THROWS( result<int&>( ec ).operator->(), system_error );
     }
 
     {
@@ -609,7 +638,8 @@ int main()
 
         BOOST_TEST_THROWS( r.value(), std::system_error );
 
-        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
+        BOOST_TEST_THROWS( *r, std::system_error );
+        BOOST_TEST_THROWS( r.operator->(), std::system_error );
     }
 
     {
@@ -623,7 +653,8 @@ int main()
 
         BOOST_TEST_THROWS( r.value(), system_error );
 
-        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
+        BOOST_TEST_THROWS( *r, system_error );
+        BOOST_TEST_THROWS( r.operator->(), system_error );
     }
 
     {
@@ -637,7 +668,8 @@ int main()
 
         BOOST_TEST_THROWS( r.value(), std::system_error );
 
-        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
+        BOOST_TEST_THROWS( *r, std::system_error );
+        BOOST_TEST_THROWS( r.operator->(), std::system_error );
     }
 
     {
@@ -652,9 +684,9 @@ int main()
 #if defined(BOOST_CLANG_VERSION) && BOOST_CLANG_VERSION < 30600
 #else
         BOOST_TEST_THROWS( r.value(), E2 );
+        BOOST_TEST_THROWS( *r, E2 );
+        BOOST_TEST_THROWS( r.operator->(), E2 );
 #endif
-
-        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
     }
 
     {
@@ -668,7 +700,8 @@ int main()
 
         BOOST_TEST_THROWS( r.value(), std::bad_exception );
 
-        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
+        BOOST_TEST_THROWS( *r, std::bad_exception );
+        BOOST_TEST_THROWS( r.operator->(), std::bad_exception );
     }
 
     //

test/result_value_construct.cpp

@@ -27,6 +27,15 @@ struct X
 
 int X::instances = 0;
 
+struct E
+{
+};
+
+BOOST_NORETURN void throw_exception_from_error( X const &, boost::source_location const& )
+{
+    throw E();
+}
+
 int main()
 {
     {
@@ -53,7 +62,7 @@ int main()
         BOOST_TEST( r.has_value() );
         BOOST_TEST( !r.has_error() );
 
-        BOOST_TEST_EQ( *r, 1 );
+        BOOST_TEST_EQ( r.unsafe_value(), 1 );
     }
 
     BOOST_TEST_EQ( X::instances, 0 );

test/result_value_construct2.cpp

@@ -74,6 +74,15 @@ result<void> fw0()
     return {};
 }
 
+struct E2
+{
+};
+
+BOOST_NORETURN void throw_exception_from_error( E const &, boost::source_location const& )
+{
+    throw E2();
+}
+
 int main()
 {
     {

test/result_value_construct3.cpp

@@ -26,6 +26,15 @@ struct X
 
 int X::instances = 0;
 
+struct E
+{
+};
+
+BOOST_NORETURN void throw_exception_from_error( X const &, boost::source_location const& )
+{
+    throw E();
+}
+
 int main()
 {
     {
@@ -45,7 +54,7 @@ int main()
         BOOST_TEST( r.has_value() );
         BOOST_TEST( !r.has_error() );
 
-        BOOST_TEST_EQ( *r, 1 );
+        BOOST_TEST_EQ( r.unsafe_value(), 1 );
     }
 
     BOOST_TEST_EQ( X::instances, 0 );
@@ -135,7 +144,7 @@ int main()
         BOOST_TEST( r.has_value() );
         BOOST_TEST( !r.has_error() );
 
-        BOOST_TEST_EQ( *r, 1 );
+        BOOST_TEST_EQ( r.unsafe_value(), 1 );
     }
 
     return boost::report_errors();

test/result_value_construct6.cpp

@@ -24,6 +24,15 @@ struct X
 
 int X::instances = 0;
 
+struct E
+{
+};
+
+BOOST_NORETURN void throw_exception_from_error( X const &, boost::source_location const& )
+{
+    throw E();
+}
+
 int main()
 {
     {
@@ -53,7 +62,7 @@ int main()
         BOOST_TEST( r.has_value() );
         BOOST_TEST( !r.has_error() );
 
-        BOOST_TEST_EQ( *r, 1 );
+        BOOST_TEST_EQ( r.unsafe_value(), 1 );
     }
 
     BOOST_TEST_EQ( X::instances, 0 );

test/result_value_construct7.cpp

@@ -24,6 +24,15 @@ struct X
 
 int X::instances = 0;
 
+struct E
+{
+};
+
+BOOST_NORETURN void throw_exception_from_error( X const &, boost::source_location const& )
+{
+    throw E();
+}
+
 int main()
 {
     {
@@ -73,7 +82,7 @@ int main()
         BOOST_TEST( r.has_value() );
         BOOST_TEST( !r.has_error() );
 
-        BOOST_TEST_EQ( *r, 1 );
+        BOOST_TEST_EQ( r.unsafe_value(), 1 );
     }
 
     {
@@ -83,7 +92,7 @@ int main()
         BOOST_TEST( r.has_value() );
         BOOST_TEST( !r.has_error() );
 
-        BOOST_TEST_EQ( *r, 1 );
+        BOOST_TEST_EQ( r.unsafe_value(), 1 );
     }
 
     BOOST_TEST_EQ( X::instances, 0 );