/// The `BufReader` struct adds buffering to any reader.
///
/// It can be excessively inefficient to work directly with a [`Read`] instance.
-/// For example, every call to [`read`] on [`TcpStream`] results in a system call.
-/// A `BufReader` performs large, infrequent reads on the underlying [`Read`]
-/// and maintains an in-memory buffer of the results.
+/// For example, every call to [`read`][`TcpStream::read`] on [`TcpStream`]
+/// results in a system call. A `BufReader` performs large, infrequent reads on
+/// the underlying [`Read`] and maintains an in-memory buffer of the results.
///
/// [`Read`]: ../../std/io/trait.Read.html
-/// [`read`]: ../../std/net/struct.TcpStream.html#method.read
+/// [`TcpStream::read`]: ../../std/net/struct.TcpStream.html#method.read
/// [`TcpStream`]: ../../std/net/struct.TcpStream.html
///
/// # Examples
/// use std::fs::File;
///
/// # fn foo() -> std::io::Result<()> {
-/// let mut f = try!(File::open("log.txt"));
+/// let mut f = File::open("log.txt")?;
/// let mut reader = BufReader::new(f);
///
/// let mut line = String::new();
-/// let len = try!(reader.read_line(&mut line));
+/// let len = reader.read_line(&mut line)?;
/// println!("First line is {} bytes long", len);
/// # Ok(())
/// # }
/// use std::fs::File;
///
/// # fn foo() -> std::io::Result<()> {
- /// let mut f = try!(File::open("log.txt"));
+ /// let mut f = File::open("log.txt")?;
/// let mut reader = BufReader::new(f);
/// # Ok(())
/// # }
/// use std::fs::File;
///
/// # fn foo() -> std::io::Result<()> {
- /// let mut f = try!(File::open("log.txt"));
+ /// let mut f = File::open("log.txt")?;
/// let mut reader = BufReader::with_capacity(10, f);
/// # Ok(())
/// # }
/// use std::fs::File;
///
/// # fn foo() -> std::io::Result<()> {
- /// let mut f1 = try!(File::open("log.txt"));
+ /// let mut f1 = File::open("log.txt")?;
/// let mut reader = BufReader::new(f1);
///
/// let f2 = reader.get_ref();
/// use std::fs::File;
///
/// # fn foo() -> std::io::Result<()> {
- /// let mut f1 = try!(File::open("log.txt"));
+ /// let mut f1 = File::open("log.txt")?;
/// let mut reader = BufReader::new(f1);
///
/// let f2 = reader.get_mut();
/// use std::fs::File;
///
/// # fn foo() -> std::io::Result<()> {
- /// let mut f1 = try!(File::open("log.txt"));
+ /// let mut f1 = File::open("log.txt")?;
/// let mut reader = BufReader::new(f1);
///
/// let f2 = reader.into_inner();
/// Wraps a writer and buffers its output.
///
/// It can be excessively inefficient to work directly with something that
-/// implements [`Write`]. For example, every call to [`write`] on [`TcpStream`]
-/// results in a system call. A `BufWriter` keeps an in-memory buffer of data
-/// and writes it to an underlying writer in large, infrequent batches.
+/// implements [`Write`]. For example, every call to
+/// [`write`][`Tcpstream::write`] on [`TcpStream`] results in a system call. A
+/// `BufWriter` keeps an in-memory buffer of data and writes it to an underlying
+/// writer in large, infrequent batches.
///
/// The buffer will be written out when the writer is dropped.
///
/// the `stream` is dropped.
///
/// [`Write`]: ../../std/io/trait.Write.html
-/// [`write`]: ../../std/net/struct.TcpStream.html#method.write
+/// [`Tcpstream::write`]: ../../std/net/struct.TcpStream.html#method.write
/// [`TcpStream`]: ../../std/net/struct.TcpStream.html
#[stable(feature = "rust1", since = "1.0.0")]
pub struct BufWriter<W: Write> {
/// I took the one less traveled by,
/// And that has made all the difference.";
///
-/// let file = try!(File::create("poem.txt"));
+/// let file = File::create("poem.txt")?;
/// let mut file = LineWriter::new(file);
///
/// for &byte in road_not_taken.iter() {
/// }
///
/// // let's check we did the right thing.
-/// let mut file = try!(File::open("poem.txt"));
+/// let mut file = File::open("poem.txt")?;
/// let mut contents = String::new();
///
-/// try!(file.read_to_string(&mut contents));
+/// file.read_to_string(&mut contents)?;
///
/// assert_eq!(contents.as_bytes(), &road_not_taken[..]);
/// # Ok(())
/// use std::io::LineWriter;
///
/// # fn foo() -> std::io::Result<()> {
- /// let file = try!(File::create("poem.txt"));
+ /// let file = File::create("poem.txt")?;
/// let file = LineWriter::new(file);
/// # Ok(())
/// # }
/// use std::io::LineWriter;
///
/// # fn foo() -> std::io::Result<()> {
- /// let file = try!(File::create("poem.txt"));
+ /// let file = File::create("poem.txt")?;
/// let file = LineWriter::with_capacity(100, file);
/// # Ok(())
/// # }
/// use std::io::LineWriter;
///
/// # fn foo() -> std::io::Result<()> {
- /// let file = try!(File::create("poem.txt"));
+ /// let file = File::create("poem.txt")?;
/// let file = LineWriter::new(file);
///
/// let reference = file.get_ref();
/// use std::io::LineWriter;
///
/// # fn foo() -> std::io::Result<()> {
- /// let file = try!(File::create("poem.txt"));
+ /// let file = File::create("poem.txt")?;
/// let mut file = LineWriter::new(file);
///
/// // we can use reference just like file
/// use std::io::LineWriter;
///
/// # fn foo() -> std::io::Result<()> {
- /// let file = try!(File::create("poem.txt"));
+ /// let file = File::create("poem.txt")?;
///
/// let writer: LineWriter<File> = LineWriter::new(file);
///
- /// let file: File = try!(writer.into_inner());
+ /// let file: File = writer.into_inner()?;
/// # Ok(())
/// # }
/// ```