refactor: reaplace unwrap_or(()) with .ok()

src/docker_data/mod.rs

@@ -109,8 +109,8 @@ impl DockerData {
             .take(1);
 
         while let Some(Ok(stats)) = stream.next().await {
-            let mem_stat = stats.memory_stats.usage.unwrap_or(0);
-            let mem_limit = stats.memory_stats.limit.unwrap_or(0);
+            let mem_stat = stats.memory_stats.usage.unwrap_or_default();
+            let mem_limit = stats.memory_stats.limit.unwrap_or_default();
 
             let op_key = stats
                 .networks

src/input_handler/mod.rs

@@ -251,32 +251,26 @@ impl InputHandler {
                             };
                             if let Some(id) = option_id {
                                 match command {
-                                    DockerControls::Pause => self
-                                        .docker_sender
-                                        .send(DockerMessage::Pause(id))
-                                        .await
-                                        .unwrap_or(()),
+                                    DockerControls::Pause => {
+                                        self.docker_sender.send(DockerMessage::Pause(id)).await.ok()
+                                    }
                                     DockerControls::Unpause => self
                                         .docker_sender
                                         .send(DockerMessage::Unpause(id))
                                         .await
-                                        .unwrap_or(()),
-                                    DockerControls::Start => self
-                                        .docker_sender
-                                        .send(DockerMessage::Start(id))
-                                        .await
-                                        .unwrap_or(()),
-                                    DockerControls::Stop => self
-                                        .docker_sender
-                                        .send(DockerMessage::Stop(id))
-                                        .await
-                                        .unwrap_or(()),
+                                        .ok(),
+                                    DockerControls::Start => {
+                                        self.docker_sender.send(DockerMessage::Start(id)).await.ok()
+                                    }
+                                    DockerControls::Stop => {
+                                        self.docker_sender.send(DockerMessage::Stop(id)).await.ok()
+                                    }
                                     DockerControls::Restart => self
                                         .docker_sender
                                         .send(DockerMessage::Restart(id))
                                         .await
-                                        .unwrap_or(()),
-                                }
+                                        .ok(),
+                                };
                             }
                         }
                     }

src/main.rs

@@ -55,10 +55,7 @@ fn setup_tracing() {
 /// An ENV is set in the ./containerised/Dockerfile, if this is ENV found, then sleep for 250ms, else the container, for as yet unknown reasons, will close immediately
 /// returns a bool, so that the `update_all_containers()` won't bother to check the entry point unless running via a container
 fn check_if_containerised() -> bool {
-    if std::env::vars()
-        .into_iter()
-        .any(|x| x == (ENV_KEY.into(), ENV_VALUE.into()))
-    {
+    if std::env::vars().any(|x| x == (ENV_KEY.into(), ENV_VALUE.into())) {
         std::thread::sleep(std::time::Duration::from_millis(250));
         true
     } else {
@@ -141,7 +138,7 @@ async fn main() {
         while is_running.load(Ordering::SeqCst) {
             // Debug mode for testing, mostly pointless, doesn't take terminal
             loop {
-                docker_sx.send(DockerMessage::Update).await.unwrap_or(());
+                docker_sx.send(DockerMessage::Update).await.ok();
                 tokio::time::sleep(std::time::Duration::from_millis(u64::from(
                     args.docker_interval,
                 )))

src/ui/mod.rs

@@ -158,31 +158,25 @@ impl Ui {
                         self.sender
                             .send(InputMessages::ButtonPress((key.code, key.modifiers)))
                             .await
-                            .unwrap_or(());
+                            .ok();
                     } else if let Event::Mouse(m) = event {
                         match m.kind {
                             event::MouseEventKind::Down(_)
                             | event::MouseEventKind::ScrollDown
                             | event::MouseEventKind::ScrollUp => {
-                                self.sender
-                                    .send(InputMessages::MouseEvent(m))
-                                    .await
-                                    .unwrap_or(());
+                                self.sender.send(InputMessages::MouseEvent(m)).await.ok();
                             }
                             _ => (),
                         }
                     } else if let Event::Resize(_, _) = event {
                         self.gui_state.lock().clear_area_map();
-                        self.terminal.autoresize().unwrap_or(());
+                        self.terminal.autoresize().ok();
                     }
                 }
             }
 
             if self.now.elapsed() >= update_duration {
-                self.docker_sx
-                    .send(DockerMessage::Update)
-                    .await
-                    .unwrap_or(());
+                self.docker_sx.send(DockerMessage::Update).await.ok();
                 self.now = Instant::now();
             }
         }