Introduce Task::map_with

examples/download_progress/src/main.rs

@@ -52,7 +52,7 @@ impl Example {
 
                 let task = download.start();
 
-                task.map(move |update| Message::DownloadUpdated(index, update))
+                task.map_with(index, Message::DownloadUpdated)
             }
             Message::DownloadUpdated(id, update) => {
                 if let Some(download) =

examples/gallery/src/main.rs

@@ -94,17 +94,15 @@ impl Gallery {
                     return Task::none();
                 };
 
-                Task::batch(vec![
-                    Task::perform(
+                Task::batch([
+                    Task::future(
                         image.clone().blurhash(Preview::WIDTH, Preview::HEIGHT),
-                        move |result| Message::BlurhashDecoded(id, result),
-                    ),
-                    Task::perform(
-                        image.download(Size::Thumbnail {
+                    )
+                    .map_with(id, Message::BlurhashDecoded),
+                    Task::future(image.download(Size::Thumbnail {
                         width: Preview::WIDTH,
-                        }),
-                        move |result| Message::ThumbnailDownloaded(id, result),
-                    ),
+                    }))
+                    .map_with(id, Message::ThumbnailDownloaded),
                 ])
             }
             Message::ImageDownloaded(Ok(rgba)) => {

futures/src/lib.rs

@@ -15,6 +15,7 @@ pub mod backend;
 pub mod event;
 pub mod executor;
 pub mod keyboard;
+pub mod stream;
 pub mod subscription;
 
 pub use executor::Executor;

runtime/src/task.rs

@@ -98,6 +98,50 @@ impl<T> Task<T> {
         self.then(move |output| Task::done(f(output)))
     }
 
+    /// Combines a prefix value with the result of the [`Task`] using
+    /// the provided closure.
+    ///
+    /// Sometimes you will want to identify the source or target
+    /// of some [`Task`] in your UI. This can be achieved through
+    /// normal means by using [`map`]:
+    ///
+    /// ```rust
+    /// # use iced_runtime::Task;
+    /// # let task = Task::none();
+    /// # enum Message { TaskCompleted(u32, ()) }
+    /// let id = 123;
+    ///
+    /// # let _ = {
+    /// task.map(move |result| Message::TaskCompleted(id, result))
+    /// # };
+    /// ```
+    ///
+    /// Quite a mouthful. [`map_with`] lets you write:
+    ///
+    /// ```rust
+    /// # use iced_runtime::Task;
+    /// # let task = Task::none();
+    /// # enum Message { TaskCompleted(u32, ()) }
+    /// # let id = 123;
+    /// # let _ = {
+    /// task.map_with(id, Message::TaskCompleted)
+    /// # };
+    /// ```
+    ///
+    /// Much nicer!
+    pub fn map_with<P, O>(
+        self,
+        prefix: P,
+        mut f: impl FnMut(P, T) -> O + MaybeSend + 'static,
+    ) -> Task<O>
+    where
+        T: MaybeSend + 'static,
+        P: MaybeSend + Clone + 'static,
+        O: MaybeSend + 'static,
+    {
+        self.map(move |result| f(prefix.clone(), result))
+    }
+
     /// Performs a new [`Task`] for every output of the current [`Task`] using the
     /// given closure.
     ///

src/lib.rs

@@ -478,6 +478,7 @@ use iced_winit::core;
 use iced_winit::runtime;
 
 pub use iced_futures::futures;
+pub use iced_futures::stream;
 
 #[cfg(feature = "highlighter")]
 pub use iced_highlighter as highlighter;