fn_formats/
lib.rs

1//! This is a small shim library for passing closures where you need a format trait.
2//!
3//! ## Example
4//!
5//! ```rust
6//! use fn_formats::DebugFmt;
7//!
8//! let formattable = DebugFmt(|f| {
9//!     f.debug_struct("StructName")
10//!         .field("list", &DebugFmt(|f| f.debug_list().entries(&[1, 2, 3]).finish()))
11//!         .field("set", &DebugFmt(|f| f.debug_set().entries(&[4, 5, 6]).finish()))
12//!         .finish()
13//! });
14//!
15//! assert_eq!(format!("{:?}", formattable), "StructName { list: [1, 2, 3], set: {4, 5, 6} }");
16//! ```
17//!
18//! There are also [`From`] implementations where applicable:
19//!
20//! ```rust
21//! use fn_formats::ComprehensiveFmt;
22//! let _: ComprehensiveFmt<_> = (|f: &mut core::fmt::Formatter| Ok(())).into();
23//! ```
24//!
25//! [`From`]: https://doc.rust-lang.org/stable/std/convert/trait.From.html
26
27#![no_std]
28#![doc(html_root_url = "https://docs.rs/fn-formats/0.0.5")]
29#![warn(clippy::pedantic)]
30
31#[cfg(doctest)]
32pub mod readme {
33	doc_comment::doctest!("../README.md");
34}
35
36use core::fmt::{
37	self, Binary, Debug, Display, Formatter, LowerExp, LowerHex, Octal, Pointer, UpperExp, UpperHex,
38};
39
40/// Implements [`Debug`] by calling the stored closure.
41///
42/// [`Debug`]: https://doc.rust-lang.org/stable/core/fmt/trait.Debug.html
43///
44/// # Example
45///
46/// ```rust
47/// use fn_formats::DebugFmt;
48///
49/// let debug = DebugFmt(|f| write!(f, "debug"));
50///
51/// assert_eq!(format!("{:?}", debug), "debug");
52/// ```
53#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Default)]
54pub struct DebugFmt<Fmt>(pub Fmt)
55where
56	Fmt: Fn(&mut Formatter) -> fmt::Result;
57
58impl<Fmt: Fn(&mut Formatter) -> fmt::Result> Debug for DebugFmt<Fmt> {
59	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
60		self.0(f)
61	}
62}
63
64/// ```rust
65/// let _: fn_formats::DebugFmt<_> = (|f: &mut core::fmt::Formatter| Ok(())).into();
66/// ```
67impl<Fmt: Fn(&mut Formatter) -> fmt::Result> From<Fmt> for DebugFmt<Fmt> {
68	fn from(fmt: Fmt) -> Self {
69		Self(fmt)
70	}
71}
72
73/// Implements [`Display`] by calling the stored closure.
74///
75/// [`Display`]: https://doc.rust-lang.org/stable/core/fmt/trait.Display.html
76///
77/// # Example
78///
79/// ```rust
80/// use fn_formats::DisplayFmt;
81///
82/// let display = DisplayFmt(|f| write!(f, "display"));
83///
84/// assert_eq!(format!("{}", display), "display");
85/// ```
86#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Default)]
87pub struct DisplayFmt<Fmt>(pub Fmt)
88where
89	Fmt: Fn(&mut Formatter) -> fmt::Result;
90
91impl<Fmt: Fn(&mut Formatter) -> fmt::Result> Display for DisplayFmt<Fmt> {
92	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
93		self.0(f)
94	}
95}
96
97/// ```rust
98/// let _: fn_formats::DisplayFmt<_> = (|f: &mut core::fmt::Formatter| Ok(())).into();
99/// ```
100impl<Fmt: Fn(&mut Formatter) -> fmt::Result> From<Fmt> for DisplayFmt<Fmt> {
101	fn from(fmt: Fmt) -> Self {
102		Self(fmt)
103	}
104}
105
106/// Implements [`Debug`] and [`Display`] by calling the stored closure.
107///
108/// [`Debug`]: https://doc.rust-lang.org/stable/core/fmt/trait.Debug.html
109/// [`Display`]: https://doc.rust-lang.org/stable/core/fmt/trait.Display.html
110///
111/// # Example
112///
113/// ```rust
114/// use fn_formats::DebugDisplayFmt;
115///
116/// let debug_display = DebugDisplayFmt(|f| write!(f, "debug or display"));
117///
118/// assert_eq!(format!("{:?}", debug_display), "debug or display");
119/// assert_eq!(format!("{}", debug_display), "debug or display");
120/// ```
121#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Default)]
122pub struct DebugDisplayFmt<Fmt>(pub Fmt)
123where
124	Fmt: Fn(&mut Formatter) -> fmt::Result;
125
126impl<Fmt: Fn(&mut Formatter) -> fmt::Result> Debug for DebugDisplayFmt<Fmt> {
127	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
128		self.0(f)
129	}
130}
131
132impl<Fmt: Fn(&mut Formatter) -> fmt::Result> Display for DebugDisplayFmt<Fmt> {
133	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
134		self.0(f)
135	}
136}
137
138/// ```rust
139/// let _: fn_formats::DebugDisplayFmt<_> = (|f: &mut core::fmt::Formatter| Ok(())).into();
140/// ```
141impl<Fmt: Fn(&mut Formatter) -> fmt::Result> From<Fmt> for DebugDisplayFmt<Fmt> {
142	fn from(fmt: Fmt) -> Self {
143		Self(fmt)
144	}
145}
146
147/// Implements [`Debug`] and [`Display`] by calling the respective stored closure.
148///
149/// [`Debug`]: https://doc.rust-lang.org/stable/core/fmt/trait.Debug.html
150/// [`Display`]: https://doc.rust-lang.org/stable/core/fmt/trait.Display.html
151///
152/// # Example
153///
154/// ```rust
155/// use fn_formats::DebugDisplayFmtSeparate;
156///
157/// let debug_display = DebugDisplayFmtSeparate {
158///     debug: |f| write!(f, "debug"),
159///     display: |f| write!(f, "display"),
160/// };
161///
162/// assert_eq!(format!("{:?}", debug_display), "debug");
163/// assert_eq!(format!("{}", debug_display), "display");
164/// ```
165#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Default)]
166pub struct DebugDisplayFmtSeparate<DebugFmt, DisplayFmt>
167where
168	DebugFmt: Fn(&mut Formatter) -> fmt::Result,
169	DisplayFmt: Fn(&mut Formatter) -> fmt::Result,
170{
171	pub debug: DebugFmt,
172	pub display: DisplayFmt,
173}
174
175impl<
176		DebugFmt: Fn(&mut Formatter) -> fmt::Result,
177		DisplayFmt: Fn(&mut Formatter) -> fmt::Result,
178	> Debug for DebugDisplayFmtSeparate<DebugFmt, DisplayFmt>
179{
180	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
181		(self.debug)(f)
182	}
183}
184
185impl<
186		DebugFmt: Fn(&mut Formatter) -> fmt::Result,
187		DisplayFmt: Fn(&mut Formatter) -> fmt::Result,
188	> Display for DebugDisplayFmtSeparate<DebugFmt, DisplayFmt>
189{
190	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
191		(self.display)(f)
192	}
193}
194
195/// Implements [`Binary`] by calling the stored closure.
196///
197/// [`Binary`]: https://doc.rust-lang.org/stable/core/fmt/trait.Binary.html
198///
199/// # Example
200///
201/// ```rust
202/// use fn_formats::BinaryFmt;
203///
204/// let binary = BinaryFmt(|f| write!(f, "binary"));
205///
206/// assert_eq!(format!("{:b}", binary), "binary");
207/// ```
208#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Default)]
209pub struct BinaryFmt<Fmt>(pub Fmt)
210where
211	Fmt: Fn(&mut Formatter) -> fmt::Result;
212
213impl<Fmt: Fn(&mut Formatter) -> fmt::Result> Binary for BinaryFmt<Fmt> {
214	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
215		self.0(f)
216	}
217}
218
219/// ```rust
220/// let _: fn_formats::BinaryFmt<_> = (|f: &mut core::fmt::Formatter| Ok(())).into();
221/// ```
222impl<Fmt: Fn(&mut Formatter) -> fmt::Result> From<Fmt> for BinaryFmt<Fmt> {
223	fn from(fmt: Fmt) -> Self {
224		Self(fmt)
225	}
226}
227
228/// Implements [`LowerExp`] by calling the stored closure.
229///
230/// [`LowerExp`]: https://doc.rust-lang.org/stable/core/fmt/trait.LowerExp.html
231///
232/// # Example
233///
234/// ```rust
235/// use fn_formats::LowerExpFmt;
236///
237/// let lower_exp = LowerExpFmt(|f| write!(f, "lower exp"));
238///
239/// assert_eq!(format!("{:e}", lower_exp), "lower exp");
240/// ```
241#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Default)]
242pub struct LowerExpFmt<Fmt>(pub Fmt)
243where
244	Fmt: Fn(&mut Formatter) -> fmt::Result;
245
246impl<Fmt: Fn(&mut Formatter) -> fmt::Result> LowerExp for LowerExpFmt<Fmt> {
247	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
248		self.0(f)
249	}
250}
251
252/// ```rust
253/// let _: fn_formats::LowerExpFmt<_> = (|f: &mut core::fmt::Formatter| Ok(())).into();
254/// ```
255impl<Fmt: Fn(&mut Formatter) -> fmt::Result> From<Fmt> for LowerExpFmt<Fmt> {
256	fn from(fmt: Fmt) -> Self {
257		Self(fmt)
258	}
259}
260
261/// Implements [`LowerHex`] by calling the stored closure.
262///
263/// [`LowerHex`]: https://doc.rust-lang.org/stable/core/fmt/trait.LowerHex.html
264///
265/// # Example
266///
267/// ```rust
268/// use fn_formats::LowerHexFmt;
269///
270/// let lower_hex = LowerHexFmt(|f| write!(f, "lower hex"));
271///
272/// assert_eq!(format!("{:x}", lower_hex), "lower hex");
273/// ```
274#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Default)]
275pub struct LowerHexFmt<Fmt>(pub Fmt)
276where
277	Fmt: Fn(&mut Formatter) -> fmt::Result;
278
279impl<Fmt: Fn(&mut Formatter) -> fmt::Result> LowerHex for LowerHexFmt<Fmt> {
280	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
281		self.0(f)
282	}
283}
284
285/// ```rust
286/// let _: fn_formats::LowerHexFmt<_> = (|f: &mut core::fmt::Formatter| Ok(())).into();
287/// ```
288impl<Fmt: Fn(&mut Formatter) -> fmt::Result> From<Fmt> for LowerHexFmt<Fmt> {
289	fn from(fmt: Fmt) -> Self {
290		Self(fmt)
291	}
292}
293
294/// Implements [`Octal`] by calling the stored closure.
295///
296/// [`Octal`]: https://doc.rust-lang.org/stable/core/fmt/trait.Octal.html
297///
298/// # Example
299///
300/// ```rust
301/// use fn_formats::OctalFmt;
302///
303/// let octal = OctalFmt(|f| write!(f, "octal"));
304///
305/// assert_eq!(format!("{:o}", octal), "octal");
306/// ```
307#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Default)]
308pub struct OctalFmt<Fmt>(pub Fmt)
309where
310	Fmt: Fn(&mut Formatter) -> fmt::Result;
311
312impl<Fmt: Fn(&mut Formatter) -> fmt::Result> Octal for OctalFmt<Fmt> {
313	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
314		self.0(f)
315	}
316}
317
318/// ```rust
319/// let _: fn_formats::OctalFmt<_> = (|f: &mut core::fmt::Formatter| Ok(())).into();
320/// ```
321impl<Fmt: Fn(&mut Formatter) -> fmt::Result> From<Fmt> for OctalFmt<Fmt> {
322	fn from(fmt: Fmt) -> Self {
323		Self(fmt)
324	}
325}
326
327/// Implements [`Pointer`] by calling the stored closure.
328///
329/// [`Pointer`]: https://doc.rust-lang.org/stable/core/fmt/trait.Pointer.html
330///
331/// # Example
332///
333/// ```rust
334/// use fn_formats::PointerFmt;
335///
336/// let pointer = PointerFmt(|f| write!(f, "pointer"));
337///
338/// assert_eq!(format!("{:p}", pointer), "pointer");
339/// ```
340#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Default)]
341pub struct PointerFmt<Fmt>(pub Fmt)
342where
343	Fmt: Fn(&mut Formatter) -> fmt::Result;
344
345impl<Fmt: Fn(&mut Formatter) -> fmt::Result> Pointer for PointerFmt<Fmt> {
346	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
347		self.0(f)
348	}
349}
350
351/// ```rust
352/// let _: fn_formats::PointerFmt<_> = (|f: &mut core::fmt::Formatter| Ok(())).into();
353/// ```
354impl<Fmt: Fn(&mut Formatter) -> fmt::Result> From<Fmt> for PointerFmt<Fmt> {
355	fn from(fmt: Fmt) -> Self {
356		Self(fmt)
357	}
358}
359
360/// Implements [`UpperExp`] by calling the stored closure.
361///
362/// [`UpperExp`]: https://doc.rust-lang.org/stable/core/fmt/trait.UpperExp.html
363///
364/// # Example
365///
366/// ```rust
367/// use fn_formats::UpperExpFmt;
368///
369/// let upper_exp = UpperExpFmt(|f| write!(f, "upper exp"));
370///
371/// assert_eq!(format!("{:E}", upper_exp), "upper exp");
372/// ```
373#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Default)]
374pub struct UpperExpFmt<Fmt>(pub Fmt)
375where
376	Fmt: Fn(&mut Formatter) -> fmt::Result;
377
378impl<Fmt: Fn(&mut Formatter) -> fmt::Result> UpperExp for UpperExpFmt<Fmt> {
379	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
380		self.0(f)
381	}
382}
383
384/// ```rust
385/// let _: fn_formats::UpperExpFmt<_> = (|f: &mut core::fmt::Formatter| Ok(())).into();
386/// ```
387impl<Fmt: Fn(&mut Formatter) -> fmt::Result> From<Fmt> for UpperExpFmt<Fmt> {
388	fn from(fmt: Fmt) -> Self {
389		Self(fmt)
390	}
391}
392
393/// Implements [`UpperHex`] by calling the stored closure.
394///
395/// [`UpperHex`]: https://doc.rust-lang.org/stable/core/fmt/trait.UpperHex.html
396///
397/// # Example
398///
399/// ```rust
400/// use fn_formats::UpperHexFmt;
401///
402/// let upper_hex = UpperHexFmt(|f| write!(f, "upperhex"));
403///
404/// assert_eq!(format!("{:X}", upper_hex), "upperhex");
405/// ```
406#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Default)]
407pub struct UpperHexFmt<Fmt>(pub Fmt)
408where
409	Fmt: Fn(&mut Formatter) -> fmt::Result;
410
411impl<Fmt: Fn(&mut Formatter) -> fmt::Result> UpperHex for UpperHexFmt<Fmt> {
412	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
413		self.0(f)
414	}
415}
416
417/// ```rust
418/// let _: fn_formats::UpperHexFmt<_> = (|f: &mut core::fmt::Formatter| Ok(())).into();
419/// ```
420impl<Fmt: Fn(&mut Formatter) -> fmt::Result> From<Fmt> for UpperHexFmt<Fmt> {
421	fn from(fmt: Fmt) -> Self {
422		Self(fmt)
423	}
424}
425
426/// Implements all format traits by calling the stored closure.
427///
428/// # Example
429///
430/// ```rust
431/// use fn_formats::ComprehensiveFmt;
432///
433/// let comprehensive = ComprehensiveFmt(|f| write!(f, "fmt"));
434///
435/// assert_eq!(format!("{:b}", comprehensive), "fmt");
436/// assert_eq!(format!("{:?}", comprehensive), "fmt");
437/// assert_eq!(format!("{}", comprehensive), "fmt");
438/// assert_eq!(format!("{:e}", comprehensive), "fmt");
439/// assert_eq!(format!("{:x}", comprehensive), "fmt");
440/// assert_eq!(format!("{:o}", comprehensive), "fmt");
441/// assert_eq!(format!("{:p}", comprehensive), "fmt");
442/// assert_eq!(format!("{:E}", comprehensive), "fmt");
443/// assert_eq!(format!("{:X}", comprehensive), "fmt");
444/// ```
445#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Default)]
446pub struct ComprehensiveFmt<Fmt>(pub Fmt)
447where
448	Fmt: Fn(&mut Formatter) -> fmt::Result;
449
450impl<Fmt: Fn(&mut Formatter) -> fmt::Result> Binary for ComprehensiveFmt<Fmt> {
451	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
452		self.0(f)
453	}
454}
455
456impl<Fmt: Fn(&mut Formatter) -> fmt::Result> Debug for ComprehensiveFmt<Fmt> {
457	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
458		self.0(f)
459	}
460}
461
462impl<Fmt: Fn(&mut Formatter) -> fmt::Result> Display for ComprehensiveFmt<Fmt> {
463	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
464		self.0(f)
465	}
466}
467
468impl<Fmt: Fn(&mut Formatter) -> fmt::Result> LowerExp for ComprehensiveFmt<Fmt> {
469	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
470		self.0(f)
471	}
472}
473
474impl<Fmt: Fn(&mut Formatter) -> fmt::Result> LowerHex for ComprehensiveFmt<Fmt> {
475	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
476		self.0(f)
477	}
478}
479
480impl<Fmt: Fn(&mut Formatter) -> fmt::Result> Octal for ComprehensiveFmt<Fmt> {
481	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
482		self.0(f)
483	}
484}
485
486impl<Fmt: Fn(&mut Formatter) -> fmt::Result> Pointer for ComprehensiveFmt<Fmt> {
487	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
488		self.0(f)
489	}
490}
491
492impl<Fmt: Fn(&mut Formatter) -> fmt::Result> UpperExp for ComprehensiveFmt<Fmt> {
493	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
494		self.0(f)
495	}
496}
497
498impl<Fmt: Fn(&mut Formatter) -> fmt::Result> UpperHex for ComprehensiveFmt<Fmt> {
499	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
500		self.0(f)
501	}
502}
503
504/// ```rust
505/// let _: fn_formats::ComprehensiveFmt<_> = (|f: &mut core::fmt::Formatter| Ok(())).into();
506/// ```
507impl<Fmt: Fn(&mut Formatter) -> fmt::Result> From<Fmt> for ComprehensiveFmt<Fmt> {
508	fn from(fmt: Fmt) -> Self {
509		Self(fmt)
510	}
511}
512
513/// Implements all format traits by calling the respective stored closure.
514///
515/// # Example
516///
517/// ```rust
518/// use fn_formats::ComprehensiveFmtSeparate;
519///
520/// let comprehensive = ComprehensiveFmtSeparate {
521///     binary: |f| write!(f, "binary"),
522///     debug: |f| write!(f, "debug"),
523///     display: |f| write!(f, "display"),
524///     lower_exp: |f| write!(f, "lower exp"),
525///     lower_hex: |f| write!(f, "lower hex"),
526///     octal: |f| write!(f, "octal"),
527///     pointer: |f| write!(f, "pointer"),
528///     upper_exp: |f| write!(f, "upper exp"),
529///     upper_hex: |f| write!(f, "upper hex"),
530/// };
531///
532/// assert_eq!(format!("{:b}", comprehensive), "binary");
533/// assert_eq!(format!("{:?}", comprehensive), "debug");
534/// assert_eq!(format!("{}", comprehensive), "display");
535/// assert_eq!(format!("{:e}", comprehensive), "lower exp");
536/// assert_eq!(format!("{:x}", comprehensive), "lower hex");
537/// assert_eq!(format!("{:o}", comprehensive), "octal");
538/// assert_eq!(format!("{:p}", comprehensive), "pointer");
539/// assert_eq!(format!("{:E}", comprehensive), "upper exp");
540/// assert_eq!(format!("{:X}", comprehensive), "upper hex");
541/// ```
542#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Default)]
543pub struct ComprehensiveFmtSeparate<
544	BinaryFmt: Fn(&mut Formatter) -> fmt::Result,
545	DebugFmt: Fn(&mut Formatter) -> fmt::Result,
546	DisplayFmt: Fn(&mut Formatter) -> fmt::Result,
547	LowerExpFmt: Fn(&mut Formatter) -> fmt::Result,
548	LowerHexFmt: Fn(&mut Formatter) -> fmt::Result,
549	OctalFmt: Fn(&mut Formatter) -> fmt::Result,
550	PointerFmt: Fn(&mut Formatter) -> fmt::Result,
551	UpperExpFmt: Fn(&mut Formatter) -> fmt::Result,
552	UpperHexFmt: Fn(&mut Formatter) -> fmt::Result,
553> {
554	pub binary: BinaryFmt,
555	pub debug: DebugFmt,
556	pub display: DisplayFmt,
557	pub lower_exp: LowerExpFmt,
558	pub lower_hex: LowerHexFmt,
559	pub octal: OctalFmt,
560	pub pointer: PointerFmt,
561	pub upper_exp: UpperExpFmt,
562	pub upper_hex: UpperHexFmt,
563}
564
565impl<
566		BinaryFmt: Fn(&mut Formatter) -> fmt::Result,
567		DebugFmt: Fn(&mut Formatter) -> fmt::Result,
568		DisplayFmt: Fn(&mut Formatter) -> fmt::Result,
569		LowerExpFmt: Fn(&mut Formatter) -> fmt::Result,
570		LowerHexFmt: Fn(&mut Formatter) -> fmt::Result,
571		OctalFmt: Fn(&mut Formatter) -> fmt::Result,
572		PointerFmt: Fn(&mut Formatter) -> fmt::Result,
573		UpperExpFmt: Fn(&mut Formatter) -> fmt::Result,
574		UpperHexFmt: Fn(&mut Formatter) -> fmt::Result,
575	> Binary
576	for ComprehensiveFmtSeparate<
577		BinaryFmt,
578		DebugFmt,
579		DisplayFmt,
580		LowerExpFmt,
581		LowerHexFmt,
582		OctalFmt,
583		PointerFmt,
584		UpperExpFmt,
585		UpperHexFmt,
586	>
587{
588	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
589		(self.binary)(f)
590	}
591}
592
593impl<
594		BinaryFmt: Fn(&mut Formatter) -> fmt::Result,
595		DebugFmt: Fn(&mut Formatter) -> fmt::Result,
596		DisplayFmt: Fn(&mut Formatter) -> fmt::Result,
597		LowerExpFmt: Fn(&mut Formatter) -> fmt::Result,
598		LowerHexFmt: Fn(&mut Formatter) -> fmt::Result,
599		OctalFmt: Fn(&mut Formatter) -> fmt::Result,
600		PointerFmt: Fn(&mut Formatter) -> fmt::Result,
601		UpperExpFmt: Fn(&mut Formatter) -> fmt::Result,
602		UpperHexFmt: Fn(&mut Formatter) -> fmt::Result,
603	> Debug
604	for ComprehensiveFmtSeparate<
605		BinaryFmt,
606		DebugFmt,
607		DisplayFmt,
608		LowerExpFmt,
609		LowerHexFmt,
610		OctalFmt,
611		PointerFmt,
612		UpperExpFmt,
613		UpperHexFmt,
614	>
615{
616	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
617		(self.debug)(f)
618	}
619}
620
621impl<
622		BinaryFmt: Fn(&mut Formatter) -> fmt::Result,
623		DebugFmt: Fn(&mut Formatter) -> fmt::Result,
624		DisplayFmt: Fn(&mut Formatter) -> fmt::Result,
625		LowerExpFmt: Fn(&mut Formatter) -> fmt::Result,
626		LowerHexFmt: Fn(&mut Formatter) -> fmt::Result,
627		OctalFmt: Fn(&mut Formatter) -> fmt::Result,
628		PointerFmt: Fn(&mut Formatter) -> fmt::Result,
629		UpperExpFmt: Fn(&mut Formatter) -> fmt::Result,
630		UpperHexFmt: Fn(&mut Formatter) -> fmt::Result,
631	> Display
632	for ComprehensiveFmtSeparate<
633		BinaryFmt,
634		DebugFmt,
635		DisplayFmt,
636		LowerExpFmt,
637		LowerHexFmt,
638		OctalFmt,
639		PointerFmt,
640		UpperExpFmt,
641		UpperHexFmt,
642	>
643{
644	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
645		(self.display)(f)
646	}
647}
648
649impl<
650		BinaryFmt: Fn(&mut Formatter) -> fmt::Result,
651		DebugFmt: Fn(&mut Formatter) -> fmt::Result,
652		DisplayFmt: Fn(&mut Formatter) -> fmt::Result,
653		LowerExpFmt: Fn(&mut Formatter) -> fmt::Result,
654		LowerHexFmt: Fn(&mut Formatter) -> fmt::Result,
655		OctalFmt: Fn(&mut Formatter) -> fmt::Result,
656		PointerFmt: Fn(&mut Formatter) -> fmt::Result,
657		UpperExpFmt: Fn(&mut Formatter) -> fmt::Result,
658		UpperHexFmt: Fn(&mut Formatter) -> fmt::Result,
659	> LowerExp
660	for ComprehensiveFmtSeparate<
661		BinaryFmt,
662		DebugFmt,
663		DisplayFmt,
664		LowerExpFmt,
665		LowerHexFmt,
666		OctalFmt,
667		PointerFmt,
668		UpperExpFmt,
669		UpperHexFmt,
670	>
671{
672	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
673		(self.lower_exp)(f)
674	}
675}
676
677impl<
678		BinaryFmt: Fn(&mut Formatter) -> fmt::Result,
679		DebugFmt: Fn(&mut Formatter) -> fmt::Result,
680		DisplayFmt: Fn(&mut Formatter) -> fmt::Result,
681		LowerExpFmt: Fn(&mut Formatter) -> fmt::Result,
682		LowerHexFmt: Fn(&mut Formatter) -> fmt::Result,
683		OctalFmt: Fn(&mut Formatter) -> fmt::Result,
684		PointerFmt: Fn(&mut Formatter) -> fmt::Result,
685		UpperExpFmt: Fn(&mut Formatter) -> fmt::Result,
686		UpperHexFmt: Fn(&mut Formatter) -> fmt::Result,
687	> LowerHex
688	for ComprehensiveFmtSeparate<
689		BinaryFmt,
690		DebugFmt,
691		DisplayFmt,
692		LowerExpFmt,
693		LowerHexFmt,
694		OctalFmt,
695		PointerFmt,
696		UpperExpFmt,
697		UpperHexFmt,
698	>
699{
700	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
701		(self.lower_hex)(f)
702	}
703}
704
705impl<
706		BinaryFmt: Fn(&mut Formatter) -> fmt::Result,
707		DebugFmt: Fn(&mut Formatter) -> fmt::Result,
708		DisplayFmt: Fn(&mut Formatter) -> fmt::Result,
709		LowerExpFmt: Fn(&mut Formatter) -> fmt::Result,
710		LowerHexFmt: Fn(&mut Formatter) -> fmt::Result,
711		OctalFmt: Fn(&mut Formatter) -> fmt::Result,
712		PointerFmt: Fn(&mut Formatter) -> fmt::Result,
713		UpperExpFmt: Fn(&mut Formatter) -> fmt::Result,
714		UpperHexFmt: Fn(&mut Formatter) -> fmt::Result,
715	> Octal
716	for ComprehensiveFmtSeparate<
717		BinaryFmt,
718		DebugFmt,
719		DisplayFmt,
720		LowerExpFmt,
721		LowerHexFmt,
722		OctalFmt,
723		PointerFmt,
724		UpperExpFmt,
725		UpperHexFmt,
726	>
727{
728	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
729		(self.octal)(f)
730	}
731}
732
733impl<
734		BinaryFmt: Fn(&mut Formatter) -> fmt::Result,
735		DebugFmt: Fn(&mut Formatter) -> fmt::Result,
736		DisplayFmt: Fn(&mut Formatter) -> fmt::Result,
737		LowerExpFmt: Fn(&mut Formatter) -> fmt::Result,
738		LowerHexFmt: Fn(&mut Formatter) -> fmt::Result,
739		OctalFmt: Fn(&mut Formatter) -> fmt::Result,
740		PointerFmt: Fn(&mut Formatter) -> fmt::Result,
741		UpperExpFmt: Fn(&mut Formatter) -> fmt::Result,
742		UpperHexFmt: Fn(&mut Formatter) -> fmt::Result,
743	> Pointer
744	for ComprehensiveFmtSeparate<
745		BinaryFmt,
746		DebugFmt,
747		DisplayFmt,
748		LowerExpFmt,
749		LowerHexFmt,
750		OctalFmt,
751		PointerFmt,
752		UpperExpFmt,
753		UpperHexFmt,
754	>
755{
756	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
757		(self.pointer)(f)
758	}
759}
760
761impl<
762		BinaryFmt: Fn(&mut Formatter) -> fmt::Result,
763		DebugFmt: Fn(&mut Formatter) -> fmt::Result,
764		DisplayFmt: Fn(&mut Formatter) -> fmt::Result,
765		LowerExpFmt: Fn(&mut Formatter) -> fmt::Result,
766		LowerHexFmt: Fn(&mut Formatter) -> fmt::Result,
767		OctalFmt: Fn(&mut Formatter) -> fmt::Result,
768		PointerFmt: Fn(&mut Formatter) -> fmt::Result,
769		UpperExpFmt: Fn(&mut Formatter) -> fmt::Result,
770		UpperHexFmt: Fn(&mut Formatter) -> fmt::Result,
771	> UpperExp
772	for ComprehensiveFmtSeparate<
773		BinaryFmt,
774		DebugFmt,
775		DisplayFmt,
776		LowerExpFmt,
777		LowerHexFmt,
778		OctalFmt,
779		PointerFmt,
780		UpperExpFmt,
781		UpperHexFmt,
782	>
783{
784	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
785		(self.upper_exp)(f)
786	}
787}
788
789impl<
790		BinaryFmt: Fn(&mut Formatter) -> fmt::Result,
791		DebugFmt: Fn(&mut Formatter) -> fmt::Result,
792		DisplayFmt: Fn(&mut Formatter) -> fmt::Result,
793		LowerExpFmt: Fn(&mut Formatter) -> fmt::Result,
794		LowerHexFmt: Fn(&mut Formatter) -> fmt::Result,
795		OctalFmt: Fn(&mut Formatter) -> fmt::Result,
796		PointerFmt: Fn(&mut Formatter) -> fmt::Result,
797		UpperExpFmt: Fn(&mut Formatter) -> fmt::Result,
798		UpperHexFmt: Fn(&mut Formatter) -> fmt::Result,
799	> UpperHex
800	for ComprehensiveFmtSeparate<
801		BinaryFmt,
802		DebugFmt,
803		DisplayFmt,
804		LowerExpFmt,
805		LowerHexFmt,
806		OctalFmt,
807		PointerFmt,
808		UpperExpFmt,
809		UpperHexFmt,
810	>
811{
812	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
813		(self.upper_hex)(f)
814	}
815}
fn_formats/lib.rs

fn_formats/
lib.rs
