refactor!: make io_result an alias for std::tuple

bench/beman/ioaw_read_stream.hpp

@@ -42,7 +42,7 @@ struct ioaw_read_stream
         }
 
         boost::capy::io_result<std::size_t>
-        await_resume() noexcept { return {{}, 0}; }
+        await_resume() noexcept { return {std::error_code(), 0}; }
     };
 
     template <boost::capy::MutableBufferSequence MB>

bench/beman/ioaw_sync_read_stream.hpp

@@ -46,7 +46,7 @@ struct ioaw_sync_read_stream
         boost::capy::io_result<std::size_t>
         await_resume() noexcept
         {
-            return {{}, 0};
+            return {std::error_code(), 0};
         }
     };
 

bench/beman/sender_awaitable.hpp

@@ -342,7 +342,7 @@ struct [[nodiscard]] sender_awaitable
                 return io_result<T>{
                     std::get<2>(result_)};
             return io_result<T>{
-                {},
+                std::error_code(),
                 std::get<0>(
                     std::get<1>(
                         std::move(result_)))};
@@ -357,7 +357,7 @@ struct [[nodiscard]] sender_awaitable
                 return io_result<value_tuple>{
                     std::get<2>(result_)};
             return io_result<value_tuple>{
-                {},
+                std::error_code(),
                 std::get<1>(
                     std::move(result_))};
         }

bench/stdexec/ioaw_read_stream.hpp

@@ -42,7 +42,7 @@ struct ioaw_read_stream
         }
 
         boost::capy::io_result<std::size_t>
-        await_resume() noexcept { return {{}, 0}; }
+        await_resume() noexcept { return {std::error_code(), 0}; }
     };
 
     template <boost::capy::MutableBufferSequence MB>

bench/stdexec/ioaw_sync_read_stream.hpp

@@ -46,7 +46,7 @@ struct ioaw_sync_read_stream
         boost::capy::io_result<std::size_t>
         await_resume() noexcept
         {
-            return {{}, 0};
+            return {std::error_code(), 0};
         }
     };
 

bench/stdexec/sender_awaitable.hpp

@@ -341,7 +341,7 @@ struct [[nodiscard]] sender_awaitable
                 return io_result<T>{
                     std::get<2>(result_), T{}};
             return io_result<T>{
-                {},
+                std::error_code(),
                 std::get<0>(
                     std::get<1>(
                         std::move(result_)))};
@@ -356,7 +356,7 @@ struct [[nodiscard]] sender_awaitable
                 return io_result<value_tuple>{
                     std::get<2>(result_), value_tuple{}};
             return io_result<value_tuple>{
-                {},
+                std::error_code(),
                 std::get<1>(
                     std::move(result_))};
         }

doc/modules/ROOT/pages/4.coroutines/4f.composition.adoc

@@ -45,7 +45,7 @@ include::example$snippets/4f_composition.cpp[tag=when_all_basic,indent=0]
 include::example$snippets/4f_composition.cpp[tag=when_all_void_mix,indent=0]
 ----
 
-When all children are `io_task<>`, just check `r.ec`:
+When all children are `io_task<>`, just check the error code:
 
 [source,cpp]
 ----

doc/modules/ROOT/pages/8.examples/8g.parallel-fetch.adoc

