get rid of unnecessary buffering during decode

[oli-obk]

babysteps for #57
sadly there's no impl<T:Iterator, E> Iterator for Result<T, E>, so I stole some code from FromIterator::from_iterator::<Result<...>>

[rust-highfive]

r? @alexcrichton

(rust_highfive has picked a reviewer for you, use r? to override)

[alexcrichton]

Hm could you take a look at some benchmarks for this as well? I think that calling .chars() on an I/O object is not performant compared to calling it on a str

[oli-obk]

benchmark:

    #[bench]
    fn bench_large_file(b: &mut Bencher) {
        use std::fs::File;
        use std::io::BufReader;
        let f = File::open("src/big_file.json").unwrap();
        let mut buf = BufReader::new(f);
        b.iter( || { let _ = Json::from_reader(&mut buf); });
    }

big_file.json consists of ~1000 lines of
{ "a": true, "b": null, "c":3.1415, "d": "Hello world", "e": [1,2,3]},

this pr:

test json::tests::bench_large_file      ... bench:      4515 ns/iter (+/- 273)

old:

test json::tests::bench_large_file      ... bench:     15356 ns/iter (+/- 711)

[oli-obk]

second benchmark:

    #[bench]
    fn bench_large_file_reopening(b: &mut Bencher) {
        use std::fs::File;
        use std::io::BufReader;
        b.iter( || {
            let f = File::open("src/big_file.json").unwrap();
            let mut buf = BufReader::new(f);
            let _ = Json::from_reader(&mut buf);
        });
    }

this pr:

test json::tests::bench_large_file_reopening ... bench:   3506554 ns/iter (+/- 54927)

old:

test json::tests::bench_large_file_reopening ... bench:   2793185 ns/iter (+/- 160453)

[oli-obk]

I don't even know what the first benchmark does... I'd have said after the first iteration all further iterations should be a nop...

[oli-obk]

There is a huge difference in the implementations of std::io::Chars and std::str::Chars.
So... to get the performance to the same level we need to use BufRead instead of Read and fill_buf instead of read. Should be simple enough to have std::io::Chars use a BufRead internally to the Read it was created with. Since ReadExt::chars consumes self, everything should be fine as long as noone calls it on a &mut (which apparently is fine: rust-lang/rust#22802)

[alexcrichton]

The first benchmark may be skewed because it decodes once and then never decodes again (e.g. you don't seek back to the beginning). The second benchmark is what I would expect in that using std::io::Chars is much slower.

Even if we use BufRead I think that using std::io::Chars will be slower, but it would be worth benchmarking.

Also, could this avoid checking in a large file? It looks like it should be easy to generate in-memory.