Rust RFC for
non_static_type_id feature has been reverted.
Which means in foreseeable future there will be no built-in way in rust to get type id for non-static type
let alone safely use it to downcast to a particular type.
This crate provides tools to do these things safely for types with single lifetime. Although looks like it is technically possible to extend this approach for multiple lifetimes, consistent api and derive macro would be much harder to create and use because of the necessity to properly handle lifetime relations. Feel free to create an issue if you have actual use case where you need this functionality for multiple lifetimes.
Also it has better downcasting that allows you do downcast not just from
dyn Tid (like
dyn Any) but from
any trait object that implements
So there is no more need to extend your traits with
fn to_any(&self)-> &dyn Any
Basically in places where before you have used
dyn Any you can use
- If your type is generic you should derive
Tidimplementation for it with
Tidderive macro. Then to retrieve back concrete type
<dyn Tid>::downcast_*methods should be used.
- If your type is not generic/implements Any you can create
dyn Anyand convert it to
dyn Tid. Then to retrieve back concrete type
<dyn Tid>::downcast_any_*methods should be used
- If your type is not generic and local to your crate you also can derive
Tidbut then you need to be careful to use methods that corresponds to the way you create
dyn Tidfor that particular type. Otherwise downcasting will return
If all your types can implement
Tid to avoid confusion
recommended way is to use first option even if some types implement
If there are some types that implement
Any and can't implement
Tid (i.e. types from other library),
recommended way is to use second option for all types that implement
Any to reduce confusion to minimum.
Unfortunately you can't just use
Tid everywhere because currently it is impossible
T:Any since it would conflict with any other possible
To overcome this limitation there is a
From impl to go from
dyn Any to
Tid deliberately return different type ids because otherwise
would be indistinguishable and it would allow to go from
which is obviously unsound for invariant and contravariant structs.
Although if you are using
dyn Trait where
Trait:Tid all of this wouldn't work,
and you are left with
It is safe because created trait object preserve lifetime information,
thus allowing us to safely downcast with proper lifetime.
Otherwise internally it is plain old
Simple version of derive macro to not pull all proc macro dependencies in simple cases when all structs are not generic
This trait indicates that this type can be converted to
trait object with typeid while preserving lifetime information.
This trait indicates that you can substitute this type as a type parameter to
another type so that resulting type could implement
Extension trait that contains actual downcasting methods.
Returns type id of
Attribute macro that makes your implementation of
Derive macro to implement traits from this crate