From f6fcb1b690134792d9423fa41746939d248fc799 Mon Sep 17 00:00:00 2001
From: Klemens Morgenstern <klemens.d.morgenstern@gmail.com>
Date: Sat, 6 Apr 2024 21:54:33 +0800
Subject: [PATCH 1/6] declared global constants as inline with
 BOOST_INLINE_CONSTEXPR

---
 include/boost/system/result.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/boost/system/result.hpp b/include/boost/system/result.hpp
index 03ab010..f6a41c4 100644
--- a/include/boost/system/result.hpp
+++ b/include/boost/system/result.hpp
@@ -73,10 +73,10 @@ BOOST_NORETURN BOOST_NOINLINE inline void throw_exception_from_error( std::excep
 // in_place_*
 
 using in_place_value_t = variant2::in_place_index_t<0>;
-constexpr in_place_value_t in_place_value{};
+BOOST_INLINE_CONSTEXPR in_place_value_t in_place_value{};
 
 using in_place_error_t = variant2::in_place_index_t<1>;
-constexpr in_place_error_t in_place_error{};
+BOOST_INLINE_CONSTEXPR in_place_error_t in_place_error{};
 
 namespace detail
 {

From 75ab18c9fd9ee37a0f616dadf257b8f5dd19f30d Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Mon, 8 Apr 2024 17:55:50 +0300
Subject: [PATCH 2/6] Support result<X> & fv, where fv returns void. Refs #119.

---
 include/boost/system/result.hpp | 40 ++++++++++++++++++++++++++++--
 test/result_and_fn1v.cpp        | 44 +++++++++++++++++++++++++++++++++
 2 files changed, 82 insertions(+), 2 deletions(-)

diff --git a/include/boost/system/result.hpp b/include/boost/system/result.hpp
index f6a41c4..d0c8d4e 100644
--- a/include/boost/system/result.hpp
+++ b/include/boost/system/result.hpp
@@ -1124,7 +1124,8 @@ result<T, E>& operator|=( result<T, E>& r, F&& f )
 
 template<class T, class E, class F,
     class U = decltype( std::declval<F>()( std::declval<T const&>() ) ),
-    class En = typename std::enable_if<!detail::is_result<U>::value>::type
+    class En1 = typename std::enable_if<!detail::is_result<U>::value>::type,
+    class En2 = typename std::enable_if<!std::is_void<U>::value>::type
 >
 result<U, E> operator&( result<T, E> const& r, F&& f )
 {
@@ -1140,7 +1141,8 @@ result<U, E> operator&( result<T, E> const& r, F&& f )
 
 template<class T, class E, class F,
     class U = decltype( std::declval<F>()( std::declval<T>() ) ),
-    class En = typename std::enable_if<!detail::is_result<U>::value>::type
+    class En1 = typename std::enable_if<!detail::is_result<U>::value>::type,
+    class En2 = typename std::enable_if<!std::is_void<U>::value>::type
 >
 result<U, E> operator&( result<T, E>&& r, F&& f )
 {
@@ -1154,6 +1156,40 @@ result<U, E> operator&( result<T, E>&& r, F&& f )
     }
 }
 
+template<class T, class E, class F,
+    class U = decltype( std::declval<F>()( std::declval<T const&>() ) ),
+    class En = typename std::enable_if<std::is_void<U>::value>::type
+>
+result<U, E> operator&( result<T, E> const& r, F&& f )
+{
+    if( r.has_error() )
+    {
+        return r.error();
+    }
+    else
+    {
+        std::forward<F>( f )( *r );
+        return {};
+    }
+}
+
+template<class T, class E, class F,
+    class U = decltype( std::declval<F>()( std::declval<T>() ) ),
+    class En = typename std::enable_if<std::is_void<U>::value>::type
+>
+result<U, E> operator&( result<T, E>&& r, F&& f )
+{
+    if( r.has_error() )
+    {
+        return r.error();
+    }
+    else
+    {
+        std::forward<F>( f )( *std::move( r ) );
+        return {};
+    }
+}
+
 template<class E, class F,
     class U = decltype( std::declval<F>()() ),
     class En = typename std::enable_if<!detail::is_result<U>::value>::type
diff --git a/test/result_and_fn1v.cpp b/test/result_and_fn1v.cpp
index 929bef5..6fb27d0 100644
--- a/test/result_and_fn1v.cpp
+++ b/test/result_and_fn1v.cpp
@@ -55,6 +55,10 @@ int k()
     return 7;
 }
 
+void fv1( int /*x*/ )
+{
+}
+
 int main()
 {
     {
@@ -199,5 +203,45 @@ int main()
         BOOST_TEST( r2.has_error() );
     }
 
+    {
+        result<int> r( 1 );
+        result<void> r2 = r & fv1;
+
+        BOOST_TEST( r2.has_value() );
+    }
+
+    {
+        result<int> const r( 1 );
+        result<void> r2 = r & fv1;
+
+        BOOST_TEST( r2.has_value() );
+    }
+
+    {
+        result<void> r2 = result<int>( 1 ) & fv1;
+
+        BOOST_TEST( r2.has_value() );
+    }
+
+    {
+        result<int, E> r( in_place_error );
+        result<void, E> r2 = r & fv1;
+
+        BOOST_TEST( r2.has_error() );
+    }
+
+    {
+        result<int, E> const r( in_place_error );
+        result<void, E> r2 = r & fv1;
+
+        BOOST_TEST( r2.has_error() );
+    }
+
+    {
+        result<void, E> r2 = result<int, E>( in_place_error ) & fv1;
+
+        BOOST_TEST( r2.has_error() );
+    }
+
     return boost::report_errors();
 }

From 96fef94580cb809cd8b91ac40fa140cf576a890b Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Mon, 8 Apr 2024 18:01:41 +0300
Subject: [PATCH 3/6] Support result<void> & fv, where fv returns void. Refs
 #119.

---
 include/boost/system/result.hpp | 20 ++++++++++++++-
 test/result_and_fn1v.cpp        | 44 +++++++++++++++++++++++++++++++++
 2 files changed, 63 insertions(+), 1 deletion(-)

diff --git a/include/boost/system/result.hpp b/include/boost/system/result.hpp
index d0c8d4e..5cd6802 100644
--- a/include/boost/system/result.hpp
+++ b/include/boost/system/result.hpp
@@ -1192,7 +1192,8 @@ result<U, E> operator&( result<T, E>&& r, F&& f )
 
 template<class E, class F,
     class U = decltype( std::declval<F>()() ),
-    class En = typename std::enable_if<!detail::is_result<U>::value>::type
+    class En1 = typename std::enable_if<!detail::is_result<U>::value>::type,
+    class En2 = typename std::enable_if<!std::is_void<U>::value>::type
 >
 result<U, E> operator&( result<void, E> const& r, F&& f )
 {
@@ -1206,6 +1207,23 @@ result<U, E> operator&( result<void, E> const& r, F&& f )
     }
 }
 
