test: add std and tokio tests

Also fixed examples.

Author: soywod

README.md

@@ -25,32 +25,37 @@ The loop is the glue between coroutines and runtimes. It makes the coroutine pro
 ### Read a directory synchronously
 
 ```rust,ignore
-use io_fs::{coroutines::ReadDir, runtimes::std::handle};
+use std::{path::PathBuf};
 
-let mut output = None;
+use io_fs::{coroutines::read_dir::ReadDir, error::FsResult, runtimes::std::handle};
+
+let mut arg = None;
 let mut coroutine = ReadDir::new("/tmp");
 
-let entries = loop {
-    match coroutine.resume(output) {
-        Ok(entries) => break entries,
-        Err(io) => output = Some(handle(io).unwrap()),
+let paths = loop {
+    match coroutine.resume(arg) {
+        FsResult::Ok(paths) => break paths,
+        FsResult::Err(err) => panic!("{err}"),
+        FsResult::Io(io) => arg = Some(handle(io).unwrap()),
     }
 };
 
-println!("Entries inside /tmp:");
+println!("Entries inside {}:", path.display());
 
 for path in paths {
     println!(" - {}", path.display());
 }
 ```
 
-*See complete example at [./examples/std-read-dir.rs](https://github.com/pimalaya/io-fs/blob/master/examples/std-read-dir.rs).*
+*See complete examples at [./examples](https://github.com/pimalaya/io-fs/blob/master/examples).*
 
-### More examples
+### Real-world examples
 
 Have a look at projects built on the top of this library:
 
-- [io-vdir](https://github.com/pimalaya/io-vdir): Set of I/O-free Rust coroutines and runtimes to manage [Vdir](https://vdirsyncer.pimutils.org/en/stable/vdir.html) filesystems.
+- [io-vdir](https://github.com/pimalaya/io-vdir): Set of I/O-free Rust coroutines to manage [Vdir](https://vdirsyncer.pimutils.org/en/stable/vdir.html) filesystems.
+- [io-addressbook](https://github.com/pimalaya/io-addressbook): Set of I/O-free Rust coroutines and clients to manage contacts.
+- [Cardamum](https://github.com/pimalaya/cardamum): CLI to manage contacts.
 
 ## Sponsoring
 

examples/std-read-dir.rs

@@ -1,25 +1,33 @@
 #![cfg(feature = "std")]
 
-use std::io::{stdin, stdout, Write as _};
+use std::{
+    env,
+    io::{stdin, stdout, Write as _},
+    path::PathBuf,
+};
 
-use io_fs::{coroutines::ReadDir, runtimes::std::handle};
+use io_fs::{coroutines::read_dir::ReadDir, error::FsResult, runtimes::std::handle};
 
 fn main() {
-    env_logger::init();
+    let _ = env_logger::try_init();
 
-    let path = read_line("Which directory to read?");
+    let path: PathBuf = match env::var("DIR") {
+        Ok(dir) => dir.into(),
+        Err(_) => read_line("Directory to read?").into(),
+    };
 
-    let mut output = None;
+    let mut arg = None;
     let mut coroutine = ReadDir::new(&path);
 
     let paths = loop {
-        match coroutine.resume(output) {
-            Ok(paths) => break paths,
-            Err(io) => output = Some(handle(io).unwrap()),
+        match coroutine.resume(arg) {
+            FsResult::Ok(paths) => break paths,
+            FsResult::Err(err) => panic!("{err}"),
+            FsResult::Io(io) => arg = Some(handle(io).unwrap()),
         }
     };
 
-    println!("Entries inside {path}:");
+    println!("Entries inside {}:", path.display());
 
     for path in paths {
         println!(" - {}", path.display());

examples/tokio-create-many-files.rs

@@ -1,32 +1,37 @@
 #![cfg(feature = "tokio")]
 
 use std::{
+    env,
     io::{stdin, stdout, Write as _},
     time::Instant,
 };
 
-use io_fs::{coroutines::CreateFiles, runtimes::tokio::handle};
+use io_fs::{coroutines::create_files::CreateFiles, error::FsResult, runtimes::tokio::handle};
 use tempdir::TempDir;
 
 #[tokio::main]
 async fn main() {
-    env_logger::init();
+    let _ = env_logger::try_init();
 
-    let tmp = TempDir::new("tokio-create-files").unwrap();
+    let tmp = TempDir::new("tokio-create-many-files").unwrap();
 
-    let n = read_line("How many temp files to create?")
-        .parse::<usize>()
-        .unwrap();
+    let n: usize = match env::var("N") {
+        Ok(n) => n.parse().unwrap(),
+        Err(_) => read_line("How many temp files to create?").parse().unwrap(),
+    };
 
     let start = Instant::now();
 
-    let mut output = None;
-    let mut coroutine = CreateFiles::new(
-        (0..n).map(|n| (tmp.path().join(n.to_string()), b"Hello, world!".to_vec())),
-    );
+    let mut arg = None;
+    let mut coroutine =
+        CreateFiles::new((0..n).map(|n| (tmp.path().join(n.to_string()), *b"Hello, world!")));
 
-    while let Err(io) = coroutine.resume(output) {
-        output = Some(handle(io).await.unwrap());
+    loop {
+        match coroutine.resume(arg) {
+            FsResult::Ok(()) => break,
+            FsResult::Err(err) => panic!("{err}"),
+            FsResult::Io(io) => arg = Some(handle(io).await.unwrap()),
+        }
     }
 
     let duration = start.elapsed();