Advent of code 2019 day 2

day2.rs

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

fn main() {
    let mut loaded_program: Vec<i32> = load_program();
    run_program(&mut loaded_program);
    println!("{}", loaded_program[0]);
}

fn run_program(program: &mut Vec<i32>) -> i32 {
    let mut prog_ptr:usize = 0;
    loop {
        let a = next_action(&mut prog_ptr, &program);
        match a {
            Action{op_type: OpType::Valid, result: Some(r), store_at: Some(store_at)} => {
                program[store_at] = r
            },
            Action{op_type: OpType::Break, result: _, store_at: _} => break,
            _ => panic!("Unexpected action."),
        }
    }
    program[0]
} 

const ADD: i32 =  1;
const MULT: i32 =  2;
const BREAK: i32 =  99;

fn next_action(prog_ptr: &mut usize, program: &Vec<i32>) -> Action {
    let next_op_code = next_cell(prog_ptr, program);
    match next_op_code {
        ADD => {
            let t1 = program[next_cell(prog_ptr, program) as usize];
            let t2 = program[next_cell(prog_ptr, program) as usize];
            let store_at = next_cell(prog_ptr, program) as usize;
            return Action{
                op_type: OpType::Valid,
                result: Some(t1 + t2),
                store_at: Some(store_at)
            }
        },
        MULT => {
            let f1 = program[next_cell(prog_ptr, program) as usize];
            let f2 = program[next_cell(prog_ptr, program) as usize];
            let store_at = next_cell(prog_ptr, program) as usize;
            return Action{
                op_type: OpType::Valid,
                result: Some(f1 * f2),
                store_at: Some(store_at)
            }
        },
        BREAK => {
            return Action{
                op_type: OpType::Break,
                result: None,
                store_at: None
            }
        },
        _ => {
            return Action{
                op_type: OpType::Invalid,
                result: None,
                store_at: None
            }
        }
    }
}

struct Action {
    op_type: OpType,
    result: Option<i32>,
    store_at: Option<usize>,
}

enum OpType{
    Valid,
    Invalid,
    Break
}

fn load_program() -> Vec<i32> {
    let mut prog: Vec<i32> = vec![];
    let stdin = io::stdin();
    let line = stdin.lock().lines().next().expect("Could not read from stdin");
    let line = line.expect("No string there.");
    for s in line.split(",") {
        let c = i32::from_str_radix(&s, 10).expect("Could not parse int");
        prog.push(c);
    }
    prog
}

fn next_cell(prog_ptr: &mut usize, program: &Vec<i32>) -> i32 {
    let ind = *prog_ptr;
    *prog_ptr += 1;
    program[ind]
}