+template<class E, class F,
+    class U = decltype( std::declval<F>()() ),
+    class En = typename std::enable_if<std::is_void<U>::value>::type
+>
+result<U, E> operator&( result<void, E> const& r, F&& f )
+{
+    if( r.has_error() )
+    {
+        return r.error();
+    }
+    else
+    {
+        std::forward<F>( f )();
+        return {};
+    }
+}
+
 // result & unary-returning-result
 
 template<class T, class E, class F,
diff --git a/test/result_and_fn1v.cpp b/test/result_and_fn1v.cpp
index 6fb27d0..0a36d16 100644
--- a/test/result_and_fn1v.cpp
+++ b/test/result_and_fn1v.cpp
@@ -59,6 +59,10 @@ void fv1( int /*x*/ )
 {
 }
 
+void fv2()
+{
+}
+
 int main()
 {
     {
@@ -243,5 +247,45 @@ int main()
         BOOST_TEST( r2.has_error() );
     }
 
+    {
+        result<void> r;
+        result<void> r2 = r & fv2;
+
+        BOOST_TEST( r2.has_value() );
+    }
+
+    {
+        result<void> const r;
+        result<void> r2 = r & fv2;
+
+        BOOST_TEST( r2.has_value() );
+    }
+
+    {
+        result<void> r2 = result<void>() & fv2;
+
+        BOOST_TEST( r2.has_value() );
+    }
+
+    {
+        result<void, E> r( in_place_error );
+        result<void, E> r2 = r & fv2;
+
+        BOOST_TEST( r2.has_error() );
+    }
+
+    {
+        result<void, E> const r( in_place_error );
+        result<void, E> r2 = r & fv2;
+
+        BOOST_TEST( r2.has_error() );
+    }
+
+    {
+        result<void, E> r2 = result<void, E>( in_place_error ) & fv2;
+
+        BOOST_TEST( r2.has_error() );
+    }
+
     return boost::report_errors();
 }

