ADvent of code, day 22

#!/usr/bin/env run-cargo-script
//cargo-deps: num-complex
extern crate num_complex;
use num_complex::Complex;

use std::collections::HashMap;

use std::io::{stdin,BufRead};

type Coord = Complex<i32>;

#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
enum State {
    Clean,
    Weakened,
    Infected,
    Flagged,
}

impl State {
    pub fn next(self, dir: Coord) -> (State, Coord) {
        use State::*;
        const LEFT: Coord = Coord { re: 0, im: 1};
        const RIGHT: Coord = Coord { re: 0, im: -1};

        // For part a, adjust cases to remove Weakened and Flagged
        match self {
            Clean => (Weakened, dir * LEFT),
            Weakened => (Infected, dir),
            Infected => (Flagged, dir * RIGHT),
            Flagged => (Clean, -dir),
        }
    }
}

type Grid = HashMap<Coord, State>;

fn solve(mut grid: Grid, iterations: usize) -> usize {

    let mut solution = 0;

    let mut loc = Coord::new(0, 0);
    let mut dir = Coord::i();

    for _ in 0..iterations {
        let loc_state = grid.get(&loc).cloned().unwrap_or(State::Clean);
        let (new_state, new_dir) = loc_state.next(dir);
        if new_state == State::Infected {
            solution += 1;
        }
        if new_state != State::Clean {
            grid.insert(loc.clone(), new_state);
        }
        else {
            grid.remove(&loc);
        }

        dir = new_dir;
        loc += dir;
    }

    solution
}

fn parse() -> Grid {
    const GRID_SIZE: i32 = 25;
    const GRID_OFFSET: i32 = 12;
    let mut ret = Grid::new();

    let stdin = stdin();
    let handle = stdin.lock();
    for (line_idx, line) in handle.lines().enumerate() {
        let col = ((GRID_SIZE - 1) - line_idx as i32) - GRID_OFFSET;
        let line = line.expect("I/O error");

        for (entry_idx, entry) in line.chars().enumerate() {
            let row = (entry_idx as i32) - GRID_OFFSET;
            if entry == '#' {
                ret.insert(Complex::new(row, col), State::Infected);
            }
        }
    }
    ret
}

fn main() {
    const N_ITERATIONS: usize = 10_000_000;
    let grid = parse();
    let answer = solve(grid, N_ITERATIONS);
    println!("{}", answer);
}