Add io write by_ref

src/io/read/mod.rs

@@ -323,15 +323,15 @@ extension_trait! {
             ```no_run
             # fn main() -> std::io::Result<()> { async_std::task::block_on(async {
             #
-            use async_std::prelude::*;
+            use async_std::io::prelude::*;
             use async_std::fs::File;
 
             let mut f = File::open("foo.txt").await?;
             let mut buffer = Vec::new();
             let mut other_buffer = Vec::new();
 
             {
-                let reference = f.by_ref();
+                let reference = ReadExt::by_ref(&mut f);
 
                 // read at most 5 bytes
                 reference.take(5).read_to_end(&mut buffer).await?;
@@ -486,7 +486,7 @@ mod tests {
             let mut other_buffer = Vec::new();
 
             {
-                let reference = f.by_ref();
+                let reference = io::read::ReadExt::by_ref(&mut f);
 
                 // read at most 5 bytes
                 assert_eq!(reference.take(5).read_to_end(&mut buffer).await?, 5);

src/io/write/mod.rs

@@ -201,6 +201,43 @@ extension_trait! {
             WriteAllFuture { writer: self, buf }
         }
 
+
+        #[doc = r#"
+            Creates a "by reference" adaptor for this instance of `Write`.
+
+            The returned adaptor also implements `Write` and will simply borrow this
+            current writer.
+
+            # Examples
+
+            [`File`][file]s implement `Write`:
+
+            [file]: ../fs/struct.File.html
+
+            ```no_run
+            # fn main() -> std::io::Result<()> { async_std::task::block_on(async {
+            #
+            use async_std::io::prelude::*;
+            use async_std::fs::File;
+
+            let mut f = File::open("foo.txt").await?;
+
+            {
+                let reference = WriteExt::by_ref(&mut f);
+
+                // read at most 5 bytes
+                reference.write_all(b"hello ").await?;
+
+            } // drop our &mut reference so we can use f again
+
+            // original file still usable, read the rest
+            f.write_all(b"world").await?;
+            #
+            # Ok(()) }) }
+            ```
+        "#]
+        fn by_ref(&mut self) -> &mut Self where Self: Sized { self }
+
         #[doc = r#"
             Writes a formatted string into this writer, returning any error encountered.
 
@@ -322,3 +359,29 @@ extension_trait! {
         }
     }
 }
+
+
+#[cfg(test)]
+mod tests {
+    use crate::io;
+    use crate::prelude::*;
+
+    #[test]
+    fn test_write_by_ref() -> io::Result<()> {
+        crate::task::block_on(async {
+            let mut f = io::Cursor::new(vec![]);
+
+            {
+                let reference = io::write::WriteExt::by_ref(&mut f);
+
+                reference.write_all(b"hello").await?;
+            } // drop our &mut reference so we can use f again
+
+            assert_eq!(f.position(), 5);
+            // original file still usable, read the rest
+            f.write_all(b" world").await?;
+            assert_eq!(f.position(), 11);
+            Ok(())
+        })
+    }
+}