From 4aeebd21730aa6517c515b9e6a554b78139049d8 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Mon, 8 Apr 2024 21:47:32 +0300
Subject: [PATCH 4/6] Avoid Appveyor timeout

---
 appveyor.yml | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/appveyor.yml b/appveyor.yml
index f9feb5a..6018f24 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -17,7 +17,11 @@ environment:
     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
       TOOLSET: msvc-14.1
       CXXSTD: 14,17,latest
-      ADDRMD: 32,64
+      ADDRMD: 32
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      TOOLSET: msvc-14.1
+      CXXSTD: 14,17,latest
+      ADDRMD: 64
     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
       ADDPATH: C:\cygwin64\bin;
       TOOLSET: gcc

From 93852d1a7e2152d6eef28b617436f0a1a3227303 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Tue, 9 Apr 2024 03:01:38 +0300
Subject: [PATCH 5/6] Support result<void> &= fv. Refs #119.

---
 include/boost/system/result.hpp | 14 ++++++++++++++
 test/result_and_eq_fn1v.cpp     | 27 +++++++++++++++++++++++++++
 2 files changed, 41 insertions(+)

diff --git a/include/boost/system/result.hpp b/include/boost/system/result.hpp
index 5cd6802..456a792 100644
--- a/include/boost/system/result.hpp
+++ b/include/boost/system/result.hpp
@@ -1296,6 +1296,20 @@ result<T, E>& operator&=( result<T, E>& r, F&& f )
     return r;
 }
 
+template<class E, class F,
+    class U = decltype( std::declval<F>()() ),
+    class En = typename std::enable_if<!detail::is_result<U>::value>::type
+>
+result<void, E>& operator&=( result<void, E>& r, F&& f )
+{
+    if( r )
+    {
+        std::forward<F>( f )();
+    }
+
+    return r;
+}
+
 // result &= unary-returning-result
 
 template<class T, class E, class F,
diff --git a/test/result_and_eq_fn1v.cpp b/test/result_and_eq_fn1v.cpp
index 4085228..dc1247d 100644
--- a/test/result_and_eq_fn1v.cpp
+++ b/test/result_and_eq_fn1v.cpp
@@ -59,6 +59,13 @@ int& h( int& )
     return x;
 }
 
+static int fv_called;
+
+void fv()
+{
+    ++fv_called;
+}
+
 int main()
 {
     {
@@ -110,5 +117,25 @@ int main()
         BOOST_TEST( r.has_error() );
     }
 
+    {
+        result<void> r;
+        fv_called = 0;
+
+        r &= fv;
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST_EQ( fv_called, 1 );
+    }
+
+    {
+        result<void, E> r( in_place_error );
+        fv_called = 0;
+
+        r &= fv;
+
+        BOOST_TEST( r.has_error() );
+        BOOST_TEST_EQ( fv_called, 0 );
+    }
+
     return boost::report_errors();
 }

