dyn-any 0.1.0

An Any trait that works for arbitrary lifetimes
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

#![doc(html_root_url = "http://docs.rs/const-default/1.0.0")]
#![cfg_attr(feature = "unstable-docs", feature(doc_cfg))]

#[cfg(feature = "derive")]
#[cfg_attr(feature = "unstable-docs", doc(cfg(feature = "derive")))]
pub use dyn_any_derive::DynAny;

pub trait DynAny<'a>: 'a {
    type Static: 'static + ?Sized;
    fn type_id(&self) -> std::any::TypeId {
        std::any::TypeId::of::<Self::Static>()
    }
}
pub trait DynAnySized<'a>: 'a {
    type Static: 'static;
    fn type_id(&self) -> std::any::TypeId {
        std::any::TypeId::of::<Self::Static>()
    }
}
impl<'a, T: DynAnySized<'a>> DynAny<'a> for T {
    type Static = <T as DynAnySized<'a>>::Static;
}
pub trait DynAnyClone<'a>: 'a {
    type Static: 'static + Clone;
    fn type_id(&self) -> std::any::TypeId {
        std::any::TypeId::of::<Self::Static>()
    }
}
impl<'a, T: DynAnyClone<'a>> DynAnySized<'a> for T {
    type Static = <T as DynAnyClone<'a>>::Static;
}

macro_rules! impl_type {
    ($($id:ident$(<$($(($l:lifetime, $s:lifetime)),*|)?$($T:ident),*>)?),*) => {
        $(
        impl<'a, $($($T: 'a + $crate::DynAnySized<'a> + Sized,)*)?> $crate::DynAny<'a> for $id $(<$($($l,)*)?$($T, )*>)?{
            type Static = $id$(<$($($s,)*)?$(<$T as $crate::DynAnySized<'a>>::Static,)*>)?;
        }
        )*
    };
}
impl<'a, T: Clone + DynAnyClone<'a>> DynAnyClone<'a>
    for std::borrow::Cow<'a, T>
{
    type Static = std::borrow::Cow<'static, <T as DynAnySized<'a>>::Static>;
}
impl<'a, T: DynAnySized<'a>> DynAnySized<'a> for *const [T] {
    type Static = *const [<T as DynAnySized<'a>>::Static];
}
impl<'a, T: DynAnySized<'a>> DynAnySized<'a> for *mut [T] {
    type Static = *mut [<T as DynAnySized<'a>>::Static];
}
impl<'a, T: DynAnySized<'a>> DynAnySized<'a> for &'a [T] {
    type Static = &'static [<T as DynAnySized<'a>>::Static];
}
impl<'a> DynAnySized<'a> for &'a str {
    type Static = &'static str;
}
impl<'a> DynAnySized<'a> for () {
    type Static = ();
}
impl<'a, T: DynAnySized<'a>, const N: usize> DynAnySized<'a> for [T; N] {
    type Static = [<T as DynAnySized<'a>>::Static; N];
}

use core::{
    cell::{Cell, RefCell, UnsafeCell},
    iter::Empty,
    marker::{PhantomData, PhantomPinned},
    mem::{ManuallyDrop, MaybeUninit},
    num::Wrapping,
    time::Duration,
};
use std::{
    collections::*,
    sync::{atomic::*, *},
    vec::Vec,
};

impl_type!(Option<T>,Result<T, E>,Cell<T>,UnsafeCell<T>,RefCell<T>,MaybeUninit<T>,
           Vec<T>, String, BTreeMap<K,V>,BTreeSet<V>, LinkedList<T>, VecDeque<T>,
           BinaryHeap<T>, ManuallyDrop<T>, PhantomData<T>, PhantomPinned<>,Empty<T>,
           Wrapping<T>, Duration, Once, Mutex<T>, RwLock<T>,  bool, f32, f64, char,
           u8, AtomicU8, u16,AtomicU16, u32,AtomicU32, u64,AtomicU64, usize,AtomicUsize,
           i8,AtomicI8, i16,AtomicI16, i32,AtomicI32, i64,AtomicI64, isize,AtomicIsize,
            i128, u128, AtomicBool, AtomicPtr<T>
);
macro_rules! impl_tuple {
    (@rec $t:ident) => { };
    (@rec $_:ident $($t:ident)+) => {
        impl_tuple! { @impl $($t)* }
        impl_tuple! { @rec $($t)* }
    };
    (@impl $($t:ident)*) => {
        impl<'dyn_any, $($t: DynAnySized<'dyn_any>,)*> DynAnySized<'dyn_any> for ($($t,)*) {
            type Static = ($(<$t as $crate::DynAnySized<'dyn_any>>::Static,)*);
        }
    };
    ($($t:ident)*) => {
        impl_tuple! { @rec _t $($t)* }
    };
}

impl_tuple! {
    A B C D E F G H I J K L
}