Enable implicit construction when the alternative is explicitly constructible from the argument. Fixes #103.

include/boost/system/result.hpp

@@ -122,7 +122,7 @@ public:
     template<class A = T, typename std::enable_if<
         std::is_convertible<A, T>::value &&
         !(detail::is_errc_t<A>::value && std::is_arithmetic<T>::value) &&
-        !std::is_constructible<E, A>::value, int>::type = 0>
+        !std::is_convertible<A, E>::value, int>::type = 0>
     constexpr result( A&& a )
         noexcept( std::is_nothrow_constructible<T, A>::value )
         : v_( in_place_value, std::forward<A>(a) )
@@ -132,7 +132,7 @@ public:
     // implicit, error
     template<class A = E, class = void, typename std::enable_if<
         std::is_convertible<A, E>::value &&
-        !std::is_constructible<T, A>::value, int>::type = 0>
+        !std::is_convertible<A, T>::value, int>::type = 0>
     constexpr result( A&& a )
         noexcept( std::is_nothrow_constructible<E, A>::value )
         : v_( in_place_error, std::forward<A>(a) )

test/CMakeLists.txt

@@ -154,7 +154,10 @@ boost_test(TYPE run SOURCES result_eq.cpp)
 boost_test(TYPE run SOURCES result_range_for.cpp)
 boost_test(TYPE run SOURCES result_value_construct2.cpp)
 boost_test(TYPE run SOURCES result_error_construct2.cpp)
+boost_test(TYPE run SOURCES result_errc_construct.cpp)
 boost_test(TYPE run SOURCES result_convert_construct.cpp)
 boost_test(TYPE run SOURCES result_typedefs.cpp)
 boost_test(TYPE run SOURCES result_value_construct3.cpp)
 boost_test(TYPE run SOURCES result_error_construct3.cpp)
+boost_test(TYPE run SOURCES result_emplace.cpp)
+boost_test(TYPE run SOURCES result_error_construct4.cpp)

test/Jamfile.v2

@@ -190,3 +190,4 @@ run result_typedefs.cpp : : : $(CPP11) ;
 run result_value_construct3.cpp : : : $(CPP11) ;
 run result_error_construct3.cpp : : : $(CPP11) ;
 run result_emplace.cpp : : : $(CPP11) ;
+run result_error_construct4.cpp : : : $(CPP11) ;

test/result_error_construct.cpp

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

test/result_error_construct4.cpp

@@ -0,0 +1,49 @@
+// Copyright 2023 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/result.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+using namespace boost::system;
+
+// Eigen::Matrix4d has an explicit templated constructor
+// https://github.com/boostorg/system/issues/103
+// https://github.com/boostorg/json/issues/843
+
+struct X
+{
+    X() {}
+    template<class T> explicit X( T const& ) {}
+};
+
+int main()
+{
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<X> r = ec;
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_EQ( r.error(), ec );
+    }
+
+#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
+
+    {
+        auto ec = make_error_code( std::errc::invalid_argument );
+
+        result<X> r = ec;
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_EQ( r.error(), ec );
+    }
+
+#endif
+
+    return boost::report_errors();
+}