From 01d46f597e891dc00bde1d9f607d57cf49512e67 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Tue, 9 Apr 2024 03:07:07 +0300
Subject: [PATCH 6/6] Update test/result_and_fn1v.cpp

---
 test/result_and_fn1v.cpp | 42 +++++++++++++++++++++++++++++++++++++++-
 1 file changed, 41 insertions(+), 1 deletion(-)

diff --git a/test/result_and_fn1v.cpp b/test/result_and_fn1v.cpp
index 0a36d16..2f5d51f 100644
--- a/test/result_and_fn1v.cpp
+++ b/test/result_and_fn1v.cpp
@@ -55,12 +55,18 @@ int k()
     return 7;
 }
 
-void fv1( int /*x*/ )
+static int fv1_called_with;
+
+void fv1( int x )
 {
+    fv1_called_with = x;
 }
 
+static int fv2_called;
+
 void fv2()
 {
+    ++fv2_called;
 }
 
 int main()
@@ -208,10 +214,13 @@ int main()
     }
 
     {
+        fv1_called_with = 0;
+
         result<int> r( 1 );
         result<void> r2 = r & fv1;
 
         BOOST_TEST( r2.has_value() );
+        BOOST_TEST_EQ( fv1_called_with, 1 );
     }
 
     {
@@ -219,72 +228,103 @@ int main()
         result<void> r2 = r & fv1;
 
         BOOST_TEST( r2.has_value() );
+        BOOST_TEST_EQ( fv1_called_with, 1 );
     }
 
     {
+        fv1_called_with = 0;
+
         result<void> r2 = result<int>( 1 ) & fv1;
 
         BOOST_TEST( r2.has_value() );
+        BOOST_TEST_EQ( fv1_called_with, 1 );
     }
 
     {
+        fv1_called_with = 0;
+
         result<int, E> r( in_place_error );
         result<void, E> r2 = r & fv1;
 
         BOOST_TEST( r2.has_error() );
+        BOOST_TEST_EQ( fv1_called_with, 0 );
     }
 
     {
+        fv1_called_with = 0;
+
         result<int, E> const r( in_place_error );
         result<void, E> r2 = r & fv1;
 
         BOOST_TEST( r2.has_error() );
+        BOOST_TEST_EQ( fv1_called_with, 0 );
     }
 
     {
+        fv1_called_with = 0;
+
         result<void, E> r2 = result<int, E>( in_place_error ) & fv1;
 
         BOOST_TEST( r2.has_error() );
+        BOOST_TEST_EQ( fv1_called_with, 0 );
     }
 
     {
         result<void> r;
+        fv2_called = 0;
+
         result<void> r2 = r & fv2;
 
         BOOST_TEST( r2.has_value() );
+        BOOST_TEST_EQ( fv2_called, 1 );
     }
 
     {
         result<void> const r;
+        fv2_called = 0;
+
         result<void> r2 = r & fv2;
 
         BOOST_TEST( r2.has_value() );
+        BOOST_TEST_EQ( fv2_called, 1 );
     }
 
     {
+        fv2_called = 0;
+
         result<void> r2 = result<void>() & fv2;
 
         BOOST_TEST( r2.has_value() );
+        BOOST_TEST_EQ( fv2_called, 1 );
     }
 
     {
         result<void, E> r( in_place_error );
+        fv2_called = 0;
+
         result<void, E> r2 = r & fv2;
 
         BOOST_TEST( r2.has_error() );
+        BOOST_TEST_EQ( fv2_called, 0 );
     }
 
     {
         result<void, E> const r( in_place_error );
+        fv2_called = 0;
+
         result<void, E> r2 = r & fv2;
 
         BOOST_TEST( r2.has_error() );
+        BOOST_TEST_EQ( fv2_called, 0 );
     }
 
     {
+        fv2_called = 0;
+
         result<void, E> r2 = result<void, E>( in_place_error ) & fv2;
 
         BOOST_TEST( r2.has_error() );
+        BOOST_TEST_EQ( fv2_called, 0 );
     }
 
     return boost::report_errors();