ystd 0.0.11

An opinionated and batteries included `std` mirror for convenient, correct code and pleasant error messages
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

use std::fs::Metadata;

use crate::{
	io::{self, asyncify},
	prelude::*,
};

pub async fn create_dir_all(path: impl AsRef<Utf8Path>) -> io::Result<()> {
	let path = path.as_ref().to_owned();
	asyncify(move || {
		std::fs::create_dir_all(&path).map_err_std_io(|io| {
			Report::new(io.clone()).wrap_err(format!("ystd::fs::create_dir_all({})", path))
		})
	})
	.await
}

pub async fn read(path: impl AsRef<Utf8Path>) -> io::Result<Vec<u8>> {
	let path = path.as_ref().to_owned();
	asyncify(move || {
		std::fs::read(&path)
			.map_err_std_io(|io| Report::new(io).wrap_err(format!("ystd::fs::read({})", path)))
	})
	.await
}

pub async fn read_to_string(path: impl AsRef<Utf8Path>) -> io::Result<String> {
	let path = path.as_ref().to_owned();
	asyncify(move || {
		std::fs::read_to_string(&path).map_err_std_io(|io| {
			Report::new(io).wrap_err(format!("ystd::fs::read_to_string({})", path))
		})
	})
	.await
}

pub async fn canonicalize_utf8(path: impl AsRef<Utf8Path>) -> io::Result<Utf8PathBuf> {
	let path = path.as_ref().to_owned();
	let path = crate::io::asyncify(move || {
		path.0.canonicalize_utf8().map(Utf8PathBuf).map_err(|io| {
			let io = Arc::new(io);
			io::Error::empty(
				Report::new(io.clone()).wrap_err(format!("ystd::fs::canonicalize({})", path)),
			)
			.with_io(io)
		})
	})
	.await?;
	Ok(path)
}

pub async fn canonicalize(path: impl AsRef<Utf8Path>) -> io::Result<Utf8PathBuf> {
	canonicalize_utf8(path).await
}

pub async fn metadata(path: impl AsRef<Utf8Path>) -> io::Result<Metadata> {
	let path = path.as_ref().to_owned();
	asyncify(move || {
		std::fs::metadata(&path)
			.map_err_std_io(|io| Report::new(io).wrap_err(format!("ystd::fs::metadata({})", path)))
	})
	.await
}

pub async fn write(path: impl AsRef<Utf8Path>, contents: impl AsRef<[u8]>) -> io::Result<()> {
	let path = path.as_ref().to_owned();
	let contents = contents.as_ref().to_owned();
	asyncify(move || {
		std::fs::write(&path, contents).map_err_std_io(|io| {
			Report::new(io).wrap_err(format!("ystd::fs::write({})", path))
		})
	})
	.await
}