app: refactor: pull event actions to functions

src/app.rs

···
     ) -> Result<bool, io::Error> {
         let mut quit = false;
 
-        let play = |graph: &mut GraphConfig| {
-            graph.pause = false;
-            sink_cmd_tx
-                .send(SinkCommand::Play)
-                .expect("receiver never dropped");
-        };
-
-        let pause = |graph: &mut GraphConfig| {
-            graph.pause = true;
-            sink_cmd_tx
-                .send(SinkCommand::Pause)
-                .expect("receiver never dropped");
-        };
-
-        let toggle_play_pause = |graph: &mut GraphConfig| {
-            graph.pause = !graph.pause;
-            let sink_cmd = if graph.pause {
-                SinkCommand::Pause
-            } else {
-                SinkCommand::Play
-            };
-            sink_cmd_tx.send(sink_cmd).expect("receiver never dropped");
-        };
-
-        let lower_volume = || {
-            let mut state = state.lock().unwrap();
-            state.volume.change_volume(-1.0);
-            sink_cmd_tx
-                .send(SinkCommand::SetVolume(state.volume.volume_ratio()))
-                .expect("receiver never dropped");
-        };
-
-        let raise_volume = || {
-            let mut state = state.lock().unwrap();
-            state.volume.change_volume(1.0);
-            sink_cmd_tx
-                .send(SinkCommand::SetVolume(state.volume.volume_ratio()))
-                .expect("receiver never dropped");
-        };
-
-        let mute_volume = || {
-            let mut state = state.lock().unwrap();
-            state.volume.toggle_mute();
-            sink_cmd_tx
-                .send(SinkCommand::SetVolume(state.volume.volume_ratio()))
-                .expect("receiver never dropped");
-        };
-
         if let Event::Key(key) = event {
             if let KeyModifiers::CONTROL = key.modifiers {
                 match key.code {
···
                 KeyCode::Up => {
                     // inverted to act as zoom
                     update_value_f(&mut self.graph.scale, 0.01, magnitude, 0.0..10.0);
-                    raise_volume();
+                    raise_volume(&state, sink_cmd_tx);
                 }
                 KeyCode::Down => {
                     // inverted to act as zoom
                     update_value_f(&mut self.graph.scale, -0.01, magnitude, 0.0..10.0);
-                    lower_volume();
+                    lower_volume(&state, sink_cmd_tx);
                 }
                 KeyCode::Right => update_value_i(
                     &mut self.graph.samples,
···
                     0..self.graph.width * 2,
                 ),
                 KeyCode::Char('q') => quit = true,
-                KeyCode::Char(' ') => toggle_play_pause(&mut self.graph),
+                KeyCode::Char(' ') => toggle_play_pause(&mut self.graph, sink_cmd_tx),
                 KeyCode::Char('s') => self.graph.scatter = !self.graph.scatter,
                 KeyCode::Char('h') => self.graph.show_ui = !self.graph.show_ui,
                 KeyCode::Char('r') => self.graph.references = !self.graph.references,
-                KeyCode::Char('m') => mute_volume(),
+                KeyCode::Char('m') => mute_volume(&state, sink_cmd_tx),
                 KeyCode::Esc => {
                     self.graph.samples = self.graph.width;
                     self.graph.scale = 1.;
···
                     }
                 }
                 KeyCode::Media(media_key_code) => match media_key_code {
-                    MediaKeyCode::Play => play(&mut self.graph),
-                    MediaKeyCode::Pause => pause(&mut self.graph),
-                    MediaKeyCode::PlayPause => toggle_play_pause(&mut self.graph),
+                    MediaKeyCode::Play => play(&mut self.graph, sink_cmd_tx),
+                    MediaKeyCode::Pause => pause(&mut self.graph, sink_cmd_tx),
+                    MediaKeyCode::PlayPause => toggle_play_pause(&mut self.graph, sink_cmd_tx),
                     MediaKeyCode::Stop => {
                         quit = true;
                     }
-                    MediaKeyCode::LowerVolume => lower_volume(),
-                    MediaKeyCode::RaiseVolume => raise_volume(),
-                    MediaKeyCode::MuteVolume => mute_volume(),
+                    MediaKeyCode::LowerVolume => lower_volume(&state, sink_cmd_tx),
+                    MediaKeyCode::RaiseVolume => raise_volume(&state, sink_cmd_tx),
+                    MediaKeyCode::MuteVolume => mute_volume(&state, sink_cmd_tx),
                     MediaKeyCode::TrackNext
                     | MediaKeyCode::TrackPrevious
                     | MediaKeyCode::Reverse
···
     )
     .style(Style::default().fg(cfg.labels_color))
 }
+
+/// Play music.
+fn play(graph: &mut GraphConfig, sink_cmd_tx: &UnboundedSender<SinkCommand>) {
+    graph.pause = false;
+    sink_cmd_tx
+        .send(SinkCommand::Play)
+        .expect("receiver never dropped");
+}
+
+/// Pause music.
+fn pause(graph: &mut GraphConfig, sink_cmd_tx: &UnboundedSender<SinkCommand>) {
+    graph.pause = true;
+    sink_cmd_tx
+        .send(SinkCommand::Pause)
+        .expect("receiver never dropped");
+}
+
+/// Toggle between play and pause.
+fn toggle_play_pause(graph: &mut GraphConfig, sink_cmd_tx: &UnboundedSender<SinkCommand>) {
+    graph.pause = !graph.pause;
+    let sink_cmd = if graph.pause {
+        SinkCommand::Pause
+    } else {
+        SinkCommand::Play
+    };
+    sink_cmd_tx.send(sink_cmd).expect("receiver never dropped");
+}
+
+/// Lower the volume.
+fn lower_volume(state: &Arc<Mutex<State>>, sink_cmd_tx: &UnboundedSender<SinkCommand>) {
+    let mut state = state.lock().unwrap();
+    state.volume.change_volume(-1.0);
+    sink_cmd_tx
+        .send(SinkCommand::SetVolume(state.volume.volume_ratio()))
+        .expect("receiver never dropped");
+}
+
+/// Raise the volume.
+fn raise_volume(state: &Arc<Mutex<State>>, sink_cmd_tx: &UnboundedSender<SinkCommand>) {
+    let mut state = state.lock().unwrap();
+    state.volume.change_volume(1.0);
+    sink_cmd_tx
+        .send(SinkCommand::SetVolume(state.volume.volume_ratio()))
+        .expect("receiver never dropped");
+}
+
+/// Mute the volume.
+fn mute_volume(state: &Arc<Mutex<State>>, sink_cmd_tx: &UnboundedSender<SinkCommand>) {
+    let mut state = state.lock().unwrap();
+    state.volume.toggle_mute();
+    sink_cmd_tx
+        .send(SinkCommand::SetVolume(state.volume.volume_ratio()))
+        .expect("receiver never dropped");
+}