You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: mod.rs
    path of file: ./repos/async-std/src/io/read
    
    the code of the file until where you have to start completion: mod bytes;
mod chain;
mod read;
mod read_exact;
mod read_to_end;
mod read_to_string;
mod read_vectored;
mod take;

use read::ReadFuture;
use read_exact::ReadExactFuture;
use read_to_end::{read_to_end_internal, ReadToEndFuture};
use read_to_string::ReadToStringFuture;
use read_vectored::ReadVectoredFuture;

use std::mem;

use crate::io::IoSliceMut;

pub use bytes::Bytes;
pub use chain::Chain;
pub use take::Take;

pub use futures_io::AsyncRead as Read;

#[doc = r#"
    Extension methods for [`Read`].

    [`Read`]: ../trait.Read.html
"#]
pub trait ReadExt: Read {
    #[doc = r#"
        Reads some bytes from the byte stream.

        Returns the number of bytes read from the start of the buffer.

        If the return value is `Ok(n)`, then it must be guaranteed that
        `0 <= n <= buf.len()`. A nonzero `n` value indicates that the buff
    
    fn by_ref(&mut self) -> &mut Self where Self: Sized { self }


    #[doc = r#"
        Transforms this `Read` instance to a `Stream` over its bytes.

        The returned type implements `Stream` where the `Item` is
        `Result<u8, io::Error>`.
        The yielded item is `Ok` if a byte was successfully read and `Err`
        otherwise. EOF is mapped to returning `None` from this iterator.

        # Examples

        [`File`][file]s implement `Read`:

        [file]: ../fs/struct.File.html

        ```no_run
        # fn main() -> std::io::Result<()> { async_std::task::block_on(async {
        #
        use async_std::prelude::*;
        use async_std::fs::File;

        let f = File::open("foo.txt").await?;
        let mut s = f.bytes();

        while let Some(byte) = s.next().await {
            println!("{}", byte.unwrap());
        }
        #
        # Ok(()) }) }
        ```
    "#]
    fn bytes(self) -> Bytes<Self> where Self: Sized {
        Bytes { inner: self }
    }

    #[doc = r#"
        Creates an adaptor which will chain this stream with another.

        The returned `Read` instance will first read all bytes from this object
        until EOF is encountered. Afterwards the output is equivalent to the
        output of `next`.

        # Examples

        [`File`][file]s implement `Read`:

        [file]: ../fs/struct.File.html

        ```no_run
        # fn main() -> std::io::Result<()> { async_std::task::block_on(async {
        #
        use async_std::prelude::*;
        use async_std::fs::File;

        let f1 = File::open("foo.txt").await?;
        let f2 = File::open("bar.txt").await?;

        let mut handle = f1.chain(f2);
        let mut buffer = String::new();

        // read the value into a String. We could use any Read method here,
        // this is just one example.
        handle.read_to_string(&mut buffer).await?;
        #
        # Ok(()) }) }
        ```
    "#]
    fn chain<R: Read>(self, next: R) -> Chain<Self, R> where Self: Sized {
        Chain { first: self, second: next, done_first: false }
    }
}