wyz 0.1.1

myrrlyn’s utility collection
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
145
146

/*! Prints `Display` instead of `Debug`.

Various APIs in Rust use `Debug` hooks to show failure diagnostics. The default
implementation of `Debug` provided by its derive macro prints a source-code
representation of the value, which may not be the most useful text to show to a
user.

This module provides a single type that implements `Debug` by delegating to the
`Display` implementation of the wrapped type. Any type with a `Display`
implementation can wrap in this type, and have its `Display` implementation
called by `Debug` hooks.

All other formatting traits are passed through without redirection.
!*/

use core::{
	fmt::{
		self,
		Binary,
		Debug,
		Display,
		LowerExp,
		LowerHex,
		Octal,
		Pointer,
		UpperExp,
		UpperHex,
		Formatter,
	},
	ops::{
		Deref,
		DerefMut,
	},
};

/** Redirects `Debug` to `Display`, leaving all other formatters unchanged.

This type wraps any other type, and reïmplements the formatters that the wrapped
type has. If the wrapped type implements `Display`, this wrapper implements both
`Debug` and `Display` as redirects to the wrapped `Display`.

Because Rust does not have negative trait bounds, there is no `Debug`
implementation if the wrapped type has `Debug` but not `Display`.

Complain to the language team.
**/
pub struct Pretty<T>(T);

/// Redirect `Debug` to `Display` when wrapping `Display` types.
impl<T: Display> Debug for Pretty<T> {
	fn fmt(&self, f: &mut Formatter) -> fmt::Result {
		Display::fmt(&self.0, f)
	}
}

/// Forward `Binary` correctly.
impl<T: Binary> Binary for Pretty<T> {
	fn fmt(&self, f: &mut Formatter) -> fmt::Result {
		Binary::fmt(&self.0, f)
	}
}

/// Forward `Display` correctly.
impl<T: Display> Display for Pretty<T> {
	fn fmt(&self, f: &mut Formatter) -> fmt::Result {
		Display::fmt(&self.0, f)
	}
}

/// Forward `LowerExp` correctly.
impl<T: LowerExp> LowerExp for Pretty<T> {
	fn fmt(&self, f: &mut Formatter) -> fmt::Result {
		LowerExp::fmt(&self.0, f)
	}
}

/// Forward `LowerHex` correctly.
impl<T: LowerHex> LowerHex for Pretty<T> {
	#[inline(always)]
	fn fmt(&self, f: &mut Formatter) -> fmt::Result {
		LowerHex::fmt(&self.0, f)
	}
}

/// Forward `Octal` correctly.
impl<T: Octal> Octal for Pretty<T> {
	#[inline(always)]
	fn fmt(&self, f: &mut Formatter) -> fmt::Result {
		Octal::fmt(&self.0, f)
	}
}

/// Forward `Pointer` correctly.
impl<T: Pointer> Pointer for Pretty<T> {
	#[inline(always)]
	fn fmt(&self, f: &mut Formatter) -> fmt::Result {
		Pointer::fmt(&self.0, f)
	}
}

/// Forward `UpperExp` correctly.
impl<T: UpperExp> UpperExp for Pretty<T> {
	#[inline(always)]
	fn fmt(&self, f: &mut Formatter) -> fmt::Result {
		UpperExp::fmt(&self.0, f)
	}
}

/// Forward `UpperHex` correctly.
impl<T: UpperHex> UpperHex for Pretty<T> {
	#[inline(always)]
	fn fmt(&self, f: &mut Formatter) -> fmt::Result {
		UpperHex::fmt(&self.0, f)
	}
}

impl<T> Deref for Pretty<T> {
	type Target = T;

	fn deref(&self) -> &Self::Target {
		&self.0
	}
}

impl<T> DerefMut for Pretty<T> {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}

/// Allow any type to wrap itself in `Pretty`.
impl<T: Sized> From<T> for Pretty<T> {
	fn from(val: T) -> Self {
		Self(val)
	}
}

/// Shorthand conversion to wrap any value in a `Pretty`.
pub trait Prettify: Sized {
	/// Wraps `self` in a `Pretty`.
	fn prettify(self) -> Pretty<Self> {
		self.into()
	}
}

impl<T: Sized> Prettify for T {}