Prefer &str over String

At this intermediate step in this refactor, we leak() everything(!)

diff --git a/src/lib.rs b/src/lib.rs
index 370eb5ddd553a80f2cb4ce75c24703bf285e7b91..199b8abd2732705484cc770b5ee948af71da332c 100644 (file)
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -76,36 +76,36 @@ impl std::fmt::Display for HTML {
 }
 
 #[derive(Debug, PartialEq, Eq, Hash)]
 }
 
 #[derive(Debug, PartialEq, Eq, Hash)]

-struct Entry {
-    col: String,
-    instance: Option<String>,
+struct Entry<'a> {
+    col: &'a str,
+    instance: Option<&'a str>,

 }
 }

-impl From<&str> for Entry {
-    fn from(value: &str) -> Entry {
+impl<'a> From<&'a str> for Entry<'a> {
+    fn from(value: &'a str) -> Entry<'a> {

         match value.split_once(':') {
             None => Entry {
         match value.split_once(':') {
             None => Entry {

-                col: String::from(value),
+                col: value,

                 instance: None,
             },
             Some((col, instance)) => Entry {
                 instance: None,
             },
             Some((col, instance)) => Entry {

-                col: String::from(col.trim()),
-                instance: Some(String::from(instance.trim())),
+                col: col.trim(),
+                instance: Some(instance.trim()),

             },
         }
     }
 }
 
 #[derive(Debug, PartialEq, Eq)]
             },
         }
     }
 }
 
 #[derive(Debug, PartialEq, Eq)]

-struct RowInput {
-    label: String,
-    entries: Vec<Entry>,
+struct RowInput<'a> {
+    label: &'a str,
+    entries: Vec<Entry<'a>>,

 }
 
 }
 

-struct Reader<Input: Iterator<Item = Result<String, std::io::Error>>> {
+struct Reader<'a, Input: Iterator<Item = Result<String, std::io::Error>>> {

     input: std::iter::Enumerate<Input>,
     input: std::iter::Enumerate<Input>,

-    row: Option<RowInput>,
+    row: Option<RowInput<'a>>,

 }
 }

