named_types/
lib.rs

1//! This crate provides [`Named`], a trait that provides a nice [`core::fmt::Display`]able way to
2//! get a types Name. It is similar to [`core::any::type_name`] without paths, but should
3//! provide a more sensical name for something like `std::io::Error`, which would show up
4//! as `Error` with something like [pretty-type-name](https://crates.io/crates/pretty-type-name),
5//! whereas this crate provides the name `IoError`.
6//!
7//! The names for `std` are given based on the [Duck
8//! Test](https://en.wikipedia.org/wiki/Duck_test), e.g. [`core::slice::Iter`] stays `Iter`
9//! conflicting with something like [`core::option::Iter`] because it behaves like a generic iterator, whereas
10//! `std::io::Error` does not behave like a generic Error but rather is a specific Error type
11//! for io operations.
12//!
13//! Additionally a [`Named`](derive.Named.html) derive macro is provided for deriving the [`Named`] trait. This macro
14//! can be configured by attributing a derived type with `#[named(...)]`. The following options can
15//! be passed to the attribute:
16//!
17//!  * `rename = "..."` to change the types name.
18//!  * `format = "..."` to use a custom format string that accepts all non-ignored generic.
19//!  Overrides `rename = "..."`
20//!  parameters to format the types name.
21//!  * `ignore_all` to ignore all generic parameters.
22//!  * `ignore = ...` to ignore a generic parameter.
23//!  * `passthrough = ...` to use the [`Named`] implementation of a generic parameter. Takes
24//!  priority over other options.
25//! 
26//! To configure multiple options repeat the `#[named(...)]` attribute.
27//!
28//! ## Feature flags
29#![doc = document_features::document_features!()]
30
31#![cfg_attr(not(feature = "std"), no_std)]
32
33/// Derives the [`Named`] trait.
34pub use named_types_derive::Named;
35
36mod stdlib;
37use crate::stdlib::*;
38
39/// Like [`core::fmt::Display`] or [`Debug`] but for type names and generic type names.
40pub trait Named {
41    /// A constant way to [`core::fmt::Display`] the Nameds type name.
42    const NAME: Name = Name(Self::format_name);
43
44    /// Formats the name of the Self type.
45    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result;
46}
47
48/// The name of a type
49#[derive(Copy, Clone)]
50pub struct Name(pub fn(&mut stdlib::fmt::Formatter<'_>) -> stdlib::fmt::Result);
51
52impl stdlib::fmt::Debug for Name {
53    #[inline]
54    fn fmt(&self, f: &mut stdlib::fmt::Formatter<'_>) -> stdlib::fmt::Result {
55        stdlib::fmt::Display::fmt(self, f)
56    }
57}
58
59impl stdlib::fmt::Display for Name {
60    #[inline]
61    fn fmt(&self, f: &mut stdlib::fmt::Formatter<'_>) -> stdlib::fmt::Result {
62        self.0(f)
63    }
64}
65
66macro_rules! simple_impl {
67    ($simple:ty => $name:expr) => {
68        impl $crate::Named for $simple {
69            #[inline]
70            fn format_name(
71                f: &mut $crate::stdlib::fmt::Formatter<'_>,
72            ) -> $crate::stdlib::fmt::Result {
73                write!(f, $name)
74            }
75        }
76    };
77}
78
79macro_rules! simple_trait_impl {
80    ($simple:ty => $name:expr) => {
81        impl $crate::Named for $simple {
82            #[inline]
83            fn format_name(
84                f: &mut $crate::stdlib::fmt::Formatter<'_>,
85            ) -> $crate::stdlib::fmt::Result {
86                write!(f, concat!("dyn ", $name))
87            }
88        }
89    };
90}
91
92macro_rules! simple_container_impl {
93    (impl<$ig:ident$(: $first_gd:ident$( + $gd:ident)*)?> $type:ty => $name:expr) => {
94        impl<$ig$(: $first_gd$( + $gd)*)?> $crate::Named for $type where $ig: $crate::Named {
95            #[inline]
96            fn format_name(f: &mut $crate::stdlib::fmt::Formatter<'_>) -> $crate::stdlib::fmt::Result {
97                write!(f, concat!($name, "<{}>"), $ig::NAME)
98            }
99        }
100    };
101}
102
103macro_rules! simple_map_impl {
104    (impl<$key_generic:ident$(: $first_key_gd:ident$( + $key_gd:ident)*)?, $value_generic:ident$(: $first_value_gd:ident$( + $value_gd:ident)*)?> $type:ty => $name:expr) => {
105        impl<$key_generic$(: $first_key_gd$( + $key_gd)*)?, $value_generic$(: $first_value_gd$( + $value_gd)*)?> $crate::Named for $type where $key_generic: $crate::Named, $value_generic: $crate::Named {
106            #[inline]
107            fn format_name(f: &mut $crate::stdlib::fmt::Formatter<'_>) -> $crate::stdlib::fmt::Result {
108                write!(f, concat!($name, "<{}, {}>"), $key_generic::NAME, $value_generic::NAME)
109            }
110        }
111    };
112}
113
114macro_rules! tuple_impl {
115    ($(($leading_name:ident$(, $name:ident)*))*$(,)?) => {
116        $(
117            impl<$leading_name: $crate::Named, $($name: $crate::Named), *> $crate::Named for ($leading_name, $($name), *) {
118                #[inline]
119                fn format_name(f: &mut $crate::stdlib::fmt::Formatter<'_>) -> $crate::stdlib::fmt::Result {
120                    write!(f, "({}", $leading_name::NAME)?;
121                    $(write!(f, ", {}", $name::NAME)?;)*
122                    write!(f, ")")
123                }
124            }
125        )+
126    };
127}
128
129macro_rules! deref_impl {
130    (impl <$($desc:tt)+) => {
131        impl <$($desc)+ where T: $crate::Named {
132            const NAME: $crate::Name = T::NAME;
133
134            #[inline]
135            fn format_name(f: &mut $crate::stdlib::fmt::Formatter<'_>) -> $crate::stdlib::fmt::Result {
136                T::format_name(f)
137            }
138        }
139    };
140}
141
142macro_rules! simple_op_trait_impl {
143    ($type:ty = $type_assign:ty => $name:expr, $op:expr) => {
144        impl<Rhs, Output> Named for $type
145        where
146            Rhs: Named,
147            Output: Named,
148        {
149            #[inline]
150            fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
151                write!(
152                    f,
153                    concat!("dyn ", $name, " ", $op, " {} = {}"),
154                    Rhs::NAME,
155                    Output::NAME
156                )
157            }
158        }
159
160        impl<Rhs> Named for $type_assign
161        where
162            Rhs: Named,
163        {
164            #[inline]
165            fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
166                write!(f, concat!("dyn ", $name, "Assign ", $op, "= {}"), Rhs::NAME)
167            }
168        }
169    };
170}
171
172// ==== Primitive Types ====
173
174// ---- array ----
175
176impl<T: Named, const N: usize> Named for [T; N] {
177    #[inline]
178    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
179        write!(f, "[{}; {}]", T::NAME, N)
180    }
181}
182
183simple_impl!(bool => "bool");
184simple_impl!(char => "char");
185simple_impl!(f32 => "f32");
186simple_impl!(f64 => "f64");
187simple_impl!(i8 => "i8");
188simple_impl!(i16 => "i16");
189simple_impl!(i32 => "i32");
190simple_impl!(i64 => "i64");
191simple_impl!(i128 => "i128");
192simple_impl!(isize => "isize");
193
194// ---- pointer ----
195
196deref_impl!(impl<T: ?Sized> Named for *const T);
197deref_impl!(impl<T: ?Sized> Named for *mut T);
198
199// ---- reference ----
200
201deref_impl!(impl<'a, T: ?Sized> Named for &'a T);
202deref_impl!(impl<'a, T: ?Sized> Named for &'a mut T);
203
204// ---- slice ----
205
206impl<T: Named> Named for [T] {
207    #[inline]
208    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
209        write!(f, "[{}]", T::NAME)
210    }
211}
212
213simple_impl!(str => "str");
214
215tuple_impl!(
216    (T0)(T0, T1)(T0, T1, T2)(T0, T1, T2, T3)(T0, T1, T2, T3, T4)(T0, T1, T2, T3, T4, T5)(
217        T0, T1, T2, T3, T4, T5, T6
218    )(T0, T1, T2, T3, T4, T5, T6, T7)(T0, T1, T2, T3, T4, T5, T6, T7, T8)(
219        T0, T1, T2, T3, T4, T5, T6, T7, T8, T9
220    )(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)(
221        T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11
222    )(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)(
223        T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13
224    )(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)(
225        T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15
226    )
227);
228
229simple_impl!(u8 => "u8");
230simple_impl!(u16 => "u16");
231simple_impl!(u32 => "u32");
232simple_impl!(u64 => "u64");
233simple_impl!(u128 => "u128");
234simple_impl!(() => "()");
235simple_impl!(usize => "usize");
236
237// ==== {std, alloc, core}::alloc ====
238
239// ---- structs ----
240
241simple_impl!(alloc::Layout => "AllocLayout");
242simple_impl!(alloc::LayoutError => "AllocLayoutError");
243#[cfg(feature = "std")]
244simple_impl!(alloc::System => "SystemAlloc");
245
246// ---- traits ----
247simple_trait_impl!(dyn alloc::GlobalAlloc => "GlobalAlloc");
248
249// ==== {std, core}::any ====
250
251// ---- structs ----
252
253simple_impl!(any::TypeId => "TypeId");
254
255// ---- traits ----
256
257simple_trait_impl!(dyn any::Any => "Any");
258
259// ==== {std, core}::any ====
260
261// ---- structs ----
262
263impl<T, const N: usize> Named for array::IntoIter<T, N>
264where
265    T: Named,
266{
267    #[inline]
268    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
269        write!(f, "IntoIter<{}, {}>", T::NAME, N)
270    }
271}
272
273// ==== {std, core}::ascii ====
274
275// ---- structs ----
276
277simple_impl!(ascii::EscapeDefault => "EscapeDefault");
278
279// ==== std::backtrace ====
280
281// ---- structs ----
282
283#[cfg(all(feature = "std", feature = "rust-1-65-0"))]
284simple_impl!(backtrace::Backtrace => "Backtrace");
285
286// ---- enums ----
287
288#[cfg(all(feature = "std", feature = "rust-1-65-0"))]
289simple_impl!(backtrace::BacktraceStatus => "BacktraceStatus");
290
291// ==== {std, alloc, core}::borrow ====
292
293// ---- enums ----
294
295#[cfg(any(feature = "std", feature = "alloc"))]
296impl<B: borrow::ToOwned + ?Sized> Named for borrow::Cow<'_, B>
297where
298    B: Named,
299{
300    #[inline]
301    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
302        write!(f, "{}", B::NAME)
303    }
304}
305
306// ---- traits ----
307
308impl<Borrowed: ?Sized> Named for dyn borrow::Borrow<Borrowed>
309where
310    Borrowed: Named,
311{
312    #[inline]
313    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
314        write!(f, "{}", Borrowed::NAME)
315    }
316}
317
318impl<Borrowed: ?Sized> Named for dyn borrow::BorrowMut<Borrowed>
319where
320    Borrowed: Named,
321{
322    #[inline]
323    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
324        write!(f, "{}", Borrowed::NAME)
325    }
326}
327
328// ==== {std, alloc}::boxed ====
329
330// ---- structs ----
331
332#[cfg(any(feature = "std", feature = "alloc"))]
333deref_impl!(impl<T: ?Sized> Named for boxed::Box<T>);
334
335// ==== {std, core}::cell ====
336
337// ---- structs ----
338
339simple_impl!(cell::BorrowError => "BorrowError");
340simple_impl!(cell::BorrowMutError => "BorrowMutError");
341deref_impl!(impl<T: ?Sized> Named for cell::Cell<T>);
342#[cfg(feature = "rust-1-70-0")]
343deref_impl!(impl<T> Named for cell::OnceCell<T>);
344deref_impl!(impl<'b, T: ?Sized> Named for cell::Ref<'b, T>);
345deref_impl!(impl<T: ?Sized> Named for cell::RefCell<T>);
346deref_impl!(impl<'b, T: ?Sized> Named for cell::RefMut<'b, T>);
347deref_impl!(impl<T: ?Sized> Named for cell::UnsafeCell<T>);
348
349// ==== {std, core}::char ====
350
351// ---- structs ----
352
353simple_impl!(char::CharTryFromError => "CharTryFromError");
354
355impl<I: Iterator<Item = u16>> Named for char::DecodeUtf16<I>
356where
357    I: Named,
358{
359    #[inline]
360    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
361        write!(f, "DecodeUtf16<from {}>", I::NAME)
362    }
363}
364
365simple_impl!(char::DecodeUtf16Error => "DecodeUtf16Error");
366simple_impl!(char::EscapeDebug => "EscapeDebug");
367simple_impl!(char::EscapeDefault => "EscapeDefault");
368simple_impl!(char::EscapeUnicode => "EscapeUnicode");
369simple_impl!(char::ParseCharError => "ParseCharError");
370simple_impl!(char::ToLowercase => "ToLowercase");
371simple_impl!(char::ToUppercase => "ToUppercase");
372#[cfg(feature = "rust-1-59-0")]
373simple_impl!(char::TryFromCharError => "TryFromCharError");
374
375// ==== {std, core}::cmp ====
376
377// ---- structs ----
378
379simple_container_impl!(impl<T> cmp::Reverse<T> => "Reverse");
380
381// ---- enums ----
382
383simple_impl!(cmp::Ordering => "Ordering");
384
385// ---- traits ----
386
387impl<Rhs: ?Sized> Named for dyn cmp::PartialEq<Rhs>
388where
389    Rhs: Named,
390{
391    #[inline]
392    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
393        write!(f, "dyn PartialEq<{}>", Rhs::NAME)
394    }
395}
396
397impl<Rhs: ?Sized> Named for dyn PartialOrd<Rhs>
398where
399    Rhs: Named,
400{
401    #[inline]
402    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
403        write!(f, "dyn PartialOrd<{}>", Rhs::NAME)
404    }
405}
406
407// ==== {std, alloc}::collections ====
408
409// ---- structs ----
410
411#[cfg(any(feature = "std", feature = "alloc"))]
412simple_container_impl!(impl<T: Ord> collections::binary_heap::BinaryHeap<T> => "BinaryHeap");
413#[cfg(any(feature = "std", feature = "alloc"))]
414simple_container_impl!(impl<T> collections::binary_heap::Drain<'_, T> => "Drain");
415#[cfg(any(feature = "std", feature = "alloc"))]
416simple_container_impl!(impl<T> collections::binary_heap::IntoIter<T> => "IntoIter");
417#[cfg(any(feature = "std", feature = "alloc"))]
418simple_container_impl!(impl<T> collections::binary_heap::Iter<'_, T> => "Iter");
419#[cfg(any(feature = "std", feature = "alloc"))]
420simple_container_impl!(impl<T: Ord> collections::binary_heap::PeekMut<'_, T> => "PeekMut");
421
422#[cfg(any(feature = "std", feature = "alloc"))]
423simple_map_impl!(impl<K, V> collections::btree_map::BTreeMap<K, V> => "BTreeMap");
424#[cfg(any(feature = "std", feature = "alloc"))]
425simple_map_impl!(impl<K, V> collections::btree_map::IntoIter<K, V> => "IntoIter");
426#[cfg(all(any(feature = "std", feature = "alloc"), feature = "rust-1-54-0"))]
427simple_map_impl!(impl<K, V> collections::btree_map::IntoKeys<K, V> => "IntoKeys");
428#[cfg(all(any(feature = "std", feature = "alloc"), feature = "rust-1-54-0"))]
429simple_map_impl!(impl<K, V> collections::btree_map::IntoValues<K, V> => "IntoValues");
430#[cfg(any(feature = "std", feature = "alloc"))]
431simple_map_impl!(impl<K, V> collections::btree_map::Iter<'_, K, V> => "Iter");
432#[cfg(any(feature = "std", feature = "alloc"))]
433simple_map_impl!(impl<K, V> collections::btree_map::IterMut<'_, K, V> => "IterMut");
434#[cfg(any(feature = "std", feature = "alloc"))]
435simple_map_impl!(impl<K, V> collections::btree_map::Keys<'_, K, V> => "Keys");
436#[cfg(any(feature = "std", feature = "alloc"))]
437simple_map_impl!(impl<K, V> collections::btree_map::OccupiedEntry<'_, K, V> => "OccupiedEntry");
438#[cfg(any(feature = "std", feature = "alloc"))]
439simple_map_impl!(impl<K, V> collections::btree_map::Range<'_, K, V> => "Range");
440#[cfg(any(feature = "std", feature = "alloc"))]
441simple_map_impl!(impl<K, V> collections::btree_map::RangeMut<'_, K, V> => "RangeMut");
442#[cfg(any(feature = "std", feature = "alloc"))]
443simple_map_impl!(impl<K, V> collections::btree_map::VacantEntry<'_, K, V> => "VacantEntry");
444#[cfg(any(feature = "std", feature = "alloc"))]
445simple_map_impl!(impl<K, V> collections::btree_map::Values<'_, K, V> => "Values");
446#[cfg(any(feature = "std", feature = "alloc"))]
447simple_map_impl!(impl<K, V> collections::btree_map::ValuesMut<'_, K, V> => "ValuesMut");
448
449#[cfg(any(feature = "std", feature = "alloc"))]
450simple_container_impl!(impl<T> collections::btree_set::BTreeSet<T> => "BTreeSet");
451#[cfg(any(feature = "std", feature = "alloc"))]
452simple_container_impl!(impl<T> collections::btree_set::Difference<'_, T> => "Difference");
453#[cfg(any(feature = "std", feature = "alloc"))]
454simple_container_impl!(impl<T> collections::btree_set::Intersection<'_, T> => "Intersection");
455#[cfg(any(feature = "std", feature = "alloc"))]
456simple_container_impl!(impl<T> collections::btree_set::IntoIter<T> => "IntoIter");
457#[cfg(any(feature = "std", feature = "alloc"))]
458simple_container_impl!(impl<T> collections::btree_set::Iter<'_, T> => "Iter");
459#[cfg(any(feature = "std", feature = "alloc"))]
460simple_container_impl!(impl<T> collections::btree_set::Range<'_, T> => "Range");
461#[cfg(any(feature = "std", feature = "alloc"))]
462simple_container_impl!(impl<T> collections::btree_set::SymmetricDifference<'_, T> => "SymmetricDifference");
463#[cfg(any(feature = "std", feature = "alloc"))]
464simple_container_impl!(impl<T> collections::btree_set::Union<'_, T> => "Union");
465
466#[cfg(feature = "std")]
467simple_map_impl!(impl<K, V> collections::hash_map::HashMap<K, V> => "HashMap");
468#[cfg(feature = "std")]
469simple_impl!(collections::hash_map::DefaultHasher => "DefaultHasher");
470#[cfg(feature = "std")]
471simple_map_impl!(impl<K, V> collections::hash_map::Drain<'_, K, V> => "Drain");
472#[cfg(feature = "std")]
473simple_map_impl!(impl<K, V> collections::hash_map::IntoIter<K, V> => "IntoIter");
474#[cfg(all(feature = "std", feature = "rust-1-54-0"))]
475simple_map_impl!(impl<K, V> collections::hash_map::IntoKeys<K, V> => "IntoKeys");
476#[cfg(all(feature = "std", feature = "rust-1-54-0"))]
477simple_map_impl!(impl<K, V> collections::hash_map::IntoValues<K, V> => "IntoValues");
478#[cfg(feature = "std")]
479simple_map_impl!(impl<K, V> collections::hash_map::Iter<'_, K, V> => "Iter");
480#[cfg(feature = "std")]
481simple_map_impl!(impl<K, V> collections::hash_map::IterMut<'_, K, V> => "IterMut");
482#[cfg(feature = "std")]
483simple_map_impl!(impl<K, V> collections::hash_map::Keys<'_, K, V> => "Keys");
484#[cfg(feature = "std")]
485simple_map_impl!(impl<K, V> collections::hash_map::OccupiedEntry<'_, K, V> => "OccupiedEntry");
486#[cfg(feature = "std")]
487simple_impl!(collections::hash_map::RandomState => "RandomState");
488#[cfg(feature = "std")]
489simple_map_impl!(impl<K, V> collections::hash_map::VacantEntry<'_, K, V> => "VacantEntry");
490#[cfg(feature = "std")]
491simple_map_impl!(impl<K, V> collections::hash_map::Values<'_, K, V> => "Values");
492#[cfg(feature = "std")]
493simple_map_impl!(impl<K, V> collections::hash_map::ValuesMut<'_, K, V> => "ValuesMut");
494
495#[cfg(feature = "std")]
496simple_container_impl!(impl<T> collections::hash_set::HashSet<T> => "HashSet");
497#[cfg(feature = "std")]
498simple_map_impl!(impl<T, S> collections::hash_set::Difference<'_, T, S> => "Difference");
499#[cfg(feature = "std")]
500simple_container_impl!(impl<K> collections::hash_set::Drain<'_, K> => "Drain");
501#[cfg(feature = "std")]
502simple_map_impl!(impl<T, S> collections::hash_set::Intersection<'_, T, S> => "Intersection");
503#[cfg(feature = "std")]
504simple_container_impl!(impl<K> collections::hash_set::IntoIter<K> => "IntoIter");
505#[cfg(feature = "std")]
506simple_container_impl!(impl<K> collections::hash_set::Iter<'_, K> => "Iter");
507#[cfg(feature = "std")]
508simple_map_impl!(impl<T, S> collections::hash_set::SymmetricDifference<'_, T, S> => "SymmetricDifference");
509#[cfg(feature = "std")]
510simple_map_impl!(impl<T, S> collections::hash_set::Union<'_, T, S> => "Union");
511
512#[cfg(any(feature = "std", feature = "alloc"))]
513simple_container_impl!(impl<T> collections::linked_list::LinkedList<T> => "LinkedList");
514#[cfg(any(feature = "std", feature = "alloc"))]
515simple_container_impl!(impl<T> collections::linked_list::IntoIter<T> => "IntoIter");
516#[cfg(any(feature = "std", feature = "alloc"))]
517simple_container_impl!(impl<T> collections::linked_list::Iter<'_, T> => "Iter");
518#[cfg(any(feature = "std", feature = "alloc"))]
519simple_container_impl!(impl<T> collections::linked_list::IterMut<'_, T> => "IterMut");
520
521#[cfg(any(feature = "std", feature = "alloc"))]
522simple_container_impl!(impl<T> collections::vec_deque::VecDeque<T> => "VecDeque");
523#[cfg(any(feature = "std", feature = "alloc"))]
524simple_container_impl!(impl<T> collections::vec_deque::Drain<'_, T> => "Drain");
525#[cfg(any(feature = "std", feature = "alloc"))]
526simple_container_impl!(impl<T> collections::vec_deque::IntoIter<T> => "IntoIter");
527#[cfg(any(feature = "std", feature = "alloc"))]
528simple_container_impl!(impl<T> collections::vec_deque::Iter<'_, T> => "Iter");
529#[cfg(any(feature = "std", feature = "alloc"))]
530simple_container_impl!(impl<T> collections::vec_deque::IterMut<'_, T> => "IterMut");
531
532#[cfg(any(feature = "std", feature = "alloc"))]
533#[cfg(feature = "rust-1-57-0")]
534simple_impl!(collections::TryReserveError => "TryReserveError");
535
536// ---- enums ----
537
538#[cfg(any(feature = "std", feature = "alloc"))]
539simple_map_impl!(impl<K, V> collections::btree_map::Entry<'_, K, V> => "Entry");
540#[cfg(feature = "std")]
541simple_map_impl!(impl<K, V> collections::hash_map::Entry<'_, K, V> => "Entry");
542
543// ==== {std,core}::convert ====
544
545// ---- enums ----
546
547simple_impl!(convert::Infallible => "Infallible");
548
549// ---- traits ----
550
551deref_impl!(impl<T: ?Sized> Named for dyn convert::AsMut<T>);
552deref_impl!(impl<T: ?Sized> Named for dyn convert::AsRef<T>);
553
554// ==== std::env ====
555
556// ---- structs ----
557
558#[cfg(feature = "std")]
559simple_impl!(env::Args => "MainArgs");
560#[cfg(feature = "std")]
561simple_impl!(env::ArgsOs => "MainArgsOs");
562#[cfg(feature = "std")]
563simple_impl!(env::JoinPathsError => "JoinPathsError");
564
565#[cfg(feature = "std")]
566simple_impl!(env::SplitPaths<'_> => "SplitPaths");
567
568#[cfg(feature = "std")]
569simple_impl!(env::Vars => "EnvVars");
570#[cfg(feature = "std")]
571simple_impl!(env::VarsOs => "EnvVarsOs");
572
573// ---- enums ----
574
575#[cfg(feature = "std")]
576simple_impl!(env::VarError => "EnvVarError");
577
578// ==== error ====
579
580// ---- traits ----
581
582#[cfg(feature = "std")]
583simple_trait_impl!(dyn error::Error => "Error");
584
585// ==== {std,alloc,core}::ffi ====
586
587// ---- structs ----
588
589simple_impl!(ffi::CStr => "CStr");
590#[cfg(any(feature = "std", feature = "alloc"))]
591simple_impl!(ffi::CString => "CString");
592#[cfg(not(feature = "std"))]
593simple_impl!(ffi::FromBytesUntilNulError => "FromBytesUntilNullError");
594simple_impl!(ffi::FromBytesWithNulError => "FromBytesWithNulError");
595#[cfg(any(feature = "std", feature = "alloc"))]
596simple_impl!(ffi::FromVecWithNulError => "FromVecWithNulError");
597#[cfg(any(feature = "std", feature = "alloc"))]
598simple_impl!(ffi::IntoStringError => "IntoStringError");
599#[cfg(any(feature = "std", feature = "alloc"))]
600simple_impl!(ffi::NulError => "NulError");
601#[cfg(feature = "std")]
602simple_impl!(ffi::OsStr => "OsStr");
603#[cfg(feature = "std")]
604simple_impl!(ffi::OsString => "OsString");
605
606// ---- enums ----
607
608simple_impl!(ffi::c_void => "c_void");
609
610// ==== {std,alloc,core}::fmt ====
611
612// ---- structs ----
613
614simple_impl!(fmt::Arguments<'_> => "FormatArguments");
615simple_impl!(fmt::DebugList<'_, '_> => "FormatDebugList");
616simple_impl!(fmt::DebugMap<'_, '_> => "FormatDebugMap");
617simple_impl!(fmt::DebugSet<'_, '_> => "FormatDebugSet");
618simple_impl!(fmt::DebugStruct<'_, '_> => "FormatDebugStruct");
619simple_impl!(fmt::DebugTuple<'_, '_> => "FormatDebugTuple");
620simple_impl!(fmt::Error => "FormatError");
621simple_impl!(fmt::Formatter<'_> => "FormatFormatter");
622
623// ---- enums ----
624
625simple_impl!(fmt::Alignment => "FormatAlignment");
626
627// ---- traits ----
628
629simple_trait_impl!(dyn fmt::Binary => "FormatAsBinary");
630simple_trait_impl!(dyn fmt::Debug => "Debug");
631simple_trait_impl!(dyn fmt::Display => "Display");
632simple_trait_impl!(dyn fmt::LowerExp => "FormatAsLowerExp");
633simple_trait_impl!(dyn fmt::LowerHex => "FormatAsLowerHex");
634simple_trait_impl!(dyn fmt::Octal => "FormatAsOctal");
635simple_trait_impl!(dyn fmt::Pointer => "FormatAsPointer");
636simple_trait_impl!(dyn fmt::UpperExp => "FormatAsUpperExp");
637simple_trait_impl!(dyn fmt::UpperHex => "FormatAsUpperHex");
638simple_trait_impl!(dyn fmt::Write => "FormatWrite");
639
640// ==== std::fs ====
641
642// ---- structs ----
643
644#[cfg(feature = "std")]
645simple_impl!(fs::DirBuilder => "DirBuilder");
646#[cfg(feature = "std")]
647simple_impl!(fs::DirEntry => "DirEntry");
648#[cfg(feature = "std")]
649simple_impl!(fs::File => "File");
650#[cfg(feature = "std")]
651simple_impl!(fs::FileType => "FileType");
652#[cfg(feature = "std")]
653simple_impl!(fs::Metadata => "FileMetadata");
654#[cfg(feature = "std")]
655simple_impl!(fs::OpenOptions => "FileOpenOptions");
656#[cfg(feature = "std")]
657simple_impl!(fs::Permissions => "FilePermissions");
658#[cfg(feature = "std")]
659simple_impl!(fs::ReadDir => "ReadDir");
660
661// ==== {std,core}::future ====
662
663// ---- structs ----
664
665simple_container_impl!(impl<T> future::Pending<T> => "Pending");
666#[cfg(feature = "rust-1-64-0")]
667simple_container_impl!(impl<T> future::PollFn<T> => "PollFn");
668simple_container_impl!(impl<T> future::Ready<T> => "Ready");
669
670// ---- traits ----
671
672impl<Output> Named for dyn future::Future<Output = Output>
673where
674    Output: Named,
675{
676    #[inline]
677    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
678        write!(f, "dyn Future<Output = {}>", Output::NAME)
679    }
680}
681
682#[cfg(feature = "rust-1-64-0")]
683impl<Output, IntoFuture: future::Future<Output = Output>> Named
684    for dyn future::IntoFuture<Output = Output, IntoFuture = IntoFuture>
685where
686    Output: Named,
687    IntoFuture: Named,
688{
689    #[inline]
690    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
691        write!(
692            f,
693            "dyn IntoFuture<Output = {}, IntoFuture = {}>",
694            Output::NAME,
695            IntoFuture::NAME
696        )
697    }
698}
699
700// ==== {std,core}::hash ====
701
702// ---- structs ----
703
704simple_container_impl!(impl<H> hash::BuildHasherDefault<H> => "BuildHasherDefault");
705
706// ---- traits ----
707
708impl<H: hash::Hasher> Named for dyn hash::BuildHasher<Hasher = H>
709where
710    H: Named,
711{
712    #[inline]
713    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
714        write!(f, "dyn BuildHasher<Hasher = {}>", H::NAME)
715    }
716}
717
718simple_trait_impl!(dyn hash::Hasher => "Hasher");
719
720// ==== std::io ====
721
722// ---- structs ----
723
724#[cfg(feature = "std")]
725simple_container_impl!(impl<R> io::BufReader<R> => "BufReader");
726
727#[cfg(feature = "std")]
728impl<R: io::Write> Named for io::BufWriter<R>
729where
730    R: Named,
731{
732    #[inline]
733    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
734        write!(f, concat!("BufWriter", "<{}>"), R::NAME)
735    }
736}
737
738#[cfg(feature = "std")]
739simple_container_impl!(impl<R> io::Bytes<R> => "Bytes");
740
741#[cfg(feature = "std")]
742simple_map_impl!(impl<T, U> io::Chain<T, U> => "Chain");
743
744#[cfg(feature = "std")]
745simple_container_impl!(impl<R> io::Cursor<R> => "Cursor");
746#[cfg(feature = "std")]
747simple_impl!(io::Empty => "Empty");
748#[cfg(feature = "std")]
749simple_impl!(io::Error => "IoError");
750#[cfg(feature = "std")]
751simple_container_impl!(impl<W> io::IntoInnerError<W> => "IntoInnerError");
752#[cfg(feature = "std")]
753simple_impl!(io::IoSlice<'_> => "IoSlice");
754#[cfg(feature = "std")]
755simple_impl!(io::IoSliceMut<'_> => "IoSliceMut");
756
757#[cfg(feature = "std")]
758impl<W: io::Write> Named for io::LineWriter<W>
759where
760    W: Named,
761{
762    #[inline]
763    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
764        write!(f, "LineWriter<{}>", W::NAME)
765    }
766}
767
768#[cfg(feature = "std")]
769simple_container_impl!(impl<B> io::Lines<B> => "Lines");
770#[cfg(feature = "std")]
771simple_impl!(io::Repeat => "Repeat");
772#[cfg(feature = "std")]
773simple_impl!(io::Sink => "Sink");
774#[cfg(feature = "std")]
775simple_container_impl!(impl<B> io::Split<B> => "Split");
776#[cfg(feature = "std")]
777simple_impl!(io::Stderr => "Stderr");
778#[cfg(feature = "std")]
779simple_impl!(io::StderrLock<'_> => "StderrLock");
780#[cfg(feature = "std")]
781simple_impl!(io::Stdin => "Stdin");
782#[cfg(feature = "std")]
783simple_impl!(io::StdinLock<'_> => "StdinLock");
784#[cfg(feature = "std")]
785simple_impl!(io::Stdout => "Stdout");
786#[cfg(feature = "std")]
787simple_impl!(io::StdoutLock<'_> => "StdoutLock");
788#[cfg(feature = "std")]
789simple_container_impl!(impl<T> io::Take<T> => "Take");
790#[cfg(all(feature = "std", feature = "rust-1-56-0"))]
791simple_impl!(io::WriterPanicked => "WriterPanicked");
792
793// ---- enums ----
794
795#[cfg(feature = "std")]
796simple_impl!(io::ErrorKind => "IoErrorKind");
797#[cfg(feature = "std")]
798simple_impl!(io::SeekFrom => "SeekFrom");
799
800// ---- traits ----
801
802#[cfg(feature = "std")]
803simple_trait_impl!(dyn io::BufRead => "BufRead");
804#[cfg(feature = "std")]
805simple_trait_impl!(dyn io::IsTerminal => "IsTerminal");
806#[cfg(feature = "std")]
807simple_trait_impl!(dyn io::Read => "Read");
808#[cfg(feature = "std")]
809simple_trait_impl!(dyn io::Seek => "Seek");
810#[cfg(feature = "std")]
811simple_trait_impl!(dyn io::Write => "Write");
812
813// ==== {std,core}::iter ====
814
815simple_map_impl!(impl<A, B> iter::Chain<A, B> => "Chain");
816simple_container_impl!(impl<I> iter::Cloned<I> => "Cloned");
817simple_container_impl!(impl<I> iter::Copied<I> => "Copied");
818simple_container_impl!(impl<I> iter::Cycle<I> => "Cycle");
819simple_container_impl!(impl<T> iter::Empty<T> => "Empty");
820simple_container_impl!(impl<I> iter::Enumerate<I> => "Enumerate");
821simple_map_impl!(impl<I, P> iter::Filter<I, P> => "Filter");
822simple_map_impl!(impl<I, P> iter::FilterMap<I, P> => "FilterMap");
823
824impl<I, U: IntoIterator, P> Named for iter::FlatMap<I, U, P>
825where
826    I: Named,
827    U: Named,
828    P: Named,
829{
830    #[inline]
831    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
832        write!(f, "FilterMap<{}, {}, {}>", I::NAME, U::NAME, P::NAME)
833    }
834}
835
836impl<Item: Iterator, I: Iterator<Item = Item>> Named for iter::Flatten<I>
837where
838    I: Named,
839{
840    #[inline]
841    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
842        write!(f, "Flatten<{}>", I::NAME)
843    }
844}
845
846simple_container_impl!(impl<F> iter::FromFn<F> => "iter::FromFn");
847simple_container_impl!(impl<I> iter::Fuse<I> => "iter::Fuse");
848
849impl<I, F> Named for iter::Inspect<I, F>
850where
851    I: Named,
852{
853    #[inline]
854    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
855        write!(f, "Inspect<{}>", I::NAME)
856    }
857}
858
859impl<I, F> Named for iter::Map<I, F>
860where
861    I: Named,
862{
863    #[inline]
864    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
865        write!(f, "Map<{}>", I::NAME)
866    }
867}
868
869#[cfg(feature = "rust-1-57-0")]
870impl<I, F> Named for iter::MapWhile<I, F>
871where
872    I: Named,
873{
874    #[inline]
875    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
876        write!(f, "MapWhile<{}>", I::NAME)
877    }
878}
879
880simple_container_impl!(impl<T> iter::Once<T> => "Once");
881simple_container_impl!(impl<T> iter::OnceWith<T> => "OnceWith");
882simple_container_impl!(impl<I: Iterator> iter::Peekable<I> => "Peekable");
883simple_container_impl!(impl<A> iter::Repeat<A> => "Repeat");
884
885impl<F> Named for iter::RepeatWith<F> {
886    #[inline]
887    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
888        write!(f, "RepeatWith")
889    }
890}
891
892simple_container_impl!(impl<T> iter::Rev<T> => "Rev");
893
894impl<I, St, F> Named for iter::Scan<I, St, F>
895where
896    I: Named,
897    St: Named,
898{
899    #[inline]
900    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
901        write!(f, "Scan<{}, {}>", I::NAME, St::NAME)
902    }
903}
904
905simple_container_impl!(impl<I> iter::Skip<I> => "Skip");
906
907impl<I, P> Named for iter::SkipWhile<I, P>
908where
909    I: Named,
910{
911    #[inline]
912    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
913        write!(f, "SkipWhile<{}>", I::NAME)
914    }
915}
916
917simple_container_impl!(impl<I> iter::StepBy<I> => "StepBy");
918
919impl<T, F> Named for iter::Successors<T, F>
920where
921    T: Named,
922{
923    #[inline]
924    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
925        write!(f, "Successors<{}>", T::NAME)
926    }
927}
928
929simple_container_impl!(impl<I> iter::Take<I> => "Take");
930
931impl<I, P> Named for iter::TakeWhile<I, P>
932where
933    I: Named,
934{
935    #[inline]
936    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
937        write!(f, "TakeWhile<{}>", I::NAME)
938    }
939}
940
941simple_map_impl!(impl<A, B> iter::Zip<A, B> => "Zip");
942
943// ---- traits ----
944
945impl<Item> Named for dyn iter::DoubleEndedIterator<Item = Item>
946where
947    Item: Named,
948{
949    #[inline]
950    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
951        write!(f, "dyn DoubleEndedIterator<Item = {}>", Item::NAME)
952    }
953}
954
955impl<Item> Named for dyn iter::ExactSizeIterator<Item = Item>
956where
957    Item: Named,
958{
959    #[inline]
960    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
961        write!(f, "dyn ExactSizeIterator<Item = {}>", Item::NAME)
962    }
963}
964
965impl<Item> Named for dyn iter::FusedIterator<Item = Item>
966where
967    Item: Named,
968{
969    #[inline]
970    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
971        write!(f, "FusedIterator<Item = {}>", Item::NAME)
972    }
973}
974
975impl<Item, IntoIter: Iterator<Item = Item>> Named
976    for dyn iter::IntoIterator<Item = Item, IntoIter = IntoIter>
977where
978    Item: Named,
979    IntoIter: Named,
980{
981    #[inline]
982    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
983        write!(
984            f,
985            "dyn IntoIterator<Item = {}, IntoIter = {}>",
986            Item::NAME,
987            IntoIter::NAME
988        )
989    }
990}
991
992impl<Item> Named for dyn iter::Iterator<Item = Item>
993where
994    Item: Named,
995{
996    #[inline]
997    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
998        write!(f, "Iterator<Item = {}>", Item::NAME)
999    }
1000}
1001
1002// ==== {std,core}::marker
1003
1004// ---- structs ----
1005
1006deref_impl!(impl<T> Named for marker::PhantomData<T>);
1007simple_impl!(marker::PhantomPinned => "PhantomPinned");
1008
1009// ---- traits ----
1010
1011simple_trait_impl!(dyn marker::Send => "Send");
1012simple_trait_impl!(dyn marker::Sync => "Sync");
1013simple_trait_impl!(dyn marker::Unpin => "Unpin");
1014
1015// ==== {std,core}::mem
1016
1017// ---- structs ----
1018
1019simple_container_impl!(impl<T> mem::Discriminant<T> => "Discriminant");
1020
1021impl<T: ?Sized> Named for mem::ManuallyDrop<T>
1022where
1023    T: Named,
1024{
1025    const NAME: Name = Name(T::format_name);
1026
1027    #[inline]
1028    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
1029        T::format_name(f)
1030    }
1031}
1032
1033// ==== std::net ====
1034
1035// ---- structs ----
1036
1037#[cfg(feature = "std")]
1038simple_impl!(net::AddrParseError => "AddrParseError");
1039#[cfg(feature = "std")]
1040simple_impl!(net::Incoming<'_> => "IncomingConnection");
1041#[cfg(feature = "std")]
1042simple_impl!(net::Ipv4Addr => "Ipv4Addr");
1043#[cfg(feature = "std")]
1044simple_impl!(net::Ipv6Addr => "Ipv6Addr");
1045#[cfg(feature = "std")]
1046simple_impl!(net::SocketAddrV4 => "SocketAddrV4");
1047#[cfg(feature = "std")]
1048simple_impl!(net::SocketAddrV6 => "SocketAddrV6");
1049#[cfg(feature = "std")]
1050simple_impl!(net::TcpListener => "TcpListener");
1051#[cfg(feature = "std")]
1052simple_impl!(net::TcpStream => "TcpStream");
1053#[cfg(feature = "std")]
1054simple_impl!(net::UdpSocket => "UdpSocket");
1055
1056// ---- enums ----
1057
1058#[cfg(feature = "std")]
1059simple_impl!(net::IpAddr => "IpAddr");
1060#[cfg(feature = "std")]
1061simple_impl!(net::Shutdown => "ShutdownConnectionDirection");
1062#[cfg(feature = "std")]
1063simple_impl!(net::SocketAddr => "SocketAddr");
1064
1065// ---- traits ----
1066
1067#[cfg(feature = "std")]
1068impl<Item, Iter: Iterator<Item = Item>> Named for dyn net::ToSocketAddrs<Iter = Iter>
1069where
1070    Iter: Named,
1071{
1072    #[inline]
1073    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
1074        write!(f, "dyn ToSocketAddrs<Iter = {}>", Iter::NAME)
1075    }
1076}
1077
1078// ==== {std,core}::num ====
1079
1080// ---- structs ----
1081
1082simple_impl!(num::NonZeroI8 => "i8!=0");
1083simple_impl!(num::NonZeroI16 => "i16!=0");
1084simple_impl!(num::NonZeroI32 => "i32!=0");
1085simple_impl!(num::NonZeroI64 => "i64!=0");
1086simple_impl!(num::NonZeroI128 => "i128!=0");
1087simple_impl!(num::NonZeroIsize => "isize!=0");
1088simple_impl!(num::NonZeroU8 => "u8!=0");
1089simple_impl!(num::NonZeroU16 => "u16!=0");
1090simple_impl!(num::NonZeroU32 => "u32!=0");
1091simple_impl!(num::NonZeroU64 => "u64!=0");
1092simple_impl!(num::NonZeroU128 => "u128!=0");
1093simple_impl!(num::NonZeroUsize => "usize!=0");
1094simple_impl!(num::ParseFloatError => "ParseFloatError");
1095simple_impl!(num::ParseIntError => "ParseIntError");
1096simple_impl!(num::TryFromIntError => "TryFromIntError");
1097simple_container_impl!(impl<T> num::Wrapping<T> => "Wrapping");
1098
1099// ---- enums ----
1100
1101simple_impl!(num::FpCategory => "FloatingPointCategory");
1102simple_impl!(num::IntErrorKind => "IntErrorKind");
1103
1104// ==== {std,core}::ops ====
1105
1106// ---- structs ----
1107
1108impl<Idx> Named for ops::Range<Idx>
1109where
1110    Idx: Named,
1111{
1112    #[inline]
1113    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
1114        write!(f, "{0}..{0}", Idx::NAME)
1115    }
1116}
1117
1118impl<Idx> Named for ops::RangeFrom<Idx>
1119where
1120    Idx: Named,
1121{
1122    #[inline]
1123    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
1124        write!(f, "{}..", Idx::NAME)
1125    }
1126}
1127
1128simple_impl!(ops::RangeFull => "..");
1129
1130impl<Idx> Named for ops::RangeInclusive<Idx>
1131where
1132    Idx: Named,
1133{
1134    #[inline]
1135    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
1136        write!(f, "{0}..={0}", Idx::NAME)
1137    }
1138}
1139
1140impl<Idx> Named for ops::RangeTo<Idx>
1141where
1142    Idx: Named,
1143{
1144    #[inline]
1145    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
1146        write!(f, "..{}", Idx::NAME)
1147    }
1148}
1149
1150impl<Idx> Named for ops::RangeToInclusive<Idx>
1151where
1152    Idx: Named,
1153{
1154    #[inline]
1155    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
1156        write!(f, "..={}", Idx::NAME)
1157    }
1158}
1159
1160// ---- enums ----
1161
1162simple_container_impl!(impl<T> ops::Bound<T> => "Bound");
1163
1164#[cfg(feature = "rust-1-55-0")]
1165impl<B, C> Named for ops::ControlFlow<B, C>
1166where
1167    B: Named,
1168    C: Named,
1169{
1170    #[inline]
1171    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
1172        write!(f, "ControlFlow<{}, {}>", B::NAME, C::NAME)
1173    }
1174}
1175
1176// ---- traits ----
1177
1178simple_op_trait_impl!(dyn ops::Add<Rhs, Output = Output> = dyn ops::AddAssign<Rhs> => "Add", "+");
1179simple_op_trait_impl!(dyn ops::BitAnd<Rhs, Output = Output> = dyn ops::BitAndAssign<Rhs> => "BitAnd", "&");
1180simple_op_trait_impl!(dyn ops::BitOr<Rhs, Output = Output> = dyn ops::BitOrAssign<Rhs> => "BitOr", "|");
1181simple_op_trait_impl!(dyn ops::BitXor<Rhs, Output = Output> = dyn ops::BitXorAssign<Rhs> => "BitXor", "^");
1182
1183impl<Target: ?Sized> Named for dyn ops::Deref<Target = Target>
1184where
1185    Target: Named,
1186{
1187    const NAME: Name = Name(Target::format_name);
1188
1189    #[inline]
1190    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
1191        Target::format_name(f)
1192    }
1193}
1194
1195impl<Target: ?Sized> Named for dyn ops::DerefMut<Target = Target>
1196where
1197    Target: Named,
1198{
1199    const NAME: Name = Name(Target::format_name);
1200
1201    #[inline]
1202    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
1203        Target::format_name(f)
1204    }
1205}
1206
1207simple_op_trait_impl!(dyn ops::Div<Rhs, Output = Output> = dyn ops::DivAssign<Rhs> => "Div", "/");
1208
1209#[allow(dyn_drop)]
1210impl Named for dyn ops::Drop {
1211    #[inline]
1212    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
1213        write!(f, "dyn Drop")
1214    }
1215}
1216
1217impl<Idx, Output> Named for dyn ops::Index<Idx, Output = Output>
1218where
1219    Idx: Named,
1220    Output: Named,
1221{
1222    #[inline]
1223    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
1224        write!(f, "dyn Index[{}] = {}", Idx::NAME, Output::NAME)
1225    }
1226}
1227
1228impl<Idx, Output> Named for dyn ops::IndexMut<Idx, Output = Output>
1229where
1230    Idx: Named,
1231    Output: Named,
1232{
1233    #[inline]
1234    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
1235        write!(f, "dyn Index[{}] = {}", Idx::NAME, Output::NAME)
1236    }
1237}
1238
1239simple_op_trait_impl!(dyn ops::Mul<Rhs, Output = Output> = dyn ops::MulAssign<Rhs> => "Mul", "*");
1240
1241impl<Output> Named for dyn ops::Neg<Output = Output>
1242where
1243    Output: Named,
1244{
1245    #[inline]
1246    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
1247        write!(f, "-dyn Neg = {}", Output::NAME)
1248    }
1249}
1250
1251impl<Output> Named for dyn ops::Not<Output = Output>
1252where
1253    Output: Named,
1254{
1255    #[inline]
1256    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
1257        write!(f, "!dyn Neg = {}", Output::NAME)
1258    }
1259}
1260
1261simple_op_trait_impl!(dyn ops::Rem<Rhs, Output = Output> = dyn ops::RemAssign<Rhs> => "Rem", "%");
1262simple_op_trait_impl!(dyn ops::Shl<Rhs, Output = Output> = dyn ops::ShlAssign<Rhs> => "Shl", "<<");
1263simple_op_trait_impl!(dyn ops::Shr<Rhs, Output = Output> = dyn ops::ShrAssign<Rhs> => "Shr", ">>");
1264simple_op_trait_impl!(dyn ops::Sub<Rhs, Output = Output> = dyn ops::SubAssign<Rhs> => "Sub", "-");
1265
1266// ==== {std,core}::options ====
1267
1268// ---- structs ----
1269
1270simple_container_impl!(impl<A> option::IntoIter<A> => "option::IntoIter");
1271simple_container_impl!(impl<A> option::Iter<'_, A> => "option::Iter");
1272simple_container_impl!(impl<A> option::IterMut<'_, A> => "option::IterMut");
1273
1274// ---- enums ----
1275
1276simple_container_impl!(impl<T> option::Option<T> => "Option");
1277
1278// ==== std::os ====
1279
1280// ---- structs ----
1281
1282#[cfg(all(feeature = "std", feature = "rust-1-66-0", any(unix, target_os = "wasi")))]
1283simple_impl!(os::fd::BorrowedFd<'_> => "BorrowedFd");
1284#[cfg(all(feature = "std", feature = "rust-1-66-0", any(unix, target_os = "wasi")))]
1285simple_impl!(os::fd::OwnedFd => "OwnedFd");
1286
1287#[cfg(all(feature = "std", unix))]
1288simple_impl!(os::unix::net::Incoming<'_> => "ConnectionIncoming");
1289#[cfg(all(feature = "std", unix))]
1290simple_impl!(os::unix::net::SocketAddr => "SocketAddr");
1291#[cfg(all(feature = "std", unix))]
1292simple_impl!(os::unix::net::UnixDatagram => "Datagram");
1293#[cfg(all(feature = "std", unix))]
1294simple_impl!(os::unix::net::UnixListener => "Listener");
1295#[cfg(all(feature = "std", unix))]
1296simple_impl!(os::unix::net::UnixStream => "Stream");
1297
1298#[cfg(all(feature = "std", windows))]
1299simple_impl!(os::windows::ffi::EncodeWide<'_> => "EncodeWide");
1300
1301#[cfg(all(feature = "std", windows, feature = "rust-1-63-0"))]
1302simple_impl!(os::windows::io::BorrowedHandle<'_> => "BorrowedHandle");
1303#[cfg(all(feature = "std", windows, feature = "rust-1-63-0"))]
1304simple_impl!(os::windows::io::BorrowedSocket<'_> => "BorrowedSocket");
1305#[cfg(all(feature = "std", windows, feature = "rust-1-63-0"))]
1306simple_impl!(os::windows::io::HandleOrInvalid => "HandleOrInvalid");
1307#[cfg(all(feature = "std", windows, feature = "rust-1-63-0"))]
1308simple_impl!(os::windows::io::HandleOrNull => "HandleOrNull");
1309#[cfg(all(feature = "std", windows, feature = "rust-1-63-0"))]
1310simple_impl!(os::windows::io::InvalidHandleError => "InvalidHandleError");
1311#[cfg(all(feature = "std", windows, feature = "rust-1-63-0"))]
1312simple_impl!(os::windows::io::NullHandleError => "NullHandleError");
1313#[cfg(all(feature = "std", windows, feature = "rust-1-63-0"))]
1314simple_impl!(os::windows::io::OwnedHandle => "OwnedHandle");
1315#[cfg(all(feature = "std", windows, feature = "rust-1-63-0"))]
1316simple_impl!(os::windows::io::OwnedSocket => "OwnedSocket");
1317
1318// ---- traits ----
1319
1320#[cfg(all(feature = "std", any(unix, target_os = "wasi")))]
1321simple_trait_impl!(dyn os::fd::AsFd => "AsFd");
1322#[cfg(all(feature = "std", any(unix, target_os = "wasi")))]
1323simple_trait_impl!(dyn os::fd::AsRawFd => "AsRawFd");
1324#[cfg(all(feature = "std", any(unix, target_os = "wasi")))]
1325simple_trait_impl!(dyn os::fd::IntoRawFd => "IntoRawFd");
1326
1327#[cfg(all(feature = "std", target_os = "linux"))]
1328simple_trait_impl!(dyn os::linux::fs::MetadataExt => "FileMetadata");
1329
1330#[cfg(all(feature = "std", unix))]
1331simple_trait_impl!(dyn os::unix::fs::DirEntryExt => "DirEntry");
1332#[cfg(all(feature = "std", unix))]
1333simple_trait_impl!(dyn os::unix::fs::FileExt => "File");
1334#[cfg(all(feature = "std", unix))]
1335simple_trait_impl!(dyn os::unix::fs::FileTypeExt => "FileType");
1336#[cfg(all(feature = "std", unix))]
1337simple_trait_impl!(dyn os::unix::fs::MetadataExt => "FileMetadata");
1338
1339#[cfg(all(feature = "std", unix))]
1340simple_trait_impl!(dyn os::unix::thread::JoinHandleExt => "JoinHandle");
1341
1342#[cfg(all(feature = "std", windows))]
1343simple_trait_impl!(dyn os::windows::ffi::OsStrExt => "OsStr");
1344
1345#[cfg(all(feature = "std", windows))]
1346simple_trait_impl!(dyn os::windows::fs::FileExt => "File");
1347#[cfg(all(feature = "std", windows, feature = "rust-1-64-0"))]
1348simple_trait_impl!(dyn os::windows::fs::FileTypeExt => "FileType");
1349#[cfg(all(feature = "std", windows))]
1350simple_trait_impl!(dyn os::windows::fs::MetadataExt => "FileMetadata");
1351
1352#[cfg(all(feature = "std", windows, feature = "rust-1-63-0"))]
1353simple_trait_impl!(dyn os::windows::io::AsHandle => "AsHandle");
1354#[cfg(all(feature = "std", windows))]
1355simple_trait_impl!(dyn os::windows::io::AsRawHandle => "AsRawHandle");
1356#[cfg(all(feature = "std", windows))]
1357simple_trait_impl!(dyn os::windows::io::AsRawSocket => "AsRawSocket");
1358#[cfg(all(feature = "std", windows, feature = "rust-1-63-0"))]
1359simple_trait_impl!(dyn os::windows::io::AsSocket => "AsSocket");
1360#[cfg(all(feature = "std", windows))]
1361simple_trait_impl!(dyn os::windows::io::IntoRawHandle => "IntoRawHandle");
1362#[cfg(all(feature = "std", windows))]
1363simple_trait_impl!(dyn os::windows::io::IntoRawSocket => "IntoRawSocket");
1364
1365// ==== {std,core}::panic ====
1366
1367// ---- structs ----
1368
1369deref_impl!(impl<T> Named for panic::AssertUnwindSafe<T>);
1370simple_impl!(panic::Location<'_> => "PanicLocation");
1371simple_impl!(panic::PanicInfo<'_> => "PanicInfo");
1372
1373// ---- traits ----
1374
1375simple_trait_impl!(dyn panic::RefUnwindSafe => "RefUnwindSafe");
1376simple_trait_impl!(dyn panic::UnwindSafe => "UnwindSafe");
1377
1378// ==== std::path ====
1379
1380// ---- structs ----
1381
1382#[cfg(feature = "std")]
1383simple_impl!(path::Ancestors<'_> => "PathAncestors");
1384#[cfg(feature = "std")]
1385simple_impl!(path::Components<'_> => "PathComponents");
1386#[cfg(feature = "std")]
1387simple_impl!(path::Display<'_> => "DisplayPath");
1388#[cfg(feature = "std")]
1389simple_impl!(path::Iter<'_> => "Iter");
1390#[cfg(feature = "std")]
1391simple_impl!(path::Path => "Path");
1392#[cfg(feature = "std")]
1393simple_impl!(path::PathBuf => "PathBuf");
1394#[cfg(feature = "std")]
1395simple_impl!(path::PrefixComponent<'_> => "PathPrefixComponent");
1396#[cfg(feature = "std")]
1397simple_impl!(path::StripPrefixError => "StripPrefixError");
1398
1399// ---- enums ----
1400
1401#[cfg(feature = "std")]
1402simple_impl!(path::Component<'_> => "PathComponent");
1403#[cfg(feature = "std")]
1404simple_impl!(path::Prefix<'_> => "PathPrefix");
1405
1406// ==== {std,core}::pin ====
1407
1408// ---- structs ----
1409
1410deref_impl!(impl<T> Named for pin::Pin<T>);
1411
1412// ==== std::process ====
1413
1414// ---- structs ----
1415
1416#[cfg(feature = "std")]
1417simple_impl!(process::Child => "ProcessChild");
1418#[cfg(feature = "std")]
1419simple_impl!(process::ChildStderr => "ChildStderr");
1420#[cfg(feature = "std")]
1421simple_impl!(process::ChildStdin => "ChildStdin");
1422#[cfg(feature = "std")]
1423simple_impl!(process::ChildStdout => "ChildStdout");
1424#[cfg(feature = "std")]
1425simple_impl!(process::Command => "Command");
1426#[cfg(all(feature = "std", feature = "rust-1-57-0"))]
1427simple_impl!(process::CommandArgs<'_> => "CommandArgs");
1428#[cfg(all(feature = "std", feature = "rust-1-57-0"))]
1429simple_impl!(process::CommandEnvs<'_> => "CommandEnvs");
1430#[cfg(all(feature = "std", feature = "rust-1-61-0"))]
1431simple_impl!(process::ExitCode => "ExitCode");
1432#[cfg(feature = "std")]
1433simple_impl!(process::ExitStatus => "ExitStatus");
1434#[cfg(feature = "std")]
1435simple_impl!(process::Output => "ProcessOutput");
1436#[cfg(feature = "std")]
1437simple_impl!(process::Stdio => "Stdio");
1438
1439// --- traits ----
1440
1441#[cfg(feature = "std")]
1442simple_trait_impl!(dyn process::Termination => "Termination");
1443
1444// ==== {std,core}::ptr ====
1445
1446// ---- structs ----
1447
1448deref_impl!(impl<T> Named for ptr::NonNull<T>);
1449
1450// ==== {std,alloc}::rc ====
1451
1452// ---- stucts ----
1453
1454#[cfg(any(feature = "std", feature = "alloc"))]
1455impl<T: ?Sized> Named for rc::Rc<T>
1456where
1457    T: Named,
1458{
1459    const NAME: Name = Name(T::format_name);
1460
1461    #[inline]
1462    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
1463        T::format_name(f)
1464    }
1465}
1466
1467#[cfg(any(feature = "std", feature = "alloc"))]
1468impl<T: ?Sized> Named for rc::Weak<T>
1469where
1470    T: Named,
1471{
1472    #[inline]
1473    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
1474        write!(f, "RcWeak<{}>", T::NAME)
1475    }
1476}
1477
1478// ==== {std,core}::result ====
1479
1480// ---- structs ----
1481
1482simple_container_impl!(impl<T> result::IntoIter<T> => "IntoIter");
1483simple_container_impl!(impl<T> result::Iter<'_, T> => "Iter");
1484simple_container_impl!(impl<T> result::IterMut<'_, T> => "IterMut");
1485
1486// ---- enums ----
1487
1488simple_map_impl!(impl<T, E> result::Result<T, E> => "Result");
1489
1490// ==== {std,alloc,core}::slice ====
1491
1492// ---- stucts ----
1493
1494simple_container_impl!(impl<T> slice::Chunks<'_, T> => "Chunks");
1495simple_container_impl!(impl<T> slice::ChunksExact<'_, T> => "ChunksExact");
1496simple_container_impl!(impl<T> slice::ChunksExactMut<'_, T> => "ChunksExactMut");
1497simple_container_impl!(impl<T> slice::ChunksMut<'_, T> => "ChunksMut");
1498#[cfg(feature = "rust-1-60-0")]
1499simple_impl!(slice::EscapeAscii<'_> => "EscapeAscii");
1500simple_container_impl!(impl<T> slice::Iter<'_, T> => "Iter");
1501simple_container_impl!(impl<T> slice::IterMut<'_, T> => "IterMut");
1502simple_container_impl!(impl<T> slice::RChunks<'_, T> => "RChunks");
1503simple_container_impl!(impl<T> slice::RChunksExact<'_, T> => "RChunksExact");
1504simple_container_impl!(impl<T> slice::RChunksExactMut<'_, T> => "RChunksExactMut");
1505simple_container_impl!(impl<T> slice::RChunksMut<'_, T> => "RChunksMut");
1506
1507impl<T, P: FnMut(&T) -> bool> Named for slice::RSplit<'_, T, P>
1508where
1509    T: Named,
1510{
1511    #[inline]
1512    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
1513        write!(f, "RSplit<{}>", T::NAME)
1514    }
1515}
1516
1517impl<T, P: FnMut(&T) -> bool> Named for slice::RSplitMut<'_, T, P>
1518where
1519    T: Named,
1520{
1521    #[inline]
1522    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
1523        write!(f, "RSplitMut<{}>", T::NAME)
1524    }
1525}
1526
1527impl<T, P: FnMut(&T) -> bool> Named for slice::RSplitN<'_, T, P>
1528where
1529    T: Named,
1530{
1531    #[inline]
1532    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
1533        write!(f, "RSplitN<{}>", T::NAME)
1534    }
1535}
1536
1537impl<T, P: FnMut(&T) -> bool> Named for slice::RSplitNMut<'_, T, P>
1538where
1539    T: Named,
1540{
1541    #[inline]
1542    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
1543        write!(f, "RSplitNMut<{}>", T::NAME)
1544    }
1545}
1546
1547impl<T, P: FnMut(&T) -> bool> Named for slice::Split<'_, T, P>
1548where
1549    T: Named,
1550{
1551    #[inline]
1552    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
1553        write!(f, "Split<{}>", T::NAME)
1554    }
1555}
1556
1557impl<T, P: FnMut(&T) -> bool> Named for slice::SplitInclusive<'_, T, P>
1558where
1559    T: Named,
1560{
1561    #[inline]
1562    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
1563        write!(f, "SplitInclusive<{}>", T::NAME)
1564    }
1565}
1566
1567impl<T, P: FnMut(&T) -> bool> Named for slice::SplitInclusiveMut<'_, T, P>
1568where
1569    T: Named,
1570{
1571    #[inline]
1572    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
1573        write!(f, "SplitInclusiveMut<{}>", T::NAME)
1574    }
1575}
1576
1577impl<T, P: FnMut(&T) -> bool> Named for slice::SplitMut<'_, T, P>
1578where
1579    T: Named,
1580{
1581    #[inline]
1582    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
1583        write!(f, "SplitMut<{}>", T::NAME)
1584    }
1585}
1586
1587impl<T, P: FnMut(&T) -> bool> Named for slice::SplitN<'_, T, P>
1588where
1589    T: Named,
1590{
1591    #[inline]
1592    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
1593        write!(f, "SplitN<{}>", T::NAME)
1594    }
1595}
1596
1597impl<T, P: FnMut(&T) -> bool> Named for slice::SplitNMut<'_, T, P>
1598where
1599    T: Named,
1600{
1601    #[inline]
1602    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
1603        write!(f, "SplitNMut<{}>", T::NAME)
1604    }
1605}
1606
1607simple_container_impl!(impl<T> slice::Windows<'_, T> => "Windows");
1608
1609// ---- traits ----
1610
1611impl<T: ?Sized, Output: ?Sized> Named for dyn slice::SliceIndex<T, Output = Output> where T: Named, Output: Named {
1612    #[inline]
1613    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
1614        write!(f, "{}[dyn SliceIndex] = {}", T::NAME, Output::NAME)
1615    }
1616}
1617
1618// ==== {std,alloc,core}::str ====
1619
1620// ---- structs ----
1621
1622simple_impl!(str::Bytes<'_> => "StrBytes");
1623simple_impl!(str::CharIndices<'_> => "CharIndices");
1624simple_impl!(str::Chars<'_> => "Chars");
1625simple_impl!(str::EncodeUtf16<'_> => "EncodeUtf16");
1626simple_impl!(str::EscapeDebug<'_> => "EscapeDebug");
1627simple_impl!(str::EscapeDefault<'_> => "EscapeDefault");
1628simple_impl!(str::EscapeUnicode<'_> => "EscapeUnicode");
1629simple_impl!(str::Lines<'_> => "StrLines");
1630simple_impl!(str::ParseBoolError => "ParseBoolError");
1631simple_impl!(str::SplitAsciiWhitespace<'_> => "SplitAsciiWhiteSpace");
1632simple_impl!(str::SplitWhitespace<'_> => "SplitWhiteSpace");
1633simple_impl!(str::Utf8Error => "Utf8Error");
1634
1635// ==== {std,alloc}::string ====
1636
1637// ---- structs ----
1638
1639#[cfg(any(feature = "std", feature = "alloc"))]
1640simple_impl!(string::Drain<'_> => "Drain");
1641#[cfg(any(feature = "std", feature = "alloc"))]
1642simple_impl!(string::FromUtf8Error => "FromUtf8Error");
1643#[cfg(any(feature = "std", feature = "alloc"))]
1644simple_impl!(string::FromUtf16Error => "FromUtf16Error");
1645#[cfg(any(feature = "std", feature = "alloc"))]
1646simple_impl!(string::String => "String");
1647
1648// ---- traits ----
1649
1650#[cfg(any(feature = "std", feature = "alloc"))]
1651simple_trait_impl!(dyn string::ToString => "ToString");
1652
1653// ==== {std,alloc,core}::sync ====
1654
1655// ---- structs ----
1656
1657simple_impl!(sync::atomic::AtomicBool => "bool");
1658simple_impl!(sync::atomic::AtomicI8 => "i8");
1659simple_impl!(sync::atomic::AtomicI16 => "i16");
1660simple_impl!(sync::atomic::AtomicI32 => "i32");
1661simple_impl!(sync::atomic::AtomicI64 => "i64");
1662simple_impl!(sync::atomic::AtomicIsize => "isize");
1663deref_impl!(impl<T> Named for sync::atomic::AtomicPtr<T>);
1664simple_impl!(sync::atomic::AtomicU8 => "u8");
1665simple_impl!(sync::atomic::AtomicU16 => "u16");
1666simple_impl!(sync::atomic::AtomicU32 => "u32");
1667simple_impl!(sync::atomic::AtomicU64 => "u64");
1668simple_impl!(sync::atomic::AtomicUsize => "usize");
1669
1670#[cfg(feature = "std")]
1671simple_container_impl!(impl<T> sync::mpsc::IntoIter<T> => "IntoIter");
1672#[cfg(feature = "std")]
1673simple_container_impl!(impl<T> sync::mpsc::Iter<'_, T> => "Iter");
1674#[cfg(feature = "std")]
1675simple_container_impl!(impl<T> sync::mpsc::Receiver<T> => "Receiver");
1676#[cfg(feature = "std")]
1677simple_impl!(sync::mpsc::RecvError => "ReceiveError");
1678#[cfg(feature = "std")]
1679simple_container_impl!(impl<T> sync::mpsc::SendError<T> => "SendError");
1680#[cfg(feature = "std")]
1681simple_container_impl!(impl<T> sync::mpsc::Sender<T> => "Sender");
1682#[cfg(feature = "std")]
1683simple_container_impl!(impl<T> sync::mpsc::SyncSender<T> => "SyncSender");
1684#[cfg(feature = "std")]
1685simple_container_impl!(impl<T> sync::mpsc::TryIter<'_, T> => "TryIter");
1686
1687#[cfg(any(feature = "std", feature = "alloc"))]
1688impl<T: ?Sized> Named for sync::Arc<T> where T: Named {
1689    const NAME: Name = Name(T::format_name);
1690
1691    #[inline]
1692    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
1693        T::format_name(f)
1694    }
1695}
1696
1697#[cfg(feature = "std")]
1698simple_impl!(sync::Barrier => "Barrier");
1699#[cfg(feature = "std")]
1700simple_impl!(sync::BarrierWaitResult => "BarrierWaitResult");
1701#[cfg(feature = "std")]
1702simple_impl!(sync::Condvar => "Condvar");
1703#[cfg(feature = "std")]
1704deref_impl!(impl<T: ?Sized> Named for sync::Mutex<T>);
1705
1706#[cfg(feature = "std")]
1707impl<T: ?Sized> Named for sync::MutexGuard<'_, T> where T: Named {
1708    const NAME: Name = Name(T::format_name);
1709
1710    #[inline]
1711    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
1712        T::format_name(f)
1713    }
1714}
1715
1716#[cfg(feature = "std")]
1717simple_impl!(sync::Once => "Once");
1718#[cfg(all(feature = "std", feature = "rust-1-70-0"))]
1719deref_impl!(impl<T> Named for sync::OnceLock<T>);
1720#[cfg(feature = "std")]
1721simple_impl!(sync::OnceState => "OnceState");
1722#[cfg(feature = "std")]
1723simple_container_impl!(impl<T> sync::PoisonError<T> => "LockPoisonError");
1724#[cfg(feature = "std")]
1725deref_impl!(impl<T: ?Sized> Named for sync::RwLock<T>);
1726
1727#[cfg(feature = "std")]
1728impl<T: ?Sized> Named for sync::RwLockReadGuard<'_, T> where T: Named {
1729    const NAME: Name = Name(T::format_name);
1730
1731    #[inline]
1732    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
1733        T::format_name(f)
1734    }
1735}
1736
1737#[cfg(feature = "std")]
1738impl<T: ?Sized> Named for sync::RwLockWriteGuard<'_, T> where T: Named {
1739    const NAME: Name = Name(T::format_name);
1740
1741    #[inline]
1742    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
1743        T::format_name(f)
1744    }
1745}
1746
1747#[cfg(feature = "std")]
1748simple_impl!(sync::WaitTimeoutResult => "WaitTimeoutResult");
1749#[cfg(any(feature = "std", feature = "alloc"))]
1750impl<T: ?Sized> Named for sync::Weak<T> where T: Named {
1751    #[inline]
1752    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
1753        write!(f, "ArcWeak<{}>", T::NAME)
1754    }
1755}
1756
1757// ---- enums ----
1758
1759simple_impl!(sync::atomic::Ordering => "AtomicOrdering");
1760
1761#[cfg(feature = "std")]
1762simple_impl!(sync::mpsc::RecvTimeoutError => "ReceiveTimeoutError");
1763#[cfg(feature = "std")]
1764simple_impl!(sync::mpsc::TryRecvError => "TryReceiveError");
1765#[cfg(feature = "std")]
1766simple_container_impl!(impl<T> sync::mpsc::TrySendError<T> => "TrySendError");
1767
1768#[cfg(feature = "std")]
1769simple_container_impl!(impl<T> sync::TryLockError<T> => "TryLockError");
1770
1771// ==== {std,core}::task ====
1772
1773// ---- structs ----
1774
1775simple_impl!(task::Context<'_> => "TaskContext");
1776simple_impl!(task::RawWaker => "RawWaker");
1777simple_impl!(task::RawWakerVTable => "RawWakerVTable");
1778simple_impl!(task::Waker => "Waker");
1779
1780// ---- enums ----
1781
1782simple_container_impl!(impl<T> task::Poll<T> => "Poll");
1783
1784// ==== std::thread ====
1785
1786// ---- structs ----
1787
1788#[cfg(feature = "std")]
1789simple_impl!(thread::AccessError => "ThreadAccessError");
1790#[cfg(feature = "std")]
1791simple_impl!(thread::Builder => "ThreadBuilder");
1792#[cfg(feature = "std")]
1793simple_container_impl!(impl<T> thread::JoinHandle<T> => "JoinHandle");
1794
1795#[cfg(feature = "std")]
1796impl<T: 'static> Named for thread::LocalKey<T> where T: Named {
1797    const NAME: Name = Name(T::format_name);
1798
1799    #[inline]
1800    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
1801        T::format_name(f)
1802    }
1803}
1804
1805#[cfg(all(feature = "std", feature = "rust-1-63-0"))]
1806impl<'scope, 'env: 'scope> Named for thread::Scope<'scope, 'env> {
1807    #[inline]
1808    fn format_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
1809        write!(f, "ThreadScope")
1810    }
1811}
1812
1813#[cfg(all(feature = "std", feature = "rust-1-63-0"))]
1814simple_container_impl!(impl<T> thread::ScopedJoinHandle<'_, T> => "ScopedJoinHandle");
1815#[cfg(feature = "std")]
1816simple_impl!(thread::Thread => "Thread");
1817#[cfg(feature = "std")]
1818simple_impl!(thread::ThreadId => "ThreadId");
1819
1820// ==== std::time ====
1821
1822// ---- structs ----
1823
1824simple_impl!(time::Duration => "Duration");
1825#[cfg(feature = "std")]
1826simple_impl!(time::Instant => "Instant");
1827#[cfg(feature = "std")]
1828simple_impl!(time::SystemTime => "SystemTime");
1829#[cfg(feature = "std")]
1830simple_impl!(time::SystemTimeError => "SystemTimeError");
1831simple_impl!(time::TryFromFloatSecsError => "TryFromFloatSecsError");
1832
1833// ==== {std,alloc}::vec ====
1834
1835// ---- structs ----
1836
1837#[cfg(any(feature = "std", feature = "alloc"))]
1838simple_container_impl!(impl<T> vec::Drain<'_, T> => "Drain");
1839#[cfg(any(feature = "std", feature = "alloc"))]
1840simple_container_impl!(impl<T> vec::IntoIter<T> => "IntoIter");
1841#[cfg(any(feature = "std", feature = "alloc"))]
1842simple_container_impl!(impl<I: Iterator> vec::Splice<'_, I> => "Drain");
1843#[cfg(any(feature = "std", feature = "alloc"))]
1844simple_container_impl!(impl<T> vec::Vec<T> => "Vec");
named_types/lib.rs

named_types/
lib.rs
