hellish parse code

hellish_parse_code.rs

// TODO: macro-ify this
fn parse_input() -> Result<Input, io::Error> {
    let q = regex!(r"^[qQ]\s+$");
    let o = regex!(r"^[oO]\s+$");
    let p = regex!(r"^[pP]\s+$");
    let d = regex!(r"^[dD]\s+$");
    let clear = regex!(r"^clear\s+$");
    let cluster = regex!(r"^cluster (\d+)\s+$");
    let partition = regex!(r"^partition (\d+), (\d+)");
    let split = regex!(r"^split (\d+), (\d+)");
    let morph = regex!(r"^morph (\d+(\.\d+)?)");
    let feeder = regex!(r"^feeder (\d+), (\d+)");
    let load = regex!(r"^load '([\w/]+)'\s+$");
    let save = regex!(r"^save '([\w/]+)'\s+$");
    let help = regex!(r"^\?");

    let mut buf = String::new();
    try!(io::stdin().read_line(&mut buf));

    if o.is_match(buf.as_str()) { return Ok(Input::O) } 
    if q.is_match(buf.as_str()) { return Ok(Input::Q) } 
    if p.is_match(buf.as_str()) { return Ok(Input::P) } 
    if d.is_match(buf.as_str()) { return Ok(Input::D) } 
    if clear.is_match(buf.as_str()) { return Ok(Input::Clear) }
    if cluster.is_match(buf.as_str()) {
        match cluster.captures(buf.as_str()) {
            Some(cap) => {
                return Ok(Input::Cluster(
                        cap.at(1).unwrap().parse::<usize>().unwrap()))
            }
            None => {
                return Ok(Input::None)
            }
        }
    }
    if load.is_match(buf.as_str()) {
        match load.captures(buf.as_str()) {
            Some(cap) => {
                return Ok(Input::Load(
                        cap.at(1).unwrap().to_string()))
            }
            None => {
                return Ok(Input::None)
            }
        }
    }
    if save.is_match(buf.as_str()) {
        match save.captures(buf.as_str()) {
            Some(cap) => {
                return Ok(Input::Save(
                        cap.at(1).unwrap().to_string()))
            }
            None => {
                return Ok(Input::None)
            }
        }
    }

    if split.is_match(buf.as_str()) {
        match split.captures(buf.as_str()) {
            Some(cap) => {
                return Ok(Input::Split(
                        cap.at(1).unwrap().parse::<usize>().unwrap(), 
                        cap.at(2).unwrap().parse::<usize>().unwrap()))
            },
            None => { 
                return Ok(Input::None) 
            }
        }
    }
    if partition.is_match(buf.as_str()) {
        match partition.captures(buf.as_str()) {
            Some(cap) => {
                return Ok(Input::Partition(
                        // Default threshold
                        cap.at(1).unwrap().parse::<usize>().unwrap(),
                        // Default trie depth
                        cap.at(2).unwrap().parse::<usize>().unwrap()))
            },
            None => { 
                return Ok(Input::None) 
            }
        }
    }
    if feeder.is_match(buf.as_str()) {
        match feeder.captures(buf.as_str()) {
            Some(cap) => {
                return Ok(Input::Feeder(
                        cap.at(1).unwrap().parse::<usize>().unwrap(), 
                        cap.at(2).unwrap().parse::<usize>().unwrap()))
            },
            None => { 
                return Ok(Input::None) 
            }
        }
    }
    if morph.is_match(buf.as_str()) {
        match morph.captures(buf.as_str()) {
            Some(cap) => {
                return Ok(Input::Morph(
                        cap.at(1).unwrap().parse::<f64>().unwrap()))
            },
            None => {
                return Ok(Input::None)
            }
        }
    }
    if help.is_match(buf.as_str()) { return Ok(Input::Help) } 

    Ok(Input::None)
}