-impl<Input: Iterator<Item = Result<String, std::io::Error>>> Reader<Input> {
+impl<'a, Input: Iterator<Item = Result<String, std::io::Error>>> Reader<'a, Input> {

     fn new(input: Input) -> Self {
         Self {
             input: input.enumerate(),
     fn new(input: Input) -> Self {
         Self {
             input: input.enumerate(),


@@ -113,14 +113,15 @@ impl<Input: Iterator<Item = Result<String, std::io::Error>>> Reader<Input> {
         }
     }
 }
         }
     }
 }

-impl<Input: Iterator<Item = Result<String, std::io::Error>>> Iterator for Reader<Input> {
-    type Item = Result<RowInput, std::io::Error>;
+impl<'a, Input: Iterator<Item = Result<String, std::io::Error>>> Iterator for Reader<'a, Input> {
+    type Item = Result<RowInput<'a>, std::io::Error>;

     fn next(&mut self) -> Option<Self::Item> {
         loop {
             match self
                 .input
                 .next()
     fn next(&mut self) -> Option<Self::Item> {
         loop {
             match self
                 .input
                 .next()

-                .map(|(n, r)| (n, r.map(|line| String::from(line.trim_end()))))
+                // TODO: Don't leak
+                .map(|(n, r)| (n, r.map(|line| String::from(line).leak().trim_end())))

             {
                 None => return Ok(std::mem::take(&mut self.row)).transpose(),
                 Some((_, Err(e))) => return Some(Err(e)),
             {
                 None => return Ok(std::mem::take(&mut self.row)).transpose(),
                 Some((_, Err(e))) => return Some(Err(e)),


@@ -152,7 +153,9 @@ impl<Input: Iterator<Item = Result<String, std::io::Error>>> Iterator for Reader
     }
 }
 
     }
 }
 

-fn read_rows(input: impl std::io::Read) -> impl Iterator<Item = Result<RowInput, std::io::Error>> {
+fn read_rows(
+    input: impl std::io::Read,
+) -> impl Iterator<Item = Result<RowInput<'static>, std::io::Error>> {

     Reader::new(std::io::BufReader::new(input).lines())
 }
 
     Reader::new(std::io::BufReader::new(input).lines())
 }
 


@@ -167,7 +170,7 @@ fn column_counts(rows: &[RowInput]) -> Vec<(usize, String)> {
                 .into_iter()
         })
         .fold(HashMap::new(), |mut cs, col| {
                 .into_iter()
         })
         .fold(HashMap::new(), |mut cs, col| {

-            cs.entry(String::from(col))
+            cs.entry(String::from(*col))

                 .and_modify(|n| *n += 1)
                 .or_insert(1);
             cs
                 .and_modify(|n| *n += 1)
                 .or_insert(1);
             cs


@@ -270,22 +273,22 @@ mod tests {
         assert_eq!(
             Entry::from("foo"),
             Entry {
         assert_eq!(
             Entry::from("foo"),
             Entry {

-                col: String::from("foo"),
+                col: "foo",

                 instance: None
             }
         );
         assert_eq!(
             Entry::from("foo:bar"),
             Entry {
                 instance: None
             }
         );
         assert_eq!(
             Entry::from("foo:bar"),
             Entry {

-                col: String::from("foo"),
-                instance: Some(String::from("bar"))
+                col: "foo",
+                instance: Some("bar")

             }
         );
         assert_eq!(
             Entry::from("foo: bar"),
             Entry {
             }
         );
         assert_eq!(
             Entry::from("foo: bar"),
             Entry {

-                col: String::from("foo"),
-                instance: Some(String::from("bar"))
+                col: "foo",
+                instance: Some("bar")

             }
         );
     }
             }
         );
     }


@@ -295,14 +298,14 @@ mod tests {
         assert_eq!(
             read_rows(&b"foo"[..]).flatten().collect::<Vec<_>>(),
             vec![RowInput {
         assert_eq!(
             read_rows(&b"foo"[..]).flatten().collect::<Vec<_>>(),
             vec![RowInput {

-                label: String::from("foo"),
+                label: "foo",

                 entries: vec![]
             }]
         );
         assert_eq!(
             read_rows(&b"bar"[..]).flatten().collect::<Vec<_>>(),
             vec![RowInput {
                 entries: vec![]
             }]
         );
         assert_eq!(
             read_rows(&b"bar"[..]).flatten().collect::<Vec<_>>(),
             vec![RowInput {

-                label: String::from("bar"),
+                label: "bar",

                 entries: vec![]
             }]
         );
                 entries: vec![]
             }]
         );


@@ -310,11 +313,11 @@ mod tests {
             read_rows(&b"foo\nbar\n"[..]).flatten().collect::<Vec<_>>(),
             vec![
                 RowInput {
             read_rows(&b"foo\nbar\n"[..]).flatten().collect::<Vec<_>>(),
             vec![
                 RowInput {

-                    label: String::from("foo"),
+                    label: "foo",

                     entries: vec![]
                 },
                 RowInput {
                     entries: vec![]
                 },
                 RowInput {

-                    label: String::from("bar"),
+                    label: "bar",

                     entries: vec![]
                 }
             ]
                     entries: vec![]
                 }
             ]


@@ -322,7 +325,7 @@ mod tests {
         assert_eq!(
             read_rows(&b"foo\n bar\n"[..]).flatten().collect::<Vec<_>>(),
             vec![RowInput {
         assert_eq!(
             read_rows(&b"foo\n bar\n"[..]).flatten().collect::<Vec<_>>(),
             vec![RowInput {

-                label: String::from("foo"),
+                label: "foo",

                 entries: vec![Entry::from("bar")]
             }]
         );
                 entries: vec![Entry::from("bar")]
             }]
         );


@@ -331,7 +334,7 @@ mod tests {
                 .flatten()
                 .collect::<Vec<_>>(),
             vec![RowInput {
                 .flatten()
                 .collect::<Vec<_>>(),
             vec![RowInput {

-                label: String::from("foo"),
+                label: "foo",

                 entries: vec![Entry::from("bar"), Entry::from("baz")]
             }]
         );
                 entries: vec![Entry::from("bar"), Entry::from("baz")]
             }]
         );


@@ -341,11 +344,11 @@ mod tests {
                 .collect::<Vec<_>>(),
             vec![
                 RowInput {
                 .collect::<Vec<_>>(),
             vec![
                 RowInput {

-                    label: String::from("foo"),
+                    label: "foo",

                     entries: vec![]
                 },
                 RowInput {
                     entries: vec![]
                 },
                 RowInput {

-                    label: String::from("bar"),
+                    label: "bar",

                     entries: vec![]
                 }
             ]
                     entries: vec![]
                 }
             ]


@@ -356,11 +359,11 @@ mod tests {
                 .collect::<Vec<_>>(),
             vec![
                 RowInput {
                 .collect::<Vec<_>>(),
             vec![
                 RowInput {

-                    label: String::from("foo"),
+                    label: "foo",

                     entries: vec![]
                 },
                 RowInput {
                     entries: vec![]
                 },
                 RowInput {

-                    label: String::from("bar"),
+                    label: "bar",

                     entries: vec![]
                 }
             ]
                     entries: vec![]
                 }
             ]


@@ -370,7 +373,7 @@ mod tests {
                 .flatten()
                 .collect::<Vec<_>>(),
             vec![RowInput {
                 .flatten()
                 .collect::<Vec<_>>(),
             vec![RowInput {

-                label: String::from("foo"),
+                label: "foo",

                 entries: vec![Entry::from("bar")]
             }]
         );
                 entries: vec![Entry::from("bar")]
             }]
         );


@@ -426,7 +429,7 @@ mod tests {
             render_cell(
                 "foo",
                 &RowInput {
             render_cell(
                 "foo",
                 &RowInput {

-                    label: String::from("nope"),
+                    label: "nope",

                     entries: vec![]
                 }
             ),
                     entries: vec![]
                 }
             ),


@@ -436,7 +439,7 @@ mod tests {
             render_cell(
                 "foo",
                 &RowInput {
             render_cell(
                 "foo",
                 &RowInput {

-                    label: String::from("nope"),
+                    label: "nope",

                     entries: vec![Entry::from("bar")]
                 }
             ),
                     entries: vec![Entry::from("bar")]
                 }
             ),


@@ -446,7 +449,7 @@ mod tests {
             render_cell(
                 "foo",
                 &RowInput {
             render_cell(
                 "foo",
                 &RowInput {

-                    label: String::from("nope"),
+                    label: "nope",

                     entries: vec![Entry::from("foo")]
                 }
             ),
                     entries: vec![Entry::from("foo")]
                 }
             ),


@@ -456,7 +459,7 @@ mod tests {
             render_cell(
                 "foo",
                 &RowInput {
             render_cell(
                 "foo",
                 &RowInput {

-                    label: String::from("nope"),
+                    label: "nope",

                     entries: vec![Entry::from("foo"), Entry::from("foo")]
                 }
             ),
                     entries: vec![Entry::from("foo"), Entry::from("foo")]
                 }
             ),


@@ -466,7 +469,7 @@ mod tests {
             render_cell(
                 "foo",
                 &RowInput {
             render_cell(
                 "foo",
                 &RowInput {

-                    label: String::from("nope"),
+                    label: "nope",

                     entries: vec![Entry::from("foo: 5"), Entry::from("foo: 10")]
                 }
             ),
                     entries: vec![Entry::from("foo: 5"), Entry::from("foo: 10")]
                 }
             ),


@@ -476,7 +479,7 @@ mod tests {
             render_cell(
                 "foo",
                 &RowInput {
             render_cell(
                 "foo",
                 &RowInput {

-                    label: String::from("nope"),
+                    label: "nope",

                     entries: vec![Entry::from("foo: 5"), Entry::from("foo")]
                 }
             ),
                     entries: vec![Entry::from("foo: 5"), Entry::from("foo")]
                 }
             ),


@@ -486,7 +489,7 @@ mod tests {
             render_cell(
                 "heart",
                 &RowInput {
             render_cell(
                 "heart",
                 &RowInput {

-                    label: String::from("nope"),
+                    label: "nope",

                     entries: vec![Entry::from("heart: <3")]
                 }
             ),
                     entries: vec![Entry::from("heart: <3")]
                 }
             ),


@@ -496,7 +499,7 @@ mod tests {
             render_cell(
                 "foo",
                 &RowInput {
             render_cell(
                 "foo",
                 &RowInput {

-                    label: String::from("bob's"),
+                    label: "bob's",

                     entries: vec![Entry::from("foo")]
                 }
             ),
                     entries: vec![Entry::from("foo")]
                 }
             ),