cauz 0.0.3

Succinct error handling
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
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

/*
	Code to simplify provision of error context.
*/

//|
//| 3rd-party imports
//|
#[allow(unused_imports)]
pub use anyhow::{Context, Result, anyhow, bail}; // Re-export to avoid using `anyhow` in other modules.
use std::fmt::Display;

//|
//| err!
//|
#[macro_export]
macro_rules! err {
	() => {
		anyhow!("{:?} ", (file!(), line!()))
	};

	//| Convert & expand an Error
	($err:ident) => {
		anyhow!("{:?} {}", (file!(), line!()), anyhow!($err).chain().map(|e| e.to_string()).collect::<String>())
	};

	($msg:literal) => {
		anyhow!("{:?} {}", (file!(), line!()), $msg)
	};

	($fmt:literal, $($args:tt)*) => {
		anyhow!("{:?} {}", (file!(), line!()), format!($fmt, $($args)*))
	};

	($err:ident, $($args:tt)*) => {
		anyhow!("{:?} {} {}", (file!(), line!()), format!($($args)*), anyhow!($err).chain().map(|e| e.to_string()).collect::<String>())
	};

	//| Convert anything into an Error
	//# This must be below the pattern of ($err:ident) to have a lower matching priority
	($err:expr) => {
		anyhow!("{:?}", $err)
	};
}
// pub(crate) use err; // To avoid using #[macro_use] in main.rs. Ref: https://stackoverflow.com/questions/26731243/how-do-i-use-a-macro-across-module-files

//|
//| Cauz
//|
pub trait Cauz<C, T> {
	#[allow(dead_code)] //todo: Why is this dead code when it's actually used?
	fn cauz(self, cause: C) -> Result<T>; //| Lazily evaluated `cause`
}

//| Result
impl<C, T, E> Cauz<C, T> for core::result::Result<T, E>
where
	C: Display + Send + Sync + 'static,
	E: Into<anyhow::Error>,
{
	#[inline(always)]
	fn cauz(self, cause: C) -> Result<T> {
		(self.map_err(|e| (e.into() as anyhow::Error)) as anyhow::Result<_>).with_context(|| cause)
	}
}

//| Option: A context function to replace `.cauz(err!(...)` (not lazy) or `.ok_or_else(|| err!(...))` (too long) with `.cauz(err!(...))`.
impl<C, T> Cauz<C, T> for Option<T>
where
	C: Display + Send + Sync + 'static,
{
	#[inline(always)]
	fn cauz(self, cause: C) -> Result<T> {
		self.with_context(|| cause)
	}
}

//| bool: A context function to replace `ensure!($expr, err!(...))` with `$expr.cauz(err!(...))?`.
impl<C> Cauz<C, ()> for bool
where
	C: Display + Send + Sync + 'static,
{
	#[inline(always)]
	fn cauz(self, cause: C) -> Result<()> {
		self.then_some(()).with_context(|| cause)
	}
}

//|
//| CauzTonic
//|
#[cfg(feature = "cauz_tonic")]
pub use cauz_tonic::*;

#[cfg(feature = "cauz_tonic")]
mod cauz_tonic {
	use super::*;
	use std::fmt::Debug;
	use tonic::Status;

	//|
	//| CauzTonic
	//|
	pub trait CauzTonic<C, T> {
		#[allow(dead_code)] //todo: Why is this dead code when it's actually used?
		fn cauz2(self, cause: C) -> Result<T, Status>; //| Lazily evaluated `cause`
	}

	//| Result
	impl<C, T, E> CauzTonic<C, T> for core::result::Result<T, E>
	where
		C: Display + Send + Sync + 'static,
		E: Into<anyhow::Error>,
	{
		#[inline(always)]
		fn cauz2(self, cause: C) -> Result<T, Status> {
			(self.map_err(|e| (e.into() as anyhow::Error)) as anyhow::Result<_>)
				.with_context(|| cause)
				.map_err(|e| Status::internal(e.chain().map(|e| e.to_string()).collect::<String>()))
				.inspect_err(|e| log::error!("{}", e.message()))
		}
	}

	//| Option: A context function to replace `.cauz(cauz!(...)` (not lazy) or `.ok_or_else(|| cauz!(...))` (too long) with `.cauz(cauz!(...))`.
	impl<C, T> CauzTonic<C, T> for Option<T>
	where
		C: Display + Send + Sync + 'static + Debug,
	{
		#[inline(always)]
		fn cauz2(self, cause: C) -> Result<T, Status> {
			self.ok_or_else(|| Status::internal(cause.to_string()))
		}
	}

	//| bool
	impl<C> CauzTonic<C, ()> for bool
	where
		C: Display + Send + Sync + 'static + Debug,
	{
		#[inline(always)]
		fn cauz2(self, cause: C) -> Result<(), Status> {
			self.then_some(()).ok_or_else(|| Status::internal(cause.to_string()))
		}
	}
}