diff --git a/2022/rust/src/solutions/day01.rs b/2022/rust/src/solutions/day01.rs
index 31c205e..72aea29 100644
--- a/2022/rust/src/solutions/day01.rs
+++ b/2022/rust/src/solutions/day01.rs
@@ -3,7 +3,7 @@ use crate::utils;
 
 
 pub fn run() -> () {
-    let data = parse_data(utils::read_lines(utils::Source::Day(1)));
+    let data = parse_data(&utils::read_lines(utils::Source::Day(1)));
 
     println!("Day 1");
     println!("Part 1: {}", solve1(&data));
@@ -41,14 +41,15 @@ fn solve2(data: &Vec<Vec<i32>>) -> i32 {
     three.iter().sum()
 }
 
-fn parse_data(data: Vec<String>) -> Vec<Vec<i32>> {
+fn parse_data<T: AsRef<str>>(data: &[T]) -> Vec<Vec<i32>> {
     data.iter()
         .fold(vec![vec![]], | mut acc, next| {
-            if next.len() == 0 {
+            let s = next.as_ref();
+            if s.len() == 0 {
                 acc.push(Vec::new())
             }
             else {
-                let number: i32 = next.parse().expect("Parse error");
+                let number: i32 = s.parse().expect("Parse error");
                 acc.last_mut().and_then(|last| Some(last.push(number)));
             }
             acc
@@ -60,26 +61,23 @@ fn parse_data(data: Vec<String>) -> Vec<Vec<i32>> {
 mod tests {
     use super::*;
 
-    fn data() -> Vec<String> {
-        vec![
-            "1000", "2000", "3000", "",
-            "4000", "",
-            "5000", "6000", "",
-            "7000", "8000", "9000", "",
-            "10000",
-        ]
-            .into_iter().map(String::from).collect()
-    }
+    static DATA: &[&str; 14] = &[
+        "1000", "2000", "3000", "",
+        "4000", "",
+        "5000", "6000", "",
+        "7000", "8000", "9000", "",
+        "10000",
+    ];
 
     #[test]
     fn part1() {
-        let data = parse_data(data());
+        let data = parse_data(DATA);
         assert_eq!(24000, solve1(&data));
     }
 
     #[test]
     fn part2() {
-        let data = parse_data(data());
+        let data = parse_data(DATA);
         assert_eq!(45000, solve2(&data));
     }
 }
diff --git a/2022/rust/src/solutions/day02.rs b/2022/rust/src/solutions/day02.rs
index c83fa0c..bc8bc7b 100644
--- a/2022/rust/src/solutions/day02.rs
+++ b/2022/rust/src/solutions/day02.rs
@@ -3,7 +3,7 @@ use crate::utils;
 
 
 pub fn run() -> () {
-    let data = parse_data(utils::read_lines(utils::Source::Day(2)));
+    let data = parse_data(&utils::read_lines(utils::Source::Day(2)));
 
     println!("Day 2");
     println!("Part 1: {}", solve1(&data));
@@ -113,9 +113,10 @@ fn solve2(data: &[(char, char)]) -> i32 {
         })
 }
 
-fn parse_data(data: Vec<String>) -> Vec<(char, char)> {
+fn parse_data<T: AsRef<str>>(data: &[T]) -> Vec<(char, char)> {
     data.into_iter()
         .map(|line| {
+            let line = line.as_ref();
             let mut chars = line.chars();
             (chars.next().unwrap(), chars.last().unwrap())
         })
@@ -127,20 +128,17 @@ fn parse_data(data: Vec<String>) -> Vec<(char, char)> {
 mod tests {
     use super::*;
 
-    fn data() -> Vec<String> {
-        vec!["A Y", "B X", "C Z"]
-            .into_iter().map(String::from).collect()
-    }
+    static DATA: &[&str; 3] = &["A Y", "B X", "C Z"];
 
     #[test]
     fn part1() {
-        let data = parse_data(data());
+        let data = parse_data(DATA);
         assert_eq!(15, solve1(&data));
     }
 
     #[test]
     fn part2() {
-        let data = parse_data(data());
+        let data = parse_data(DATA);
         assert_eq!(12, solve2(&data));
     }
 }
diff --git a/2022/rust/src/solutions/day03.rs b/2022/rust/src/solutions/day03.rs
index 8109a99..d8a8472 100644
--- a/2022/rust/src/solutions/day03.rs
+++ b/2022/rust/src/solutions/day03.rs
@@ -4,7 +4,7 @@ use crate::utils;
 
 
 pub fn run() -> () {
-    let data = parse_data(utils::read_lines(utils::Source::Day(3)));
+    let data = parse_data(&utils::read_lines(utils::Source::Day(3)));
 
     println!("Day 3");
     println!("Part 1: {}", solve1(&data));
@@ -48,9 +48,10 @@ fn find_intersection(sets: &[HashSet<char>]) -> char {
         .unwrap()
 }
 
-fn parse_data(data: Vec<String>) -> Vec<(HashSet<char>, HashSet<char>)> {
+fn parse_data<T: AsRef<str>>(data: &[T]) -> Vec<(HashSet<char>, HashSet<char>)> {
     data.iter()
         .map(|str| {
+            let str = str.as_ref();
             let length = str.len();
             let left = &str[..length / 2];
             let right = &str[length / 2..];
@@ -64,27 +65,24 @@ fn parse_data(data: Vec<String>) -> Vec<(HashSet<char>, HashSet<char>)> {
 mod tests {
     use super::*;
 
-    fn data() -> Vec<String> {
-        vec![
-            "vJrwpWtwJgWrhcsFMMfFFhFp",
-            "jqHRNqRjqzjGDLGLrsFMfFZSrLrFZsSL",
-            "PmmdzqPrVvPwwTWBwg",
-            "wMqvLMZHhHMvwLHjbvcjnnSBnvTQFn",
-            "ttgJtRGJQctTZtZT",
-            "CrZsJsPPZsGzwwsLwLmpwMDw"
-        ]
-            .into_iter().map(String::from).collect()
-    }
+    static DATA: &[&str; 6] = &[
+        "vJrwpWtwJgWrhcsFMMfFFhFp",
+        "jqHRNqRjqzjGDLGLrsFMfFZSrLrFZsSL",
+        "PmmdzqPrVvPwwTWBwg",
+        "wMqvLMZHhHMvwLHjbvcjnnSBnvTQFn",
+        "ttgJtRGJQctTZtZT",
+        "CrZsJsPPZsGzwwsLwLmpwMDw"
+    ];
 
     #[test]
     fn part1() {
-        let data = parse_data(data());
+        let data = parse_data(DATA);
         assert_eq!(157, solve1(&data));
     }
 
     #[test]
     fn part2() {
-        let data = parse_data(data());
+        let data = parse_data(DATA);
         assert_eq!(70, solve2(&data));
     }
 }
diff --git a/2022/rust/src/solutions/day04.rs b/2022/rust/src/solutions/day04.rs
index a073ae9..afec2b1 100644
--- a/2022/rust/src/solutions/day04.rs
+++ b/2022/rust/src/solutions/day04.rs
@@ -4,7 +4,7 @@ use crate::utils;
 
 
 pub fn run() -> () {
-    let data = parse_data(utils::read_lines(utils::Source::Day(4)));
+    let data = parse_data(&utils::read_lines(utils::Source::Day(4)));
 
     println!("Day 4");
     println!("Part 1: {}", solve1(&data));
@@ -29,10 +29,11 @@ fn solve2(data: &[((i32, i32), (i32, i32))]) -> usize {
 }
 
 
-fn parse_data(data: Vec<String>) -> Vec<((i32, i32), (i32, i32))> {
+fn parse_data<T: AsRef<str>>(data: &[T]) -> Vec<((i32, i32), (i32, i32))> {
     let re = Regex::new(r#"^(\d+)-(\d+),(\d+)-(\d+)$"#).unwrap();
     data.iter()
         .map(|s| {
+            let s = s.as_ref();
             let c = re.captures(s).unwrap();
             (
                 (
@@ -53,20 +54,17 @@ fn parse_data(data: Vec<String>) -> Vec<((i32, i32), (i32, i32))> {
 mod tests {
     use super::*;
 
-    fn data() -> Vec<String> {
-        vec!["2-4,6-8", "2-3,4-5", "5-7,7-9", "2-8,3-7", "6-6,4-6", "2-6,4-8"]
-            .into_iter().map(String::from).collect()
-    }
+    static DATA: &[&str; 6] = &["2-4,6-8", "2-3,4-5", "5-7,7-9", "2-8,3-7", "6-6,4-6", "2-6,4-8"];
 
     #[test]
     fn part1() {
-        let data = parse_data(data());
+        let data = parse_data(DATA);
         assert_eq!(2, solve1(&data));
     }
 
     #[test]
     fn part2() {
-        let data = parse_data(data());
+        let data = parse_data(DATA);
         assert_eq!(4, solve2(&data));
     }
 }
diff --git a/2022/rust/src/solutions/day05.rs b/2022/rust/src/solutions/day05.rs
index 00316ce..b551b8a 100644
--- a/2022/rust/src/solutions/day05.rs
+++ b/2022/rust/src/solutions/day05.rs
@@ -4,7 +4,7 @@ use crate::utils;
 
 
 pub fn run() -> () {
-    let data = parse_data(utils::read_lines(utils::Source::Day(5)));
+    let data = parse_data(&utils::read_lines(utils::Source::Day(5)));
 
     println!("Day 5");
     println!("Part 1: {}", solve1(&data));
@@ -42,11 +42,12 @@ fn solve2((stacks, actions): &Data) -> String {
 }
 
 
-fn parse_data(data: Vec<String>) -> Data {
+fn parse_data<T: AsRef<str>>(data: &[T]) -> Data {
     let stacks = {
         let re = Regex::new(r#"( {3}|[\[\w\]]{3}) ?"#).unwrap();
         let mut boxes = data.iter()
             .map_while(|s| {
+                let s = s.as_ref();
                 let cap = re.find_iter(s)
                     .map(|x| x.as_str().trim())
                     .enumerate()
@@ -77,7 +78,7 @@ fn parse_data(data: Vec<String>) -> Data {
     let actions = {
         let re = Regex::new(r#"^move (\d+) from (\d+) to (\d+)$"#).unwrap();
         data.iter()
-            .filter_map(|str| re.captures(str))
+            .filter_map(|str| re.captures(str.as_ref()))
             .map(|cap| (
                 cap.get(1).unwrap().as_str().parse().unwrap(),
                 cap.get(2).unwrap().as_str().parse::<usize>().unwrap() - 1,
@@ -93,30 +94,27 @@ fn parse_data(data: Vec<String>) -> Data {
 mod tests {
     use super::*;
 
-    fn data() -> Vec<String> {
-        vec![
-            "    [D]    ",
-            "[N] [C]    ",
-            "[Z] [M] [P]",
-            " 1   2   3 ",
-            "",
-            "move 1 from 2 to 1",
-            "move 3 from 1 to 3",
-            "move 2 from 2 to 1",
-            "move 1 from 1 to 2",
-        ]
-            .into_iter().map(String::from).collect()
-    }
+    static DATA: &[&str; 9] = &[
+        "    [D]    ",
+        "[N] [C]    ",
+        "[Z] [M] [P]",
+        " 1   2   3 ",
+        "",
+        "move 1 from 2 to 1",
+        "move 3 from 1 to 3",
+        "move 2 from 2 to 1",
+        "move 1 from 1 to 2",
+    ];
 
     #[test]
     fn part1() {
-        let data = parse_data(data());
+        let data = parse_data(DATA);
         assert_eq!("CMZ", solve1(&data));
     }
 
     #[test]
     fn part2() {
-        let data = parse_data(data());
+        let data = parse_data(DATA);
         assert_eq!("MCD", solve2(&data));
     }
 }
diff --git a/2022/rust/src/solutions/day06.rs b/2022/rust/src/solutions/day06.rs
index d667b51..e20071b 100644
--- a/2022/rust/src/solutions/day06.rs
+++ b/2022/rust/src/solutions/day06.rs
@@ -4,7 +4,7 @@ use crate::utils;
 
 
 pub fn run() -> () {
-    let data = parse_data(utils::read_lines(utils::Source::Day(6)));
+    let data = parse_data(&utils::read_lines(utils::Source::Day(6)));
 
     println!("Day 6");
     println!("Part 1: {}", solve1(&data));
@@ -49,10 +49,10 @@ fn marker_bitwise(data: &[char], window_len: usize) -> usize {
 }
 
 
-fn parse_data(data: Vec<String>) -> Vec<char> {
-    data.into_iter()
+fn parse_data<T: AsRef<str>>(data: &[T]) -> Vec<char> {
+    data.iter()
         .next()
-        .map(|char| char.chars().collect())
+        .map(|char| char.as_ref().chars().collect())
         .unwrap()
 }
 
@@ -61,22 +61,20 @@ fn parse_data(data: Vec<String>) -> Vec<char> {
 mod tests {
     use super::*;
 
-    fn data() -> Vec<String> {
-        vec![
-           "mjqjpqmgbljsphdztnvjfqwrcgsmlb"
-        ]
-            .into_iter().map(String::from).collect()
-    }
+    static DATA: &[&str; 1] = &[
+        "mjqjpqmgbljsphdztnvjfqwrcgsmlb"
+    ];
+
 
     #[test]
     fn part1() {
-        let data = parse_data(data());
+        let data = parse_data(DATA);
         assert_eq!(7, solve1(&data));
     }
 
     #[test]
     fn part2() {
-        let data = parse_data(data());
+        let data = parse_data(DATA);
         assert_eq!(19, solve2(&data));
     }
 }
diff --git a/2022/rust/template.rs b/2022/rust/template.rs
index 57fc61f..4f4dc17 100644
--- a/2022/rust/template.rs
+++ b/2022/rust/template.rs
@@ -2,7 +2,7 @@ use crate::utils;
 
 
 pub fn run() -> () {
-    let data = parse_data(utils::read_lines(utils::Source::Day(-1)));
+    let data = parse_data(&utils::read_lines(utils::Source::Day(-1)));
 
     println!("Day X");
     println!("Part 1: {}", solve1(&data));
@@ -19,7 +19,7 @@ fn solve2(data: &()) -> i32 {
 }
 
 
-fn parse_data(data: Vec<String>) -> () {
+fn parse_data<T: AsRef<str>>(data: &[T]) -> () {
     ()
 }
 
@@ -28,22 +28,17 @@ fn parse_data(data: Vec<String>) -> () {
 mod tests {
     use super::*;
 
-    fn data() -> Vec<String> {
-        vec![
-            ""
-        ]
-            .into_iter().map(String::from).collect()
-    }
+    static DATA: &[&str; 1] = [""];
 
     #[test]
     fn part1() {
-        let data = parse_data(data());
+        let data = parse_data(DATA);
         assert_eq!(1, solve1(&data));
     }
 
     #[test]
     fn part2() {
-        let data = parse_data(data());
+        let data = parse_data(DATA);
         assert_eq!(2, solve2(&data));
     }
 }