better_conversions/
lib.rs

1//!/////// START OF FILE //////////
2//! better-conversions ///
3
4pub mod prelude;
5
6// ERROR //
7#[derive(Debug, Clone, PartialEq)]
8pub enum ConversionError {
9    Error(String, String),
10}
11impl ConversionError {
12    pub(crate) fn error<F: Into<String>, M: Into<String>>(from: F, msg: M) -> Self {
13        return Self::Error(from.into(), msg.into());
14    }
15}
16// ERROR //
17
18// TRAITS //
19pub trait GoToU8 {fn goto_u8(&self) -> u8;}
20pub trait GoToU16 {fn goto_u16(&self) -> u16;}
21pub trait GoToU32 {fn goto_u32(&self) -> u32;}
22pub trait GoToU64 {fn goto_u64(&self) -> u64;}
23pub trait GoToU128 {fn goto_u128(&self) -> u128;}
24pub trait GoToUsize {fn goto_usize(&self) -> usize;}
25pub trait GoToF32 {fn goto_f32(&self) -> f32;}
26pub trait GoToF64 {fn goto_f64(&self) -> f64;}
27pub trait TryGoToU8 {fn try_goto_u8(&self) -> Result<u8, ConversionError>;}
28pub trait TryGoToU16 {fn try_goto_u16(&self) -> Result<u16, ConversionError>;}
29pub trait TryGoToU32 {fn try_goto_u32(&self) -> Result<u32, ConversionError>;}
30pub trait TryGoToU64 {fn try_goto_u64(&self) -> Result<u64, ConversionError>;}
31pub trait TryGoToU128 {fn try_goto_u128(&self) -> Result<u128, ConversionError>;}
32pub trait TryGoToUsize {fn try_goto_usize(&self) -> Result<usize, ConversionError>;}
33pub trait TryGoToF32 {fn try_goto_f32(&self) -> Result<f32, ConversionError>;}
34pub trait TryGoToF64 {fn try_goto_f64(&self) -> Result<f64, ConversionError>;}
35// TRAITS //
36
37// U8 //
38impl GoToU8 for u8 {fn goto_u8(&self) -> u8 {*self as u8}}
39impl GoToU16 for u8 {fn goto_u16(&self) -> u16 {*self as u16}}
40impl GoToU32 for u8 {fn goto_u32(&self) -> u32 {*self as u32}}
41impl GoToU64 for u8 {fn goto_u64(&self) -> u64 {*self as u64}}
42impl GoToU128 for u8 {fn goto_u128(&self) -> u128 {*self as u128}}
43impl GoToUsize for u8 {fn goto_usize(&self) -> usize {*self as usize}}
44impl GoToF32 for u8 {fn goto_f32(&self) -> f32 {*self as f32}}
45impl GoToF64 for u8 {fn goto_f64(&self) -> f64 {*self as f64}}
46// U8 //
47
48// U16 //
49impl TryGoToU8 for u16 { 
50    fn try_goto_u8(&self) -> Result<u8, ConversionError> {
51        if *self <= u8::MAX as u16 {Ok(*self as u8)}
52        else {Err(ConversionError::error("better-conversions::TryGoToU8::try_goto_u8", format!("{} out of u8 range", self)))}
53    }
54}
55impl GoToU16 for u16 {fn goto_u16(&self) -> u16 {*self as u16}}
56impl GoToU32 for u16 {fn goto_u32(&self) -> u32 {*self as u32}}
57impl GoToU64 for u16 {fn goto_u64(&self) -> u64 {*self as u64}}
58impl GoToU128 for u16 {fn goto_u128(&self) -> u128 {*self as u128}}
59impl GoToUsize for u16 {fn goto_usize(&self) -> usize {*self as usize}}
60impl GoToF32 for u16 {fn goto_f32(&self) -> f32 {*self as f32}}
61impl GoToF64 for u16 {fn goto_f64(&self) -> f64 {*self as f64}}
62// U16 //
63
64// U32 //
65impl TryGoToU8 for u32 { 
66    fn try_goto_u8(&self) -> Result<u8, ConversionError> {
67        if *self <= u8::MAX as u32 {Ok(*self as u8)}
68        else {Err(ConversionError::error("better-conversions::TryGoToU8::try_goto_u8", format!("{} out of u8 range", self)))}
69    }
70}
71impl TryGoToU16 for u32 { 
72    fn try_goto_u16(&self) -> Result<u16, ConversionError> {
73        if *self <= u16::MAX as u32 {Ok(*self as u16)}
74        else {Err(ConversionError::error("better-conversions::TryGoToU16::try_goto_u16", format!("{} out of u16 range", self)))}
75    }
76}
77impl GoToU32 for u32 {fn goto_u32(&self) -> u32 {*self as u32}}
78impl GoToU64 for u32 {fn goto_u64(&self) -> u64 {*self as u64}}
79impl GoToU128 for u32 {fn goto_u128(&self) -> u128 {*self as u128}}
80impl GoToUsize for u32 {fn goto_usize(&self) -> usize {*self as usize}}
81impl TryGoToF32 for u32 { 
82    fn try_goto_f32(&self) -> Result<f32, ConversionError> {
83        let converted = *self as f32;
84        if converted as u32 == *self {Ok(converted)} 
85        else {Err(ConversionError::error("better-conversions::TryGoToF32::try_goto_f32", format!("{} lost precision as a f32", self)))}
86    }
87}
88impl GoToF64 for u32 {fn goto_f64(&self) -> f64 {*self as f64}}
89// U32 //
90
91// U64 //
92impl TryGoToU8 for u64 { 
93    fn try_goto_u8(&self) -> Result<u8, ConversionError> {
94        if *self <= u8::MAX as u64 {Ok(*self as u8)}
95        else {Err(ConversionError::error("better-conversions::TryGoToU8::try_goto_u8", format!("{} out of u8 range", self)))}
96    }
97}
98impl TryGoToU16 for u64 { 
99    fn try_goto_u16(&self) -> Result<u16, ConversionError> {
100        if *self <= u16::MAX as u64 {Ok(*self as u16)}
101        else {Err(ConversionError::error("better-conversions::TryGoToU16::try_goto_u16", format!("{} out of u16 range", self)))}
102    }
103}
104impl TryGoToU32 for u64 { 
105    fn try_goto_u32(&self) -> Result<u32, ConversionError> {
106        if *self <= u32::MAX as u64 {Ok(*self as u32)}
107        else {Err(ConversionError::error("better-conversions::TryGoToU32::try_goto_u32", format!("{} out of u32 range", self)))}
108    }
109}
110impl GoToU64 for u64 {fn goto_u64(&self) -> u64 {*self as u64}}
111impl GoToU128 for u64 {fn goto_u128(&self) -> u128 {*self as u128}}
112impl TryGoToUsize for u64 { 
113    fn try_goto_usize(&self) -> Result<usize, ConversionError> {
114        if *self <= usize::MAX as u64 {Ok(*self as usize)}
115        else {Err(ConversionError::error("better-conversions::TryGoToUsize::try_goto_usize", format!("{} out of usize range", self)))}
116    }
117}
118impl TryGoToF32 for u64 { 
119    fn try_goto_f32(&self) -> Result<f32, ConversionError> {
120        let converted = *self as f32;
121        if converted as u64 == *self {Ok(converted)} 
122        else {Err(ConversionError::error("better-conversions::TryGoToF32::try_goto_f32", format!("{} lost precision as a f32", self)))}
123    }
124}
125impl TryGoToF64 for u64 { 
126    fn try_goto_f64(&self) -> Result<f64, ConversionError> {
127        let converted = *self as f64;
128        if converted as u64 == *self {Ok(converted)} 
129        else {Err(ConversionError::error("better-conversions::TryGoToF64::try_goto_f64", format!("{} lost precision as a f64", self)))}
130    }
131}
132// U64 //
133
134// U128 //
135impl TryGoToU8 for u128 { 
136    fn try_goto_u8(&self) -> Result<u8, ConversionError> {
137        if *self <= u8::MAX as u128 {Ok(*self as u8)}
138        else {Err(ConversionError::error("better-conversions::TryGoToU8::try_goto_u8", format!("{} out of u8 range", self)))}
139    }
140}
141impl TryGoToU16 for u128 { 
142    fn try_goto_u16(&self) -> Result<u16, ConversionError> {
143        if *self <= u16::MAX as u128 {Ok(*self as u16)}
144        else {Err(ConversionError::error("better-conversions::TryGoToU16::try_goto_u16", format!("{} out of u16 range", self)))}
145    }
146}
147impl TryGoToU32 for u128 { 
148    fn try_goto_u32(&self) -> Result<u32, ConversionError> {
149        if *self <= u32::MAX as u128 {Ok(*self as u32)}
150        else {Err(ConversionError::error("better-conversions::TryGoToU32::try_goto_u32", format!("{} out of u32 range", self)))}
151    }
152}
153impl TryGoToU64 for u128 { 
154    fn try_goto_u64(&self) -> Result<u64, ConversionError> {
155        if *self <= u64::MAX as u128 {Ok(*self as u64)}
156        else {Err(ConversionError::error("better-conversions::TryGoToU64::try_goto_u64", format!("{} out of u64 range", self)))}
157    }
158}
159impl GoToU128 for u128 {fn goto_u128(&self) -> u128 {*self as u128}}
160impl TryGoToUsize for u128 { 
161    fn try_goto_usize(&self) -> Result<usize, ConversionError> {
162        if *self <= usize::MAX as u128 {Ok(*self as usize)}
163        else {Err(ConversionError::error("better-conversions::TryGoToUsize::try_goto_usize", format!("{} out of usize range", self)))}
164    }
165}
166impl TryGoToF32 for u128 { 
167    fn try_goto_f32(&self) -> Result<f32, ConversionError> {
168        let converted = *self as f32;
169        if converted as u128 == *self {Ok(converted)} 
170        else {Err(ConversionError::error("better-conversions::TryGoToF32::try_goto_f32", format!("{} lost precision as a f32", self)))}
171    }
172}
173impl TryGoToF64 for u128 { 
174    fn try_goto_f64(&self) -> Result<f64, ConversionError> {
175        let converted = *self as f64;
176        if converted as u128 == *self {Ok(converted)} 
177        else {Err(ConversionError::error("better-conversions::TryGoToF64::try_goto_f64", format!("{} lost precision as a f64", self)))}
178    }
179}
180// U128 //
181
182// usize //
183impl TryGoToU8 for usize {
184    fn try_goto_u8(&self) -> Result<u8, ConversionError> {
185        if *self <= u8::MAX as usize { Ok(*self as u8) }
186        else { Err(ConversionError::error("better-conversions::TryGoToU8::try_goto_u8", format!("{} out of u8 range", self))) }
187    }
188}
189impl TryGoToU16 for usize {
190    fn try_goto_u16(&self) -> Result<u16, ConversionError> {
191        if *self <= u16::MAX as usize { Ok(*self as u16) }
192        else { Err(ConversionError::error("better-conversions::TryGoToU16::try_goto_u16", format!("{} out of u16 range", self))) }
193    }
194}
195impl TryGoToU32 for usize {
196    fn try_goto_u32(&self) -> Result<u32, ConversionError> {
197        if *self <= u32::MAX as usize { Ok(*self as u32) }
198        else { Err(ConversionError::error("better-conversions::TryGoToU32::try_goto_u32", format!("{} out of u32 range", self))) }
199    }
200}
201impl TryGoToU64 for usize {
202    fn try_goto_u64(&self) -> Result<u64, ConversionError> {
203        if *self <= u64::MAX as usize { Ok(*self as u64) }
204        else { Err(ConversionError::error("better-conversions::TryGoToU64::try_goto_u64", format!("{} out of u64 range", self))) }
205    }
206}
207impl GoToU128 for usize { fn goto_u128(&self) -> u128 { *self as u128 } }
208impl GoToUsize for usize { fn goto_usize(&self) -> usize { *self } }
209impl TryGoToF32 for usize {
210    fn try_goto_f32(&self) -> Result<f32, ConversionError> {
211        let converted = *self as f32;
212        if converted as usize == *self { Ok(converted) }
213        else { Err(ConversionError::error("better-conversions::TryGoToF32::try_goto_f32", format!("{} lost precision as a f32", self))) }
214    }
215}
216impl TryGoToF64 for usize {
217    fn try_goto_f64(&self) -> Result<f64, ConversionError> {
218        let converted = *self as f64;
219        if converted as usize == *self { Ok(converted) }
220        else { Err(ConversionError::error("better-conversions::TryGoToF64::try_goto_f64", format!("{} lost precision as a f64", self))) }
221    }
222}
223// usize //
224
225// f32 //
226impl TryGoToU8 for f32 {
227    fn try_goto_u8(&self) -> Result<u8, ConversionError> {
228        if !self.is_finite() {return Err(ConversionError::error("better-conversions::TryGoToU8::try_goto_u8", format!("{} is not finite", self)));}
229        if self.fract() != 0.0 {return Err(ConversionError::error("better-conversions::TryGoToU8::try_goto_u8", format!("{} has a fractional", self)));}
230        if *self >= 0.0 && *self <= u8::MAX as f32 {Ok(*self as u8)}
231        else {Err(ConversionError::error("better-conversions::TryGoToU8::try_goto_u8", format!("{} out of u8 range", self)))}
232    }
233}
234impl TryGoToU16 for f32 {
235    fn try_goto_u16(&self) -> Result<u16, ConversionError> {
236        if !self.is_finite() {return Err(ConversionError::error("better-conversions::TryGoToU16::try_goto_u16", format!("{} is not finite", self)));}
237        if self.fract() != 0.0 {return Err(ConversionError::error("better-conversions::TryGoToU16::try_goto_u16", format!("{} has a fractional", self)));}
238        if *self >= 0.0 && *self <= u16::MAX as f32 {Ok(*self as u16)}
239        else {Err(ConversionError::error("better-conversions::TryGoToU16::try_goto_u16", format!("{} out of u16 range", self)))}
240    }
241}
242impl TryGoToU32 for f32 {
243    fn try_goto_u32(&self) -> Result<u32, ConversionError> {
244        if !self.is_finite() {return Err(ConversionError::error("better-conversions::TryGoToU32::try_goto_u32", format!("{} is not finite", self)));}
245        if self.fract() != 0.0 {return Err(ConversionError::error("better-conversions::TryGoToU32::try_goto_u32", format!("{} has a fractional", self)));}
246        if *self >= 0.0 && *self <= u32::MAX as f32 {Ok(*self as u32)}
247        else {Err(ConversionError::error("better-conversions::TryGoToU32::try_goto_u32", format!("{} out of u32 range", self)))}
248    }
249}
250impl TryGoToU64 for f32 {
251    fn try_goto_u64(&self) -> Result<u64, ConversionError> {
252        if !self.is_finite() {return Err(ConversionError::error("better-conversions::TryGoToU64::try_goto_u64", format!("{} is not finite", self)));}
253        if self.fract() != 0.0 {return Err(ConversionError::error("better-conversions::TryGoToU64::try_goto_u64", format!("{} has a fractional", self)));}
254        if *self >= 0.0 && *self <= u64::MAX as f32 {Ok(*self as u64)}
255        else {Err(ConversionError::error("better-conversions::TryGoToU64::try_goto_u64", format!("{} out of u64 range", self)))}
256    }
257}
258impl TryGoToU128 for f32 {
259    fn try_goto_u128(&self) -> Result<u128, ConversionError> {
260        if !self.is_finite() {return Err(ConversionError::error("better-conversions::TryGoToU128::try_goto_u128", format!("{} is not finite", self)));}
261        if self.fract() != 0.0 {return Err(ConversionError::error("better-conversions::TryGoToU128::try_goto_u128", format!("{} has a fractional", self)));}
262        if *self >= 0.0 && *self <= u128::MAX as f32 {Ok(*self as u128)}
263        else {Err(ConversionError::error("better-conversions::TryGoToU128::try_goto_u128", format!("{} out of u128 range", self)))}
264    }
265}
266impl TryGoToUsize for f32 {
267    fn try_goto_usize(&self) -> Result<usize, ConversionError> {
268        if !self.is_finite() {return Err(ConversionError::error("better-conversions::TryGoToUsize::try_goto_usize", format!("{} is not finite", self)));}
269        if self.fract() != 0.0 {return Err(ConversionError::error("better-conversions::TryGoToUsize::try_goto_usize", format!("{} has a fractional", self)));
270        }
271        if *self >= 0.0 && *self <= usize::MAX as f32 {Ok(*self as usize)} 
272        else {Err(ConversionError::error("better-conversions::TryGoToUsize::try_goto_usize", format!("{} out of usize range", self)))}
273    }
274}
275impl GoToF32 for f32 {fn goto_f32(&self) -> f32 {*self as f32}}
276impl GoToF64 for f32 {fn goto_f64(&self) -> f64 {*self as f64}}
277// f32 //
278
279// f64 //
280impl TryGoToU8 for f64 {
281    fn try_goto_u8(&self) -> Result<u8, ConversionError> {
282        if !self.is_finite() {return Err(ConversionError::error("better-conversions::TryGoToU8::try_goto_u8", format!("{} is not finite", self)));}
283        if self.fract() != 0.0 {return Err(ConversionError::error("better-conversions::TryGoToU8::try_goto_u8", format!("{} has a fractional", self)));}
284        if *self >= 0.0 && *self <= u8::MAX as f64 {Ok(*self as u8)}
285        else {Err(ConversionError::error("better-conversions::TryGoToU8::try_goto_u8", format!("{} out of u8 range", self)))}
286    }
287}
288impl TryGoToU16 for f64 {
289    fn try_goto_u16(&self) -> Result<u16, ConversionError> {
290        if !self.is_finite() {return Err(ConversionError::error("better-conversions::TryGoToU16::try_goto_u16", format!("{} is not finite", self)));}
291        if self.fract() != 0.0 {return Err(ConversionError::error("better-conversions::TryGoToU16::try_goto_u16", format!("{} has a fractional", self)));}
292        if *self >= 0.0 && *self <= u16::MAX as f64 {Ok(*self as u16)}
293        else {Err(ConversionError::error("better-conversions::TryGoToU16::try_goto_u16", format!("{} out of u16 range", self)))}
294    }
295}
296impl TryGoToU32 for f64 {
297    fn try_goto_u32(&self) -> Result<u32, ConversionError> {
298        if !self.is_finite() {return Err(ConversionError::error("better-conversions::TryGoToU32::try_goto_u32", format!("{} is not finite", self)));}
299        if self.fract() != 0.0 {return Err(ConversionError::error("better-conversions::TryGoToU32::try_goto_u32", format!("{} has a fractional", self)));}
300        if *self >= 0.0 && *self <= u32::MAX as f64 {Ok(*self as u32)}
301        else {Err(ConversionError::error("better-conversions::TryGoToU32::try_goto_u32", format!("{} out of u32 range", self)))}
302    }
303}
304impl TryGoToU64 for f64 {
305    fn try_goto_u64(&self) -> Result<u64, ConversionError> {
306        if !self.is_finite() {return Err(ConversionError::error("better-conversions::TryGoToU64::try_goto_u64", format!("{} is not finite", self)));}
307        if self.fract() != 0.0 {return Err(ConversionError::error("better-conversions::TryGoToU64::try_goto_u64", format!("{} has a fractional", self)));}
308        if *self >= 0.0 && *self <= u64::MAX as f64 {Ok(*self as u64)}
309        else {Err(ConversionError::error("better-conversions::TryGoToU64::try_goto_u64", format!("{} out of u64 range", self)))}
310    }
311}
312impl TryGoToU128 for f64 {
313    fn try_goto_u128(&self) -> Result<u128, ConversionError> {
314        if !self.is_finite() {return Err(ConversionError::error("better-conversions::TryGoToU128::try_goto_u128", format!("{} is not finite", self)));}
315        if self.fract() != 0.0 {return Err(ConversionError::error("better-conversions::TryGoToU128::try_goto_u128", format!("{} has a fractional", self)));}
316        if *self >= 0.0 && *self <= u128::MAX as f64 {Ok(*self as u128)}
317        else {Err(ConversionError::error("better-conversions::TryGoToU128::try_goto_u128", format!("{} out of u128 range", self)))}
318    }
319}
320impl TryGoToUsize for f64 {
321    fn try_goto_usize(&self) -> Result<usize, ConversionError> {
322        if !self.is_finite() {return Err(ConversionError::error("better-conversions::TryGoToUsize::try_goto_usize", format!("{} is not finite", self)));}
323        if self.fract() != 0.0 {return Err(ConversionError::error("better-conversions::TryGoToUsize::try_goto_usize", format!("{} has a fractional", self)));}
324        if *self >= 0.0 && *self <= usize::MAX as f64 {Ok(*self as usize)}
325        else {Err(ConversionError::error("better-conversions::TryGoToUsize::try_goto_usize", format!("{} out of usize range", self)))}
326    }
327}
328impl TryGoToF32 for f64 {
329    fn try_goto_f32(&self) -> Result<f32, ConversionError> {
330        if !self.is_finite() {return Err(ConversionError::error("better-conversions::TryGoToF32::try_goto_f32", format!("{} is not finite", self)));}
331        if *self >= f32::MIN as f64 && *self <= f32::MAX as f64 {Ok(*self as f32)}
332        else {Err(ConversionError::error("better-conversions::TryGoToF32::try_goto_f32", format!("{} out of f32 range", self)))}
333    }
334}
335impl GoToF64 for f64 {fn goto_f64(&self) -> f64 {*self as f64}}
336// f64 //
337
338////////// END OF FILE //////////
better_conversions/lib.rs

better_conversions/
lib.rs