@@ -46,7 +46,7 @@ include::example$parallel-fetch/parallel_fetch.cpp[tag=when_all_dashboard,indent
 include::example$parallel-fetch/parallel_fetch.cpp[tag=when_all_void,indent=0]
 ----
 
-`io_task<>` children return `io_result<>` (just an error code, no payload). Check `r.ec` to detect failure.
+`io_task<>` children return `io_result<>` (just an error code, no payload). Check `std::get<0>(r)` to detect failure.
 
 === Error Propagation
 

doc/modules/ROOT/pages/9.design/9i.TypeEraseAwaitable.adoc

@@ -72,7 +72,7 @@ std::coroutine_handle<> await_suspend(std::coroutine_handle<> h, io_env const* e
 
 io_result<size_t> await_resume() {
     if(!awaitable_active_)
-        return {{}, 0};                  // short-circuited
+        return {std::error_code(), 0};                  // short-circuited
     auto r = vt_->await_resume(cached_awaitable_);
     vt_->destroy_awaitable(cached_awaitable_);
     awaitable_active_ = false;
@@ -130,7 +130,7 @@ std::coroutine_handle<> await_suspend(std::coroutine_handle<> h, io_env const* e
 
 io_result<size_t> await_resume() {
     if(!active_ops_)
-        return {{}, 0};                  // short-circuited
+        return {std::error_code(), 0};                  // short-circuited
     auto r = active_ops_->await_resume(cached_awaitable_);
     active_ops_->destroy(cached_awaitable_);
     active_ops_ = nullptr;

doc/modules/ROOT/pages/A.specification-methods/Ac.contingencies.adoc

@@ -18,7 +18,7 @@ as their postconditions never say that the requested number of bytes will indeed
 processed.
 
 Each stream operation that may encounter a contingency await-returns
-a type which is a specialization of `capy::io_result`. These objects can be _destructured_
+an instance of `capy::io_result`. These objects can be _destructured_
 using a structured binding. The first binding of such destructuring is of type
 `std::error_code`. This binding, call it `ec`, is used to signal if and which
 contingency occured:

doc/unlisted/coroutines-when-all.adoc

@@ -83,7 +83,7 @@ auto r = co_await when_all(
     task_void(),
     task_void()
 );
-if (r.ec)
+if (std::get<0>(r))
     // handle error
 ----
 

doc/unlisted/coroutines-when-any.adoc

@@ -233,10 +233,10 @@ io_task<Response> fetch_with_cancel_support()
     for (auto& chunk : data_source)
     {
         if (token.stop_requested())
-            co_return io_result<Response>{{}, partial_response()};
+            co_return io_result<Response>{std::error_code(), partial_response()};
         co_await send_chunk(chunk);
     }
-    co_return io_result<Response>{{}, complete_response()};
+    co_return io_result<Response>{std::error_code(), complete_response()};
 }
 
 task<> example()
@@ -333,7 +333,7 @@ io_task<Response> fetch_with_redundancy(Request req)
         if constexpr (!std::is_same_v<std::decay_t<decltype(v)>, std::error_code>)
             resp = v;
     }, result);
-    co_return io_result<Response>{{}, std::move(resp)};
+    co_return io_result<Response>{std::error_code(), std::move(resp)};
 }
 ----
 
@@ -357,7 +357,7 @@ io_task<Connection> get_connection(std::vector<ConnectionPool>& pools)
 
     auto& [index, conn] = std::get<1>(result);
     std::cout << "Got connection from pool " << index << "\n";
-    co_return io_result<Connection>{{}, std::move(conn)};
+    co_return io_result<Connection>{std::error_code(), std::move(conn)};
 }
 ----
 

doc/unlisted/library-io-result.adoc

@@ -62,7 +62,30 @@ Features:
 * Structured bindings for clean syntax
 * Error code is always present
 * Additional values (bytes transferred, etc.) included
-* `[[nodiscard]]` prevents ignoring results
+* An alias for `std::tuple`, so the whole standard tuple API
+  applies: `std::tie`, `std::apply`, `std::get`, comparisons
+* Library awaitables mark `await_resume` `[[nodiscard]]`, so
+  discarding a result is diagnosed
+
+== Rebinding with std::tie
+
+When a coroutine performs several operations in sequence,
+`std::tie` reassigns into existing variables instead of
+introducing a new binding per operation:
+
+[source,cpp]
+----
+std::error_code ec;
+std::size_t n = 0;
+
+std::tie(ec, n) = co_await s.read_some(buf);
+if (ec)
+    co_return ec;
+
+std::tie(ec, n) = co_await s.write(buf);
+if (ec)
+    co_return ec;
+----
 
 == io_result Variants
 
@@ -185,7 +208,7 @@ io_task<std::size_t> read_all(stream& s, buffer& buf)
         buf.commit(n);
         total += n;
     }
