Cleanup type inference

Author: maneatingape

src/year2020/day09.rs

@@ -24,7 +24,7 @@ pub fn part2(input: &Result) -> u64 {
 }
 
 pub fn decrypt<const N: usize>(input: &str) -> Result {
-    let numbers: Vec<u64> = input.iter_unsigned().collect();
+    let numbers: Vec<_> = input.iter_unsigned().collect();
 
     let invalid = numbers
         .windows(N + 1)

src/year2020/day13.rs

@@ -18,7 +18,7 @@ pub struct Input {
 pub fn parse(input: &str) -> Input {
     let lines: Vec<_> = input.lines().collect();
     let timestamp = lines[0].unsigned();
-    let buses: Vec<(usize, usize)> = lines[1]
+    let buses: Vec<_> = lines[1]
         .split(',')
         .enumerate()
         .filter(|&(_, id)| id != "x")

src/year2020/day15.rs

@@ -33,7 +33,7 @@ fn play(input: &[usize], rounds: usize) -> usize {
     let mut last = input[size];
 
     let mut spoken_low = vec![0; rounds.min(THRESHOLD)];
-    let mut spoken_high: FastMap<u32, u32> = FastMapBuilder::with_capacity(rounds / 5);
+    let mut spoken_high = FastMapBuilder::with_capacity(rounds / 5);
 
     for i in 0..size {
         spoken_low[input[i]] = (i + 1) as u32;

src/year2020/day21.rs

@@ -114,7 +114,7 @@ pub fn part2(input: &Input) -> String {
         .filter(|(_, v)| v.candidates.count_ones() == 1)
         .map(|(k, v)| (*k, v.candidates))
         .collect();
-    let mut done: Vec<_> = vec![];
+    let mut done = Vec::new();
 
     // Eliminate known allergens from other ingredients.
     while let Some(pair @ (next, allergen)) = todo.pop() {

src/year2021/day10.rs

@@ -13,7 +13,7 @@ pub fn parse(input: &str) -> Vec<&[u8]> {
 }
 
 pub fn part1(input: &[&[u8]]) -> u64 {
-    let mut stack: Vec<u8> = Vec::new();
+    let mut stack = Vec::new();
     let mut score = 0;
 
     for line in input {
@@ -25,7 +25,7 @@ pub fn part1(input: &[&[u8]]) -> u64 {
 }
 
 pub fn part2(input: &[&[u8]]) -> u64 {
-    let mut stack: Vec<u8> = Vec::new();
+    let mut stack = Vec::new();
     let mut scores = Vec::new();
 
     for line in input {

src/year2022/day05.rs

@@ -30,7 +30,7 @@ type Input = (Stack, Vec<Move>);
 /// [`chunk`]: ChunkOps::chunk
 pub fn parse(input: &str) -> Input {
     let (prefix, suffix) = input.split_once("\n\n").unwrap();
-    let lines: Vec<&str> = prefix.lines().collect();
+    let lines: Vec<_> = prefix.lines().collect();
     let width = (lines[0].len() + 1) / 4;
 
     let mut stack: Stack = vec![Vec::new(); width];
@@ -42,7 +42,7 @@ pub fn parse(input: &str) -> Input {
         }
     }
 
-    let moves: Vec<Move> = suffix
+    let moves: Vec<_> = suffix
         .iter_unsigned()
         .chunk::<3>()
         .map(|[amount, from, to]| [amount, from - 1, to - 1])
@@ -70,7 +70,7 @@ pub fn part2(input: &Input) -> String {
 fn play(input: &Input, reverse: bool) -> String {
     let (initial, moves) = input;
     let mut stack = initial.clone();
-    let mut crates: Vec<char> = Vec::new();
+    let mut crates = Vec::new();
 
     for &[amount, from, to] in moves {
         let start = stack[from].len() - amount;

src/year2022/day07.rs

@@ -40,8 +40,8 @@ use crate::util::parse::*;
 pub fn parse(input: &str) -> Vec<u32> {
     let mut cd = false;
     let mut total = 0;
-    let mut stack: Vec<u32> = vec![];
-    let mut sizes: Vec<u32> = vec![];
+    let mut stack = Vec::new();
+    let mut sizes = Vec::new();
 
     for token in input.split_ascii_whitespace() {
         if cd {

src/year2022/day08.rs

@@ -57,7 +57,7 @@ pub fn parse(input: &str) -> Input {
 /// so they're added directly to the total.
 pub fn part1(input: &Input) -> usize {
     let (width, digits) = input;
-    let mut visible: Vec<bool> = vec![false; digits.len()];
+    let mut visible = vec![false; digits.len()];
 
     for i in 1..(*width - 1) {
         let mut left_max = -1;

src/year2022/day10.rs

@@ -5,7 +5,7 @@ use crate::util::parse::*;
 /// instruction timing. Produces a `vec` of the absolute values of `x` from cycle 0 to 241.
 pub fn parse(input: &str) -> Vec<i32> {
     let mut x = 1;
-    let mut xs: Vec<i32> = vec![1];
+    let mut xs = vec![1];
 
     for token in input.split_ascii_whitespace() {
         match token {

src/year2022/day11.rs

@@ -62,7 +62,7 @@ pub fn parse(input: &str) -> Vec<Monkey> {
     /// Inner helper function to keep the parsing logic readable.
     fn helper(chunk: &[&str]) -> Monkey {
         let items = chunk[1].iter_unsigned().collect();
-        let tokens: Vec<&str> = chunk[2].split(' ').rev().take(2).collect();
+        let tokens: Vec<_> = chunk[2].split(' ').rev().take(2).collect();
         let operation = match tokens[..] {
             ["old", _] => Operation::Square,
             [y, "*"] => Operation::Multiply(y.unsigned()),

src/year2022/day15.rs

@@ -36,7 +36,7 @@ pub fn part1_testable(input: &[Input], row: i32) -> i32 {
         (beacon.y == row).then_some(beacon.x)
     }
 
-    let mut ranges: Vec<Range<i32>> = input.iter().filter_map(|i| build_range(i, row)).collect();
+    let mut ranges: Vec<_> = input.iter().filter_map(|i| build_range(i, row)).collect();
     ranges.sort_unstable_by(|a, b| a.start.cmp(&b.start));
 
     let mut total = 0;
@@ -52,7 +52,7 @@ pub fn part1_testable(input: &[Input], row: i32) -> i32 {
         }
     }
 
-    let beacons: FastSet<i32> = input.iter().filter_map(|i| build_beacons(i, row)).collect();
+    let beacons: FastSet<_> = input.iter().filter_map(|i| build_beacons(i, row)).collect();
     total - (beacons.len() as i32)
 }
 
@@ -61,10 +61,10 @@ pub fn part2(input: &[Input]) -> u64 {
 }
 
 pub fn part2_testable(input: &[Input], size: i32) -> u64 {
-    let mut top: FastSet<i32> = FastSetBuilder::empty();
-    let mut left: FastSet<i32> = FastSetBuilder::empty();
-    let mut bottom: FastSet<i32> = FastSetBuilder::empty();
-    let mut right: FastSet<i32> = FastSetBuilder::empty();
+    let mut top = FastSetBuilder::empty();
+    let mut left = FastSetBuilder::empty();
+    let mut bottom = FastSetBuilder::empty();
+    let mut right = FastSetBuilder::empty();
 
     // Rotate points clockwise by 45 degrees, scale by √2 and extend edge by 1.
     // This transform each sensor into an axis aligned bounding box.
@@ -77,8 +77,8 @@ pub fn part2_testable(input: &[Input], size: i32) -> u64 {
         right.insert(sensor.x - sensor.y + manhattan + 1);
     }
 
-    let horizontal: Vec<&i32> = top.intersection(&bottom).collect();
-    let vertical: Vec<&i32> = left.intersection(&right).collect();
+    let horizontal: Vec<_> = top.intersection(&bottom).collect();
+    let vertical: Vec<_> = left.intersection(&right).collect();
     let range = 0..(size + 1);
 
     for x in &vertical {

src/year2022/day16.rs

@@ -26,7 +26,7 @@ pub struct Valve<'a> {
 
 impl Valve<'_> {
     fn parse(line: &str) -> Valve {
-        let mut tokens: Vec<&str> = line
+        let mut tokens: Vec<_> = line
             .split(|c: char| !c.is_ascii_uppercase() && !c.is_ascii_digit())
             .filter(|s| !s.is_empty())
             .collect();
@@ -47,13 +47,12 @@ impl Valve<'_> {
 }
 
 pub fn parse(input: &str) -> Input {
-    let mut valves: Vec<Valve> = input.lines().map(Valve::parse).collect();
+    let mut valves: Vec<_> = input.lines().map(Valve::parse).collect();
     valves.sort_unstable_by(Valve::cmp);
 
     let size = valves.iter().filter(|v| v.flow > 0).count() + 1;
     let mut distance = vec![u32::MAX; size * size];
-    let indices: FastMap<&str, usize> =
-        valves.iter().enumerate().map(|(i, v)| (v.name, i)).collect();
+    let indices: FastMap<_, _> = valves.iter().enumerate().map(|(i, v)| (v.name, i)).collect();
 
     // Eliminate zero valves
     for (from, valve) in valves.iter().enumerate().take(size) {
@@ -89,7 +88,7 @@ pub fn parse(input: &str) -> Input {
     }
 
     let todo = (1 << (size - 1)) - 1;
-    let flow: Vec<u32> = valves.iter().take(size).map(|v| v.flow).collect();
+    let flow: Vec<_> = valves.iter().take(size).map(|v| v.flow).collect();
     distance.iter_mut().for_each(|d| *d += 1);
 
     Input { size, todo, flow, distance }
@@ -172,7 +171,7 @@ pub fn part2(input: &Input) -> u32 {
     }
 
     let mut result = 0;
-    let mut visited: Vec<bool> = score.iter().map(|&s| s > 0).collect();
+    let mut visited: Vec<_> = score.iter().map(|&s| s > 0).collect();
     subsets(input.todo, &mut score, &mut visited);
 
     for (i, you) in score.iter().enumerate() {

src/year2022/day17.rs

@@ -80,8 +80,8 @@ pub fn part1(input: &[u8]) -> usize {
 
 pub fn part2(input: &[u8]) -> usize {
     let guess = 1000;
-    let height: Vec<usize> = State::new(input).take(5 * guess).collect();
-    let deltas: Vec<usize> = height
+    let height: Vec<_> = State::new(input).take(5 * guess).collect();
+    let deltas: Vec<_> = height
         .iter()
         .scan(0, |state, &height| {
             let delta = height - *state;

src/year2022/day20.rs

@@ -17,9 +17,9 @@ struct Tree {
 impl Tree {
     fn from(input: &[i64]) -> Tree {
         let len = input.len();
-        let mut nodes: Vec<Node> = Vec::with_capacity(len * 2);
-        let mut todo: VecDeque<u16> = VecDeque::with_capacity(len);
-        let mut next: VecDeque<u16> = VecDeque::with_capacity(len);
+        let mut nodes = Vec::with_capacity(len * 2);
+        let mut todo = VecDeque::with_capacity(len);
+        let mut next = VecDeque::with_capacity(len);
 
         for i in 0..len {
             nodes.push(Node { size: 1, left: u16::MAX, right: u16::MAX, up: u16::MAX });

src/year2022/day21.rs

@@ -43,11 +43,10 @@ pub struct Input {
 pub fn parse(input: &str) -> Input {
     let lines: Vec<_> = input.lines().collect();
 
-    let indices: FastMap<&str, usize> =
+    let indices: FastMap<_, _> =
         lines.iter().enumerate().map(|(index, line)| (&line[0..4], index)).collect();
 
-    let monkeys: Vec<Monkey> =
-        lines.iter().map(|line| Monkey::parse(&line[6..], &indices)).collect();
+    let monkeys: Vec<_> = lines.iter().map(|line| Monkey::parse(&line[6..], &indices)).collect();
 
     let root = indices["root"];
     let humn = indices["humn"];

src/year2022/day22.rs

@@ -185,7 +185,7 @@ pub fn part2(input: &Input) -> i32 {
 }
 
 fn parse_grid(input: &str) -> Grid {
-    let raw: Vec<&[u8]> = input.lines().map(str::as_bytes).collect();
+    let raw: Vec<_> = input.lines().map(str::as_bytes).collect();
     let width = raw.iter().map(|line| line.len()).max().unwrap();
     let height = raw.len();
     let mut tiles = vec![Tile::None; width * height];
@@ -207,7 +207,7 @@ fn parse_grid(input: &str) -> Grid {
 }
 
 fn parse_moves(input: &str) -> Vec<Move> {
-    let mut moves: Vec<Move> = Vec::new();
+    let mut moves = Vec::new();
 
     for token in input.replace('L', " L ").replace('R', " R ").trim().split(' ') {
         let next = match token {

src/year2022/day23.rs

@@ -104,7 +104,7 @@ pub struct Input {
 
 pub fn parse(input: &str) -> Input {
     let offset = 70;
-    let raw: Vec<&[u8]> = input.lines().map(str::as_bytes).collect();
+    let raw: Vec<_> = input.lines().map(str::as_bytes).collect();
     let default = [U256::default(); HEIGHT];
     let mut grid = default;
 

src/year2022/day24.rs

@@ -6,7 +6,7 @@ pub struct Input {
 }
 
 pub fn parse(input: &str) -> Input {
-    let raw: Vec<&[u8]> = input
+    let raw: Vec<_> = input
         .lines()
         .map(|line| {
             let bytes = line.as_bytes();
@@ -16,14 +16,14 @@ pub fn parse(input: &str) -> Input {
 
     let width = raw[0].len();
     let height = raw.len() - 2;
-    let build = |kind| {
+    let build = |kind| -> Vec<_> {
         let fold = |row: &&[u8]| row.iter().fold(0, |acc, &b| (acc << 1) | (b != kind) as u128);
         raw[1..=height].iter().map(fold).collect()
     };
-    let left: Vec<u128> = build(b'<');
-    let right: Vec<u128> = build(b'>');
-    let up: Vec<u128> = build(b'^');
-    let down: Vec<u128> = build(b'v');
+    let left = build(b'<');
+    let right = build(b'>');
+    let up = build(b'^');
+    let down = build(b'v');
 
     let mut horizontal = Vec::with_capacity(width * height);
     for time in 0..width {
@@ -59,7 +59,7 @@ pub fn part2(input: &Input) -> usize {
 fn expedition(input: &Input, start: usize, forward: bool) -> usize {
     let Input { width, height, horizontal, vertical } = input;
     let mut time = start;
-    let mut state: Vec<u128> = vec![0; height + 1];
+    let mut state = vec![0; height + 1];
 
     loop {
         time += 1;