correcting compile errors

- replace switch fn with closures in some places.
- integrate the switch fn inside the main switch.
- make sure lifetime are defined for PanelSizer.
- remove some `mut`, `&`, and `*` where they superfluous.
- wrongly called `ctx()` when it was a variable 🤦.
- cannot use `impl Trait` in a variable declaration type.

crates/egui/src/containers/panel.rs

@@ -73,59 +73,36 @@ pub enum Side {
 
 impl Side {
     fn opposite(self) -> Self {
+        let opposite_vertical = |side: VerticalSide| -> Side {
+            match side {
+                VerticalSide::Left => Side::Vertical(VerticalSide::Right),
+                VerticalSide::Right => Side::Vertical(VerticalSide::Left),
+            }
+        };
+
+        let opposite_horizontal = |side: HorizontalSide| -> Side {
+            match side {
+                HorizontalSide::Top => Side::Horizontal(HorizontalSide::Bottom),
+                HorizontalSide::Bottom => Side::Horizontal(HorizontalSide::Top),
+            }
+        };
+
         match self {
             Side::Vertical(side) => opposite_vertical(side),
             Side::Horizontal(side) => opposite_horizontal(side),
         }
-
-        fn opposite_vertical(
-            side: VerticalSide,
-        ) -> Side {
-            match side {
-                VerticalSide::Left => {
-                    Side::Vertical(
-                        VerticalSide::Right,
-                    )
-                }
-                VerticalSide::Right => {
-                    Side::Vertical(
-                        VerticalSide::Left,
-                    )
-                }
-            }
-        }
-
-        fn opposite_horizontal(
-            side: HorizontalSide,
-        ) -> Side {
-            match side {
-                HorizontalSide::Top => {
-                    Side::Horizontal(
-                        HorizontalSide::Bottom,
-                    )
-                }
-                HorizontalSide::Bottom => {
-                    Side::Horizontal(
-                        HorizontalSide::Top,
-                    )
-                }
-            }
-        }
     }
 
     fn set_rect_size(self, rect: &mut Rect, size: f32) {
-        let set_rect_size_vertical = |side: VerticalSide| match side {
+        let mut set_rect_size_vertical = |side: VerticalSide| match side {
             VerticalSide::Left => rect.max.x = rect.min.x + size,
             VerticalSide::Right => rect.min.x = rect.max.x - size,
         };
 
-        let set_rect_size_horizontal =
+        let mut set_rect_size_horizontal = |side: HorizontalSide| match side {
-            |side: HorizontalSide| match side {
+            HorizontalSide::Top => rect.max.y = rect.min.y + size,
-                HorizontalSide::Top => rect.max.y = rect.min.y + size,
+            HorizontalSide::Bottom => rect.min.y = rect.max.y - size,
-                HorizontalSide::Bottom => {
+        };
-                    rect.min.y = rect.max.y - size
-                }
-            };
 
         match self {
             Side::Vertical(side) => set_rect_size_vertical(side),
@@ -134,47 +111,44 @@ impl Side {
     }
 
     fn side_axe(self, rect: Rect) -> f32 {
-        match self {
+        let side_axe_vertical = |side: VerticalSide, rect: Rect| -> f32 {
-            Side::Vertical(side) => side_axe_vertical(side, rect),
-            Side::Horizontal(side) => side_axe_horizontal(side, rect),
-        }
-
-        fn side_axe_vertical(side: VerticalSide, rect: Rect) -> f32 {
             match side {
                 VerticalSide::Left => rect.left(),
                 VerticalSide::Right => rect.right(),
             }
-        }
+        };
 
-        fn side_axe_horizontal(
+        let side_axe_horizontal = |side: HorizontalSide, rect: Rect| -> f32 {
-            side: HorizontalSide,
-            rect: Rect,
-        ) -> f32 {
             match side {
                 HorizontalSide::Top => rect.top(),
                 HorizontalSide::Bottom => rect.bottom(),
             }
+        };
+
+        match self {
+            Side::Vertical(side) => side_axe_vertical(side, rect),
+            Side::Horizontal(side) => side_axe_horizontal(side, rect),
         }
     }
 
     fn sign(self) -> f32 {
-        match self {
+        let sign_vertical = |side: VerticalSide| -> f32 {
-            Side::Vertical(side) => sign_vertical(side),
-            Side::Horizontal(side) => sign_horizontal(side),
-        }
-
-        fn sign_vertical(side: VerticalSide) -> f32 {
             match side {
                 VerticalSide::Left => -1.0,
                 VerticalSide::Right => 1.0,
             }
-        }
+        };
 
-        fn sign_horizontal(side: HorizontalSide) -> f32 {
+        let sign_horizontal = |side: HorizontalSide| -> f32 {
             match side {
                 HorizontalSide::Top => -1.0,
                 HorizontalSide::Bottom => 1.0,
             }
+        };
+
+        match self {
+            Side::Vertical(side) => sign_vertical(side),
+            Side::Horizontal(side) => sign_horizontal(side),
         }
     }
 }
@@ -190,14 +164,14 @@ struct PanelSizer<'a> {
     panel_rect: Rect,
 }
 
-impl PanelSizer {
+impl<'a> PanelSizer<'a> {
-    fn new(panel: &Panel, ui: &mut Ui) -> Self {
+    fn new(panel: &'a Panel, ui: &mut Ui) -> Self {
         let frame = panel
             .frame
             .unwrap_or_else(|| Frame::side_top_panel(ui.style()));
         let available_rect = ui.available_rect_before_wrap();
-        let mut size = PanelSizer::get_size_from_state_or_default(panel, ui, frame);
+        let size = PanelSizer::get_size_from_state_or_default(panel, ui, frame);
-        let mut panel_rect = PanelSizer::get_panel_rect(panel, available_rect, &mut size);
+        let panel_rect = PanelSizer::get_panel_rect(panel, available_rect, size);
 
         Self {
             panel,
@@ -226,7 +200,7 @@ impl PanelSizer {
         }
     }
 
-    fn get_panel_rect(panel: &Panel, available_rect: Rect, mut size: &mut f32) -> Rect {
+    fn get_panel_rect(panel: &Panel, available_rect: Rect, mut size: f32) -> Rect {
         let side = panel.side;
         let size_range = panel.size_range;
 
@@ -234,13 +208,13 @@ impl PanelSizer {
 
         match side {
             Side::Vertical(_) => {
-                size = &mut clamp_to_range(*size, size_range).at_most(available_rect.width());
+                size = clamp_to_range(size, size_range).at_most(available_rect.width());
             }
             Side::Horizontal(_) => {
-                size = &mut clamp_to_range(*size, size_range).at_most(available_rect.height());
+                size = clamp_to_range(size, size_range).at_most(available_rect.height());
             }
         }
-        side.set_rect_size(&mut panel_rect, *size);
+        side.set_rect_size(&mut panel_rect, size);
         panel_rect
     }
 
@@ -248,22 +222,20 @@ impl PanelSizer {
         let side = self.panel.side;
         let size_range = self.panel.size_range;
 
-        let prepare_resizing_response_vertical = |pointer: Pos2| {
-            self.size = (pointer.x - side.side_axe(self.panel_rect)).abs();
-            self.size = clamp_to_range(self.size, size_range).at_most(self.available_rect.width());
-        };
-
-        let prepare_resizing_response_horizontal = |pointer: Pos2| {
-            self.size = (pointer.y - side.side_axe(self.panel_rect)).abs();
-            self.size = clamp_to_range(self.size, size_range).at_most(self.available_rect.height());
-        };
-
         if is_resizing && pointer.is_some() {
             let pointer = pointer.unwrap();
 
             match side {
-                Side::Vertical(_) => prepare_resizing_response_vertical(pointer),
+                Side::Vertical(_) => {
-                Side::Horizontal(_) => prepare_resizing_response_horizontal(pointer),
+                    self.size = (pointer.x - side.side_axe(self.panel_rect)).abs();
+                    self.size =
+                        clamp_to_range(self.size, size_range).at_most(self.available_rect.width());
+                }
+                Side::Horizontal(_) => {
+                    self.size = (pointer.y - side.side_axe(self.panel_rect)).abs();
+                    self.size =
+                        clamp_to_range(self.size, size_range).at_most(self.available_rect.height());
+                }
             }
 
             side.set_rect_size(&mut self.panel_rect, self.size);
@@ -469,9 +441,9 @@ impl Panel {
         is_expanded: bool,
         add_contents: impl FnOnce(&mut Ui) -> R,
     ) -> Option<InnerResponse<R>> {
-        let how_expanded = animate_expansion(ctx(), self.id.with("animation"), is_expanded);
+        let how_expanded = animate_expansion(ctx, self.id.with("animation"), is_expanded);
 
-        let animated_panel = self.get_animated_panel(ctx(), is_expanded);
+        let animated_panel = self.get_animated_panel(ctx, is_expanded);
 
         if animated_panel.is_none() {
             None
@@ -522,7 +494,7 @@ impl Panel {
 
         // Get either the fake or the real panel to animate
         let animated_between_panel =
-            Self::get_animated_between_panel(ctx(), is_expanded, collapsed_panel, expanded_panel);
+            Self::get_animated_between_panel(ctx, is_expanded, collapsed_panel, expanded_panel);
 
         if 0.0 == how_expanded {
             Some(animated_between_panel.show(ctx, |ui| add_contents(ui, how_expanded)))
@@ -745,7 +717,7 @@ impl Panel {
         inner_response
     }
 
-    fn prepare_resizable_panel(&self, panel_sizer: &mut PanelSizer, ui: &mut Ui) {
+    fn prepare_resizable_panel(&self, panel_sizer: &mut PanelSizer<'_>, ui: &mut Ui) {
         let resize_id = self.id.with("__resize");
         let resize_response = ui.ctx().read_response(resize_id);
 
@@ -760,37 +732,36 @@ impl Panel {
         }
     }
 
-    fn resize_panel(&self, panel_sizer: &mut PanelSizer, ui: &mut Ui) -> (bool, bool) {
+    fn resize_panel(&self, panel_sizer: &mut PanelSizer<'_>, ui: &mut Ui) -> (bool, bool) {
-        let (resize_x, resize_y, amnt): (impl Into<Rangef>, impl Into<Rangef>, Vec2) =
+        let (resize_x, resize_y, amount): (Rangef, Rangef, Vec2) = match self.side {
-            match self.side {
+            Side::Vertical(_) => {
-                Side::Vertical(_) => {
+                let resize_x = self.side.opposite().side_axe(panel_sizer.panel_rect);
-                    let resize_x = self.side.opposite().side_axe(panel_sizer.panel_rect);
+                let resize_y = panel_sizer.panel_rect.y_range();
-                    let resize_y = panel_sizer.panel_rect.y_range();
+                (
-                    (
+                    Rangef::from(resize_x..=resize_x),
-                        resize_x..=resize_x,
+                    resize_y,
-                        resize_y,
+                    vec2(ui.style().interaction.resize_grab_radius_side, 0.0),
-                        vec2(ui.style().interaction.resize_grab_radius_side, 0.0),
+                )
-                    )
+            }
-                }
+            Side::Horizontal(_) => {
-                Side::Horizontal(_) => {
+                let resize_x = panel_sizer.panel_rect.x_range();
-                    let resize_x = panel_sizer.panel_rect.x_range();
+                let resize_y = self.side.opposite().side_axe(panel_sizer.panel_rect);
-                    let resize_y = self.side.opposite().side_axe(panel_sizer.panel_rect);
+                (
-                    (
+                    resize_x,
-                        resize_x,
+                    Rangef::from(resize_y..=resize_y),
-                        resize_y..=resize_y,
+                    vec2(0.0, ui.style().interaction.resize_grab_radius_side),
-                        vec2(0.0, ui.style().interaction.resize_grab_radius_side),
+                )
-                    )
+            }
-                }
+        };
-            };
 
         let resize_id = self.id.with("__resize");
-        let resize_rect = Rect::from_x_y_ranges(resize_x, resize_y).expand2(amnt);
+        let resize_rect = Rect::from_x_y_ranges(resize_x, resize_y).expand2(amount);
         let resize_response = ui.interact(resize_rect, resize_id, Sense::drag());
 
         (resize_response.hovered(), resize_response.dragged())
     }
 
-    fn get_cursor_icon(&self, panel_sizer: &PanelSizer) -> CursorIcon {
+    fn get_cursor_icon(&self, panel_sizer: &PanelSizer<'_>) -> CursorIcon {
         if panel_sizer.size <= self.size_range.min {
             match self.side {
                 Side::Vertical(v_side) => match v_side {
@@ -838,8 +809,8 @@ impl Panel {
                     id: self.id.with("animating_panel"),
                     ..self
                 }
-                    .resizable(false)
+                .resizable(false)
-                    .exact_size(fake_size),
+                .exact_size(fake_size),
             )
         } else {
             // Show the real panel:
@@ -868,8 +839,8 @@ impl Panel {
                 id: expanded_panel.id.with("animating_panel"),
                 ..expanded_panel
             }
-                .resizable(false)
+            .resizable(false)
-                .exact_size(fake_size)
+            .exact_size(fake_size)
         } else {
             expanded_panel
         }