-    co_return {{}, total};  // Success with total bytes
+    co_return {std::error_code(), total};  // Success with total bytes
 }
 ----
 

example/asio/any_stream.cpp

@@ -82,8 +82,8 @@ run_example(
         writer(client_stream, total_bytes),
         reader(server_stream, total_bytes));
 
-    if(r.ec)
-        std::printf("example error: %s\n", r.ec.message().c_str());
+    if(std::get<0>(r))
+        std::printf("example error: %s\n", std::get<0>(r).message().c_str());
     else
         std::printf("example complete!\n");
 }

example/asio/api/capy_streams.cpp

@@ -114,8 +114,8 @@ class asio_socket
                         boost::system::error_code ec,
                         std::size_t n) mutable
                     {
-                        result_.ec = ec;
-                        std::get<0>(result_.values) = n;
+                        std::get<0>(result_) = ec;
+                        std::get<1>(result_) = n;
                         ex.post(cont_);
                     }));
 
@@ -178,8 +178,8 @@ class asio_socket
                         boost::system::error_code ec,
                         std::size_t n) mutable
                     {
-                        result_.ec = ec;
-                        std::get<0>(result_.values) = n;
+                        std::get<0>(result_) = ec;
+                        std::get<1>(result_) = n;
                         ex.post(cont_);
                     }));
 

example/asio/api/use_capy.hpp

@@ -162,31 +162,31 @@ class capy_awaitable
 private:
     void store_result(boost::system::error_code ec)
     {
-        result_.ec = ec;
+        std::get<0>(result_) = ec;
     }
 
     template<typename T1>
     void store_result(boost::system::error_code ec, T1&& t1)
     {
-        result_.ec = ec;
-        std::get<0>(result_.values) = std::forward<T1>(t1);
+        std::get<0>(result_) = ec;
+        std::get<1>(result_) = std::forward<T1>(t1);
     }
 
     template<typename T1, typename T2>
     void store_result(boost::system::error_code ec, T1&& t1, T2&& t2)
     {
-        result_.ec = ec;
-        std::get<0>(result_.values) = std::forward<T1>(t1);
-        std::get<1>(result_.values) = std::forward<T2>(t2);
+        std::get<0>(result_) = ec;
+        std::get<1>(result_) = std::forward<T1>(t1);
+        std::get<2>(result_) = std::forward<T2>(t2);
     }
 
     template<typename T1, typename T2, typename T3>
     void store_result(boost::system::error_code ec, T1&& t1, T2&& t2, T3&& t3)
     {
-        result_.ec = ec;
-        std::get<0>(result_.values) = std::forward<T1>(t1);
-        std::get<1>(result_.values) = std::forward<T2>(t2);
-        std::get<2>(result_.values) = std::forward<T3>(t3);
+        std::get<0>(result_) = ec;
+        std::get<1>(result_) = std::forward<T1>(t1);
+        std::get<2>(result_) = std::forward<T2>(t2);
+        std::get<3>(result_) = std::forward<T3>(t3);
     }
 };
 

example/asio/use_capy_example.cpp

@@ -95,8 +95,8 @@ run_example(
         writer(client, total_bytes),
         reader(server, total_bytes));
 
-    if (r.ec)
-        std::printf("example error: %s\n", r.ec.message().c_str());
+    if (std::get<0>(r))
+        std::printf("example error: %s\n", std::get<0>(r).message().c_str());
     else
         std::printf("example complete!\n");
 }

example/async-mutex/async_mutex.cpp

@@ -72,9 +72,9 @@ int main()
         auto r = co_await capy::when_all(
             worker(0), worker(1), worker(2),
             worker(3), worker(4), worker(5));
-        if(r.ec)
+        if(std::get<0>(r))
             std::cerr << "when_all error: "
-                      << r.ec.message() << "\n";
+                      << std::get<0>(r).message() << "\n";
     };
 
     // Run on a strand so async_mutex operations are single-threaded

example/cuda/datamovement/cuda_datamovement.hpp

