refactor(tee): introduce retain_with method for MultiWriter

Author: xtqqczze

src/uu/tee/src/tee.rs

@@ -236,24 +236,33 @@ fn process_error(
     }
 }
 
-impl Write for MultiWriter {
-    fn write(&mut self, buf: &[u8]) -> Result<usize> {
+impl MultiWriter {
+    fn retain_with<F>(&mut self, mut f: F) -> Result<()>
+    where
+        F: FnMut(&mut NamedWriter) -> Result<()>,
+    {
         let mut aborted = None;
         let mode = self.output_error_mode.clone();
         let mut errors = 0;
-        self.writers.retain_mut(|writer| {
-            writer
-                .write_all(buf)
-                .map_err(|f| {
-                    let _ = process_error(mode.as_ref(), f, writer, &mut errors)
-                        .map_err(|e| aborted.get_or_insert(e));
-                })
-                .is_ok()
+        self.writers.retain_mut(|writer| match f(writer) {
+            Ok(()) => true,
+            Err(f) => {
+                if let Err(e) = process_error(mode.as_ref(), f, writer, &mut errors) {
+                    aborted.get_or_insert(e);
+                }
+                false
+            }
         });
         self.ignored_errors += errors;
-        if let Some(e) = aborted {
-            Err(e)
-        } else if self.writers.is_empty() {
+        aborted.map_or(Ok(()), Err)
+    }
+}
+
+impl Write for MultiWriter {
+    fn write(&mut self, buf: &[u8]) -> Result<usize> {
+        self.retain_with(|w| w.write_all(buf))?;
+
+        if self.writers.is_empty() {
             // This error kind will never be raised by the standard
             // library, so we can use it for early termination of
             // `copy`
@@ -264,24 +273,7 @@ impl Write for MultiWriter {
     }
 
     fn flush(&mut self) -> Result<()> {
-        let mut aborted = None;
-        let mode = self.output_error_mode.clone();
-        let mut errors = 0;
-        self.writers.retain_mut(|writer| {
-            writer
-                .flush()
-                .map_err(|f| {
-                    let _ = process_error(mode.as_ref(), f, writer, &mut errors)
-                        .map_err(|e| aborted.get_or_insert(e));
-                })
-                .is_ok()
-        });
-        self.ignored_errors += errors;
-        if let Some(e) = aborted {
-            Err(e)
-        } else {
-            Ok(())
-        }
+        self.retain_with(|w| w.flush())
     }
 }