Implement sipper support through Task::sip 🎉

Cargo.lock

@@ -2592,6 +2592,7 @@ dependencies = [
  "iced_core",
  "iced_futures",
  "raw-window-handle 0.6.2",
+ "sipper",
  "thiserror 1.0.69",
 ]
 
@@ -5227,6 +5228,15 @@ version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "56199f7ddabf13fe5074ce809e7d3f42b42ae711800501b5b16ea82ad029c39d"
 
+[[package]]
+name = "sipper"
+version = "0.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d936de9741a68cb9452b683ffcc1fce44be7a79446ac5918319a42738da2d165"
+dependencies = [
+ "futures",
+]
+
 [[package]]
 name = "skrifa"
 version = "0.22.3"

Cargo.toml

@@ -172,6 +172,7 @@ raw-window-handle = "0.6"
 resvg = "0.42"
 rustc-hash = "2.0"
 sha2 = "0.10"
+sipper = "0.0.4"
 smol = "1.0"
 smol_str = "0.2"
 softbuffer = "0.4"

runtime/Cargo.toml

@@ -23,5 +23,6 @@ iced_core.workspace = true
 iced_futures.workspace = true
 iced_futures.features = ["thread-pool"]
 
-thiserror.workspace = true
 raw-window-handle.workspace = true
+sipper.workspace = true
+thiserror.workspace = true

runtime/src/task.rs

@@ -3,7 +3,6 @@ use crate::core::widget;
 use crate::futures::futures::channel::mpsc;
 use crate::futures::futures::channel::oneshot;
 use crate::futures::futures::future::{self, FutureExt};
-use crate::futures::futures::never::Never;
 use crate::futures::futures::stream::{self, Stream, StreamExt};
 use crate::futures::{boxed_stream, BoxStream, MaybeSend};
 use crate::Action;
@@ -11,6 +10,9 @@ use crate::Action;
 use std::future::Future;
 use std::sync::Arc;
 
+#[doc(no_inline)]
+pub use sipper::{sipper, stream, Never, Sender, Sipper, Straw};
+
 /// A set of concurrent actions to be performed by the iced runtime.
 ///
 /// A [`Task`] _may_ produce a bunch of values of type `T`.
@@ -57,6 +59,25 @@ impl<T> Task<T> {
         Self::stream(stream.map(f))
     }
 
+    /// Creates a [`Task`] that runs the given [`Sipper`] to completion, mapping
+    /// progress with the first closure and the output with the second one.
+    pub fn sip<S, Output, Progress>(
+        sipper: S,
+        on_progress: impl Fn(Progress) -> T + Send + 'static,
+        on_output: impl FnOnce(Output) -> T + Send + 'static,
+    ) -> Self
+    where
+        S: Sipper<Output, Progress> + Send + 'static,
+        S::Future: Send + 'static,
+        Output: Send,
+        Progress: Send,
+        T: Send + 'static,
+    {
+        Self::stream(stream(sipper::sipper(move |sender| async move {
+            on_output(sipper.map(on_progress).run(sender).await)
+        })))
+    }
+
     /// Combines the given tasks and produces a single [`Task`] that will run all of them
     /// in parallel.
     pub fn batch(tasks: impl IntoIterator<Item = Self>) -> Self