@@ -339,7 +339,7 @@ class cuda_device_stream
                 }
                 auto n = buf.size();
                 self->offset_ += n;
-                return {{}, n};
+                return {std::error_code(), n};
             }
         };
         return awaitable{this, *capy::begin(buffers)};

example/cuda/pipeline/sender_awaitable.hpp

@@ -342,7 +342,7 @@ struct [[nodiscard]] sender_awaitable
                 return io_result<T>{
                     std::get<2>(result_), T{}};
             return io_result<T>{
-                {},
+                std::error_code(),
                 std::get<0>(
                     std::get<1>(
                         std::move(result_)))};
@@ -357,7 +357,7 @@ struct [[nodiscard]] sender_awaitable
                 return io_result<value_tuple>{
                     std::get<2>(result_), value_tuple{}};
             return io_result<value_tuple>{
-                {},
+                std::error_code(),
                 std::get<1>(
                     std::move(result_))};
         }

example/custom-executor/custom_executor.cpp

@@ -138,7 +138,7 @@ static_assert(capy::Executor<run_loop::executor_type>);
 capy::io_task<int> compute(int x)
 {
     std::cout << "  computing " << x << " * " << x << "\n";
-    co_return capy::io_result<int>{{}, x * x};
+    co_return capy::io_result<int>{std::error_code(), x * x};
 }
 
 capy::task<> run_tasks()

example/parallel-fetch/parallel_fetch.cpp

@@ -57,7 +57,7 @@ capy::task<> fetch_user_dashboard(std::string username)
 
     auto wrap = [](auto inner) -> capy::io_task<decltype(inner.await_resume())> {
         co_return capy::io_result<decltype(inner.await_resume())>{
-            {}, co_await std::move(inner)};
+            std::error_code(), co_await std::move(inner)};
     };
 
     // tag::when_all_dashboard[]
@@ -94,7 +94,7 @@ capy::task<std::string> fetch_with_side_effects()
     auto r = co_await capy::when_all(
         log_access("api/data"),
         update_metrics("api_calls"));
-    if (r.ec)
+    if (std::get<0>(r))
         co_return "error";
     // end::when_all_void[]
 
@@ -115,7 +115,7 @@ capy::io_task<int> might_fail(bool should_fail, std::string name)
     }
 
     std::cout << "Task " << name << " completed\n";
-    co_return capy::io_result<int>{{}, 42};
+    co_return capy::io_result<int>{std::error_code(), 42};
 }
 
 capy::task<> demonstrate_error_handling()

example/parallel-tasks/parallel_tasks.cpp

@@ -35,7 +35,7 @@ capy::io_task<long long> partial_sum(int lo, int hi)
     long long sum = 0;
     for (int i = lo; i < hi; ++i)
         sum += i;
-    co_return capy::io_result<long long>{{}, sum};
+    co_return capy::io_result<long long>{std::error_code(), sum};
 }
 
 int main()

example/sender-bridge/sender_awaitable.hpp

@@ -320,7 +320,7 @@ struct [[nodiscard]] sender_awaitable
                 return io_result<T>{
                     std::get<2>(result_)};
             return io_result<T>{
-                {},
+                std::error_code(),
                 std::get<0>(
                     std::get<1>(
                         std::move(result_)))};
@@ -335,7 +335,7 @@ struct [[nodiscard]] sender_awaitable
                 return io_result<value_tuple>{
                     std::get<2>(result_)};
             return io_result<value_tuple>{
-                {},
+                std::error_code(),
                 std::get<1>(
                     std::move(result_))};
         }

example/timeout-cancellation/timeout_cancellation.cpp

@@ -78,7 +78,7 @@ capy::io_task<std::string> await_fetch(fetch_channel& ch)
         ch.cancelled.store(true);
         co_return capy::io_result<std::string>{ec, {}};
     }
-    co_return capy::io_result<std::string>{{}, std::move(ch.result)};
+    co_return capy::io_result<std::string>{std::error_code(), std::move(ch.result)};
 }
 // end::race_await_fetch[]