revert: rm L on Scrollable; use Deref<Target=[L]> instead AsRef<[T]> as the bound

Author: zjp-CN

src/bin/ui/scrollable/interaction.rs

@@ -1,9 +1,10 @@
 use super::Scrollable;
 use crate::ui::ScrollOffset;
+use std::ops::Deref;
 use term_rustdoc::tree::TreeLine;
 
 /// Scrolling
-impl<Lines: AsRef<[TreeLine]>> Scrollable<Lines, TreeLine> {
+impl<Lines: Deref<Target = [TreeLine]>> Scrollable<Lines> {
     pub fn scrolldown(&mut self, offset: ScrollOffset) {
         let height = self.area.height as usize;
         let len = self.len();
@@ -48,7 +49,7 @@ impl<Lines: AsRef<[TreeLine]>> Scrollable<Lines, TreeLine> {
 }
 
 /// Cursor movement
-impl<Lines: AsRef<[TreeLine]>> Scrollable<Lines, TreeLine> {
+impl<Lines: Deref<Target = [TreeLine]>> Scrollable<Lines> {
     pub fn move_forward_cursor(&mut self) {
         let height = self.area.height;
         let reach_sceen_bottom = (self.cursor + 1) == height;

src/bin/ui/scrollable/markdown/mod.rs

@@ -1,12 +1,12 @@
 use super::Scrollable;
 use ratatui::layout::Rect;
-use std::fmt;
+use std::{fmt, ops::Deref};
 use term_rustdoc::tree::Text as StyledText;
 
 mod parse;
 
 /// Scrollable text area for displaying markdown.
-pub type ScrollText = Scrollable<StyledLines, StyledLine>;
+pub type ScrollText = Scrollable<StyledLines>;
 
 pub struct StyledLine {
     line: Vec<StyledText>,
@@ -31,8 +31,10 @@ impl fmt::Debug for StyledLines {
     }
 }
 
-impl AsRef<[StyledLine]> for StyledLines {
-    fn as_ref(&self) -> &[StyledLine] {
+impl Deref for StyledLines {
+    type Target = [StyledLine];
+
+    fn deref(&self) -> &Self::Target {
         &self.lines
     }
 }

src/bin/ui/scrollable/mod.rs

@@ -1,7 +1,7 @@
 use super::Selected;
 use crate::{err, Result};
 use ratatui::prelude::Rect;
-use std::{fmt, marker::PhantomData};
+use std::{fmt, ops::Deref};
 use term_rustdoc::tree::{TreeLine, TreeLines};
 
 mod interaction;
@@ -11,10 +11,10 @@ mod render;
 pub use self::markdown::ScrollText;
 
 /// Scrollable tree view but stored in lines.
-pub type ScrollTreeLines = Scrollable<TreeLines, TreeLine>;
+pub type ScrollTreeLines = Scrollable<TreeLines>;
 
 /// A text panel that can be scrolled and select texts when the cursor is inside of it.
-pub struct Scrollable<Lines, L> {
+pub struct Scrollable<Lines> {
     /// Styled texts on each line
     pub lines: Lines,
     /// The start of row to be displayed
@@ -27,17 +27,16 @@ pub struct Scrollable<Lines, L> {
     pub select: Option<Selected>,
     /// The widget area, usually not the full screen
     pub area: Rect,
-    _ph: PhantomData<L>,
 }
 
-impl<Lines, L> Scrollable<Lines, L> {
+impl<Lines> Scrollable<Lines> {
     /// The index the current cursor on screen points to.
     pub fn idx_of_current_cursor(&self) -> usize {
         self.cursor as usize + self.start
     }
 }
 
-impl<L, Lines: AsRef<[L]>> Scrollable<Lines, L> {
+impl<L, Lines: Deref<Target = [L]>> Scrollable<Lines> {
     pub fn lines(&self) -> &[L] {
         self.lines.as_ref()
     }
@@ -47,22 +46,21 @@ impl<L, Lines: AsRef<[L]>> Scrollable<Lines, L> {
     }
 }
 
-impl<Lines: Default, L> Default for Scrollable<Lines, L> {
+impl<Lines: Default> Default for Scrollable<Lines> {
     fn default() -> Self {
-        let (lines, start, cursor, max_windth, select, area, _ph) = Default::default();
+        let (lines, start, cursor, max_windth, select, area) = Default::default();
         Scrollable {
             lines,
             start,
             cursor,
             max_windth,
             select,
             area,
-            _ph,
         }
     }
 }
 
-impl<Lines: Default + AsRef<[TreeLine]>> Scrollable<Lines, TreeLine> {
+impl<Lines: Deref<Target = [TreeLine]>> Scrollable<Lines> {
     pub fn new(lines: Lines, full: Rect) -> Result<Self> {
         let w = lines.as_ref().iter().map(TreeLine::width).max();
         let max_windth = w.ok_or_else(|| err!("The documentation is empty with no items."))?;
@@ -72,16 +70,20 @@ impl<Lines: Default + AsRef<[TreeLine]>> Scrollable<Lines, TreeLine> {
                 max_windth, "Outline width exceeds the area width, so lines may be truncated."
             );
         }
+
+        let (start, cursor, select) = Default::default();
         Ok(Self {
             lines,
             max_windth,
             area: full,
-            ..Default::default()
+            start,
+            cursor,
+            select,
         })
     }
 }
 
-impl<L, Lines: AsRef<[L]>> fmt::Debug for Scrollable<Lines, L> {
+impl<L, Lines: Deref<Target = [L]>> fmt::Debug for Scrollable<Lines> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let mut s = f.debug_struct("Scrollable");
         s.field("lines.len", &self.len())

src/bin/ui/scrollable/render.rs

@@ -1,8 +1,9 @@
 use super::Scrollable;
 use ratatui::prelude::{Buffer, Color, Rect, Widget};
+use std::ops::Deref;
 use term_rustdoc::tree::TreeLine;
 
-impl<Lines: AsRef<[TreeLine]>> Widget for &mut Scrollable<Lines, TreeLine> {
+impl<Lines: Deref<Target = [TreeLine]>> Widget for &mut Scrollable<Lines> {
     fn render(self, area: Rect, buf: &mut Buffer) {
         // render tree by each line
         write_lines(self.lines.as_ref(), self.start, area, buf);

src/tree/textline.rs

@@ -176,9 +176,11 @@ impl TreeLines {
     }
 }
 
-impl AsRef<[TreeLine]> for TreeLines {
-    fn as_ref(&self) -> &[TreeLine] {
-        self.lines()
+impl std::ops::Deref for TreeLines {
+    type Target = [TreeLine];
+
+    fn deref(&self) -> &Self::Target {
+        &self.tree
     }
 }