trait Parser<E> {
    fn begin_field(&mut self);
    fn end_field(&mut self);
}

trait ParseFrom<I,E> : Sized {
    fn parse_from(parser: &mut Parser<E>, from: I) -> Result<Self,E>;
}

trait ParserExt<E> : Parser<E> {
    fn parse_field_FAILS<I,O:ParseFrom<I,E>>(&mut self, field: String, from: I) -> Result<O,E> {
        self.begin_field();
        let retv = O::parse_from(self, from);
        self.end_field();
        retv
    }
}

fn parse_field_WORKS<E,I,O:ParseFrom<I,E>>(parser: &mut Parser<E>, field: String, from: I) -> Result<O,E> {
    parser.begin_field();
    let retv = O::parse_from(parser, from);
    parser.end_field();
    retv
}

struct DummyParser { }

impl Parser<String> for DummyParser {
    fn begin_field(&mut self) { }
    fn end_field(&mut self) { }
}

impl ParseFrom<String,String> for i64 {
    fn parse_from(parser: &mut Parser<String>, from: String) -> Result<i64,String> {
        from.parse::<i64>().map_err(|err|err.to_string())
    }
}

fn main() {
    let mut p = DummyParser { };
    let i : i64 = parse_field_WORKS(&mut p, "field".to_string(), "123".to_string()).unwrap();
    println!("i={}",i)
}