Use trait for parsing type bound

Author: maneatingape

src/util/parse.rs

@@ -1,73 +1,54 @@
-use std::fmt::Debug;
-use std::str::FromStr;
+pub trait Integer: std::str::FromStr {}
+impl Integer for u8 {}
+impl Integer for u32 {}
+impl Integer for u64 {}
+impl Integer for usize {}
+impl Integer for i32 {}
 
-pub fn to<T>(s: &str) -> T
-where
-    T: FromStr,
-    <T as FromStr>::Err: Debug,
-{
-    s.parse().unwrap()
+pub fn to<T: Integer>(s: &str) -> T {
+    match s.parse() {
+        Ok(t) => t,
+        Err(_) => panic!("Unable to parse \"{s}\""),
+    }
 }
 
 pub fn to_iter<'a, T>(s: &'a str) -> impl Iterator<Item = T> + 'a
-where
-    T: FromStr + 'a,
-    <T as FromStr>::Err: Debug,
+where T: Integer + 'a
 {
     s.split(not_numeric).filter(not_empty).map(to::<T>)
 }
 
-pub fn to_vec<T>(s: &str) -> Vec<T>
-where
-    T: FromStr,
-    <T as FromStr>::Err: Debug,
-{
+pub fn to_vec<T: Integer>(s: &str) -> Vec<T> {
     to_iter(s).collect()
 }
 
-pub fn to_array1<T>(s: &str) -> [T; 1]
-where
-    T: FromStr,
-    <T as FromStr>::Err: Debug,
-{
+pub fn to_tuple_1<T: Integer>(s: &str) -> T {
     let mut iter = to_iter(s);
-    [iter.next().unwrap()]
+    iter.next().unwrap()
 }
 
-pub fn to_array2<T>(s: &str) -> [T; 2]
-where
-    T: FromStr,
-    <T as FromStr>::Err: Debug,
-{
+pub fn to_tuple_2<T: Integer>(s: &str) -> (T, T) {
     let mut iter = to_iter(s);
-    [iter.next().unwrap(), iter.next().unwrap()]
+    (iter.next().unwrap(), iter.next().unwrap())
 }
 
-pub fn to_array3<T>(s: &str) -> [T; 3]
-where
-    T: FromStr,
-    <T as FromStr>::Err: Debug,
-{
+pub fn to_tuple_3<T: Integer>(s: &str) -> (T, T, T) {
     let mut iter = to_iter(s);
-    [
+    (
         iter.next().unwrap(),
         iter.next().unwrap(),
         iter.next().unwrap(),
-    ]
+    )
 }
 
-pub fn to_array4<T>(s: &str) -> [T; 4]
-where
-    T: FromStr,
-    <T as FromStr>::Err: Debug,
-{
+pub fn to_tuple_4<T: Integer>(s: &str) -> (T, T, T, T) {
     let mut iter = to_iter(s);
-    [
+    (
         iter.next().unwrap(),
         iter.next().unwrap(),
         iter.next().unwrap(),
         iter.next().unwrap(),
-    ]
+    )
 }
 
 fn not_numeric(c: char) -> bool {

src/year2015/day02.rs

@@ -1,28 +1,49 @@
-use crate::util::parse::to_array3;
+use crate::util::parse::to_tuple_3;
 
-type Gift = [u32; 3];
+type Gift = (u32, u32, u32);
 
 pub fn parse(input: &str) -> Vec<Gift> {
     fn helper(line: &str) -> Gift {
-        let mut tokens: Gift = to_array3(line);
-        tokens.sort_unstable();
-        tokens
+        let mut gift: Gift = to_tuple_3(line);
+        sort(&mut gift);
+        gift
     }
     input.lines().map(helper).collect()
 }
 
 pub fn part1(input: &[Gift]) -> u32 {
     fn helper(gift: &Gift) -> u32 {
-        let [l, w, h] = gift;
+        let (l, w, h) = gift;
         2 * (l * w + w * h + h * l) + l * w
     }
     input.iter().map(helper).sum()
 }
 
 pub fn part2(input: &[Gift]) -> u32 {
     fn helper(gift: &Gift) -> u32 {
-        let [l, w, h] = gift;
+        let (l, w, h) = gift;
         2 * (l + w) + (l * w * h)
     }
     input.iter().map(helper).sum()
 }
+
+fn sort(gift: &mut Gift) {
+    let mut tmp;
+
+    if gift.0 > gift.1 {
+        tmp = gift.0;
+        gift.0 = gift.1;
+        gift.1 = tmp;
+    }
+    if gift.1 > gift.2 {
+        tmp = gift.1;
+        gift.1 = gift.2;
+        gift.2 = tmp;
+
+        if gift.0 > gift.1 {
+            tmp = gift.0;
+            gift.0 = gift.1;
+            gift.1 = tmp;
+        }
+    }
+}

src/year2022/day04.rs

@@ -1,22 +1,22 @@
-use crate::util::parse::to_array4;
+use crate::util::parse::to_tuple_4;
 
-type Pairs = [u32; 4];
+type Pairs = (u32, u32, u32, u32);
 
 pub fn parse(input: &str) -> Vec<Pairs> {
-    input.lines().map(to_array4::<u32>).collect()
+    input.lines().map(to_tuple_4::<u32>).collect()
 }
 
 pub fn part1(input: &[Pairs]) -> usize {
     fn helper(pairs: &&Pairs) -> bool {
-        let [a, b, c, d] = pairs;
+        let (a, b, c, d) = pairs;
         (a >= c && b <= d) || (c >= a && d <= b)
     }
     input.iter().filter(helper).count()
 }
 
 pub fn part2(input: &[Pairs]) -> usize {
     fn helper(pairs: &&Pairs) -> bool {
-        let [a, b, c, d] = pairs;
+        let (a, b, c, d) = pairs;
         a <= d && c <= b
     }
     input.iter().filter(helper).count()

src/year2022/day05.rs

@@ -1,9 +1,9 @@
 use crate::util::collection::*;
-use crate::util::parse::to_array3;
+use crate::util::parse::to_tuple_3;
 
 type Input = (Stack, Vec<Move>);
 type Stack = Vec<Vec<char>>;
-type Move = [usize; 3];
+type Move = (usize, usize, usize);
 
 pub fn parse(input: &str) -> Input {
     let lines: Vec<&str> = input.lines().collect();
@@ -20,8 +20,8 @@ pub fn parse(input: &str) -> Input {
     }
 
     fn helper(line: &&str) -> Move {
-        let [amount, from, to]: Move = to_array3(line);
-        [amount, from - 1, to - 1]
+        let (amount, from, to): Move = to_tuple_3(line);
+        (amount, from - 1, to - 1)
     }
     let moves: Vec<Move> = lines.iter().skip(height + 1).map(helper).collect();
 
@@ -40,7 +40,7 @@ fn play(input: &Input, reverse: bool) -> String {
     let (initial, moves) = input;
     let mut stack = initial.clone();
 
-    for [amount, from, to] in moves {
+    for (amount, from, to) in moves {
         let start = stack[*from].len() - amount;
         let crates: Vec<char> = stack[*from].drain(start..).collect();
         if reverse {

src/year2022/day11.rs

@@ -27,9 +27,9 @@ pub fn parse(input: &str) -> Vec<Monkey> {
             [y, "+"] => Operation::Add(to(y)),
             _ => unreachable!(),
         };
-        let [test] = to_array1::<u64>(chunk[3]);
-        let [yes] = to_array1::<usize>(chunk[4]);
-        let [no] = to_array1::<usize>(chunk[5]);
+        let test = to_tuple_1::<u64>(chunk[3]);
+        let yes = to_tuple_1::<usize>(chunk[4]);
+        let no = to_tuple_1::<usize>(chunk[5]);
         Monkey { items, operation, test, yes, no, }
     }
     input