Refac unnecessary ref mut pattern matching

examples/draw/draw_arrow.rs

@@ -12,12 +12,14 @@ fn view(app: &App, frame: Frame) {
     for r in r.subdivisions_iter() {
         for r in r.subdivisions_iter() {
             for r in r.subdivisions_iter() {
-                let side = r.w().min(r.h());
-                let start = r.xy();
-                let start_to_mouse = app.mouse.position() - start;
-                let target_mag = start_to_mouse.length().min(side * 0.5);
-                let end = start + start_to_mouse.normalize_or_zero() * target_mag;
-                draw.arrow().weight(5.0).points(start, end);
+                for r in r.subdivisions_iter() {
+                    let side = r.w().min(r.h());
+                    let start = r.xy();
+                    let start_to_mouse = app.mouse.position() - start;
+                    let target_mag = start_to_mouse.length().min(side * 0.5);
+                    let end = start + start_to_mouse.normalize_or_zero() * target_mag;
+                    draw.arrow().weight(5.0).points(start, end);
+                }
             }
         }
     }

examples/laser/laser_frame_stream_gui.rs

@@ -326,7 +326,7 @@ fn update(_app: &App, model: &mut Model, update: Update) {
         ref mut egui,
         ref laser_streams,
         ref mut laser_model,
-        ref mut laser_settings,
+        laser_settings,
         ..
     } = *model;
 

examples/ui/egui/circle_packing.rs

@@ -52,11 +52,11 @@ fn model(app: &App) -> Model {
 
 fn update(_app: &App, model: &mut Model, update: Update) {
     let Model {
-        ref mut egui,
-        ref mut settings,
-        ref mut circles,
+        egui,
+        settings,
+        circles,
         ..
-    } = *model;
+    } = model;
 
     egui.set_elapsed_time(update.since_start);
     let ctx = egui.begin_frame();
@@ -72,7 +72,7 @@ fn update(_app: &App, model: &mut Model, update: Update) {
             .add(egui::Slider::new(&mut settings.circle_count, 0..=2000).text("circle count"))
             .changed();
         changed |= ui.button("Generate").clicked();
-        if changed {
+        if !changed {
             *circles = generate_circles(settings);
         }
     });

examples/ui/egui/tune_color.rs

@@ -36,10 +36,10 @@ fn model(app: &App) -> Model {
 
 fn update(_app: &App, model: &mut Model, update: Update) {
     let Model {
-        ref mut egui,
-        ref mut radius,
-        ref mut color,
-    } = *model;
+        egui,
+        radius,
+        color,
+    } = model;
 
     egui.set_elapsed_time(update.since_start);
     let ctx = egui.begin_frame();

generative_design/shape/p_2_1_5_03.rs

@@ -110,7 +110,7 @@ fn model(app: &App) -> Model {
 }
 
 fn update(app: &App, model: &mut Model, _update: Update) {
-    if let Some(ref mut s) = model.new_shape {
+    if let Some(s) = model.new_shape {
         s.x2 = app.mouse.x;
         s.y2 = app.mouse.y;
         s.h = model.shape_height;

nannou/src/draw/drawing.rs

@@ -73,12 +73,12 @@ impl<'a> DrawingContext<'a> {
     // Initialise the DrawingContext from the draw's IntermediaryState.
     pub(crate) fn from_intermediary_state(state: &'a mut super::IntermediaryState) -> Self {
         let super::IntermediaryState {
-            ref mut intermediary_mesh,
-            ref mut path_event_buffer,
-            ref mut path_points_colored_buffer,
-            ref mut path_points_textured_buffer,
-            ref mut text_buffer,
-        } = *state;
+            intermediary_mesh,
+            path_event_buffer,
+            path_points_colored_buffer,
+            path_points_textured_buffer,
+            text_buffer,
+        } = state;
         DrawingContext {
             mesh: intermediary_mesh,
             path_event_buffer: path_event_buffer,

nannou/src/draw/primitive/text.rs

@@ -310,10 +310,10 @@ impl draw::renderer::RenderPrimitive for Text {
         {
             let draw::renderer::RenderContext {
                 glyph_cache:
-                    &mut draw::renderer::GlyphCache {
-                        ref mut cache,
-                        ref mut pixel_buffer,
-                        ref mut requires_upload,
+                    draw::renderer::GlyphCache {
+                        cache,
+                        pixel_buffer,
+                        requires_upload,
                         ..
                     },
                 ..

nannou/src/draw/properties/spatial/orientation.rs

@@ -181,8 +181,8 @@ impl Default for Properties {
 
 // Expects the `Axes` variant from the given properties.
 fn expect_axes(p: &mut Properties) -> &mut Vec3 {
-    match *p {
-        Properties::Axes(ref mut axes) => axes,
+    match p {
+        Properties::Axes(axes) => axes,
         Properties::LookAt(_) => panic!("expected `Axes`, found `LookAt`"),
         Properties::Quat(_) => panic!("expected `Axes`, found `Quat`"),
     }

nannou/src/text/glyph.rs

@@ -59,7 +59,7 @@ struct ContourPathEvents {
 impl<'a, 'b> Iterator for Rects<'a, 'b> {
     type Item = (ScaledGlyph<'a>, Rect);
     fn next(&mut self) -> Option<Self::Item> {
-        let Rects { ref mut layout, y } = *self;
+        let Rects { layout, y } = self;
         layout.next().map(|g| {
             let left = g.position().x;
             let (right, height) = g

nannou_audio/src/requester.rs

@@ -48,16 +48,16 @@ where
         FR: stream::output::RenderFn<M, S>,
     {
         let Requester {
-            ref mut samples,
+            samples,
             num_frames,
-            ref mut pending_range,
-        } = *self;
+            pending_range,
+        } = self;
 
         // Ensure that the buffer length makes sense given the number of channels.
         assert_eq!(output.len() % channels, 0);
 
         // Determine the number of samples in the buffer.
-        let num_samples = num_frames * channels;
+        let num_samples = *num_frames * channels;
 
         // if `output` is empty, there's nothing to fill.
         if output.is_empty() {

nannou_audio/src/stream/input.rs

@@ -220,7 +220,7 @@ impl<M, FC, FE, S> Builder<M, FC, FE, S> {
         // Wrap the user's error function.
         let err_fn = move |err| {
             if let Ok(mut guard) = model_error.lock() {
-                if let Some(ref mut model) = *guard {
+                if let Some(model) = guard.as_mut() {
                     error(model, err);
                 }
             }

nannou_audio/src/stream/output.rs

@@ -219,7 +219,7 @@ impl<M, FR, FE, S> Builder<M, FR, FE, S> {
         // Wrap the user's error function.
         let err_fn = move |err| {
             if let Ok(mut guard) = model_error.lock() {
-                if let Some(ref mut model) = *guard {
+                if let Some(model) = guard.as_mut() {
                     error(model, err);
                 }
             }

nannou_core/src/geom/ellipse.rs

@@ -357,10 +357,7 @@ where
 {
     type Item = Tri<[S; 2]>;
     fn next(&mut self) -> Option<Self::Item> {
-        let Triangles {
-            ref mut points,
-            ref mut last,
-        } = *self;
+        let Triangles { points, last } = self;
         points.next().map(|next| {
             let triangle = Tri([points.middle, *last, next]);
             *last = next;

nannou_egui_demo_app/src/main.rs

@@ -37,10 +37,10 @@ fn raw_window_event(_app: &App, model: &mut Model, event: &nannou::winit::event:
 
 fn update(app: &App, model: &mut Model, update: Update) {
     let Model {
-        ref mut egui,
-        ref mut egui_demo_app,
+        egui,
+        egui_demo_app,
         ..
-    } = *model;
+    } = model;
     egui.set_elapsed_time(update.since_start);
     let proxy = app.create_proxy();
     egui.do_frame_with_epi_frame(proxy, |ctx, frame| {

nannou_isf/src/pipeline.rs

@@ -382,7 +382,7 @@ impl IsfInputData {
             (IsfInputData::Float(_), isf::InputType::Float(_)) => {}
             (IsfInputData::Point2d(_), isf::InputType::Point2d(_)) => {}
             (IsfInputData::Color(_), isf::InputType::Color(_)) => {}
-            (IsfInputData::Image(ref mut state), isf::InputType::Image) => {
+            (IsfInputData::Image(state), isf::InputType::Image) => {
                 if let Some(img_path) = image_paths(images_path).next() {
                     state.update(device, encoder, image_loader, img_path);
                 }

nannou_laser/src/ilda_idtf.rs

@@ -52,10 +52,10 @@ where
         self.points.clear();
         loop {
             let FrameReader {
-                ref mut reader,
-                ref mut points,
-                ref mut palette,
-            } = *self;
+                reader,
+                points,
+                palette,
+            } = self;
 
             // Read the next section.
             let section = match reader.read_next()? {

scripts/set_version/main.rs

@@ -103,12 +103,12 @@ fn update_dependencies_table(table: &mut toml_edit::Table, desired_version: &sem
             .entry(&dep)
             .as_value_mut()
             .expect("failed to retrieve toml value for dependency");
-        let version_value = match *value {
+        let version_value = match value {
             toml_edit::Value::String(_) => value,
-            toml_edit::Value::InlineTable(ref mut inline_table) => {
+            toml_edit::Value::InlineTable(inline_table) => {
                 inline_table.get_or_insert("version", "")
             }
-            ref v => panic!("unexpected dependency value: {:?}", v),
+            v => panic!("unexpected dependency value: {:?}", v),
         };
         *version_value = format!("{}", desired_version).into();
     }