gist

    // omg
    loop {
        state = match (state, try_io!(stream.read_byte())) {
            (MsStart, b'G') => {
                println!("Matching G");
                MsG
            },
            (MsStart, b'P') => MsP,
            (MsStart, b'H') => MsH,
            (MsStart, b'O') => MsO,
            (MsStart, b'T') => MsT,
            (MsStart, b'C') => MsC,
            (MsStart, b'D') => MsD,
            (MsStart, b@b'A'...b'Z') => {
                println!("Starting extension method: {} adding {}", s, b);
                s.push(b as char);
                MsExt
            },

            (MsG, b'E') => {
                println!("Matching GE");
                MsGE
            },
            (MsGE, b'T') => {
                println!("Matching GET");
                MsGET
            },

            (MsP, b'O') => MsPO,
            (MsPO, b'S') => MsPOS,
            (MsPOS, b'T') => MsPOST,

            (MsP, b'U') => MsPU,
            (MsPU, b'T') => MsPUT,

            (MsP, b'A') => MsPA,
            (MsPA, b'T') => MsPAT,
            (MsPAT, b'C') => MsPATC,
            (MsPATC, b'H') => MsPATCH,

            (MsH, b'E') => MsHE,
            (MsHE, b'A') => MsHEA,
            (MsHEA, b'D') => MsHEAD,

            (MsO, b'P') => MsOP,
            (MsOP, b'T') => MsOPT,
            (MsOPT, b'I') => MsOPTI,
            (MsOPTI, b'O') => MsOPTIO,
            (MsOPTIO, b'N') => MsOPTION,
            (MsOPTION, b'S') => MsOPTIONS,

            (MsT, b'R') => MsTR,
            (MsTR, b'A') => MsTRA,
            (MsTRA, b'C') => MsTRAC,
            (MsTRAC, b'E') => MsTRACE,

            (MsC, b'O') => MsCO,
            (MsCO, b'N') => MsCON,
            (MsCON, b'N') => MsCONN,
            (MsCONN, b'E') => MsCONNE,
            (MsCONNE, b'C') => MsCONNEC,
            (MsCONNEC, b'T') => MsCONNECT,

            (MsD, b'E') => MsDE,
            (MsDE, b'L') => MsDEL,
            (MsDEL, b'E') => MsDELE,
            (MsDELE, b'T') => MsDELET,
            (MsDELET, b'E') => MsDELETE,

            (MsExt, b@b'A'...b'Z') => {
                s.push(b as char);
                MsExt
            },

            (status, b@b'A'...b'Z') => {
                s = state.as_slice().to_string();
                println!("Matching extension method: {} adding: {}, from: {}", s, b as char, status.as_slice());
                s.push(b as char);
                MsExt
            },

            (MsGET, SP) => {
                println!("Resolving method GET");
                return Ok(method::Get)
            },
            (MsPOST, SP) => return Ok(method::Post),
            (MsPUT, SP) => return Ok(method::Put),
            (MsPATCH, SP) => return Ok(method::Patch),
            (MsHEAD, SP) => return Ok(method::Head),
            (MsDELETE, SP) => return Ok(method::Delete),
            (MsTRACE, SP) => return Ok(method::Trace),
            (MsOPTIONS, SP) => return Ok(method::Options),
            (MsCONNECT, SP) => return Ok(method::Connect),
            (MsExt, SP) => return Ok(method::Extension(s)),

            (_, _) => return Err(HttpMethodError)
        }