Crosstrait

https://docs.rs/crosstrait/
Admin
Crosstrait is a Rust crate that enables casting from dyn Any to other trait objects with a...
Tokens:14,219
Snippets:142
Trust Score:9.1
Update:5 months ago
Show doc for...
Tokens:
Raw
### Dynamic Registration Order

Source: https://docs.rs/crosstrait/latest/crosstrait

Registrations can occur in any order across different crates and at any point in the program's execution, as long as they are linked correctly. This example shows a late registration.

```rust
// Registration in the default registry can happen anywhere
// in any order in any downstream crate
register! { i32 => dyn AddAssign<i32> }
```

--------------------------------

### Handle Autotraits and Generics in Casting

Source: https://docs.rs/crosstrait/latest/crosstrait

Casting fails if autotraits (like `Sync`, `Send`) or type/const generics are part of the target trait and not explicitly registered. This example shows a failed cast due to missing `Sync`.

```rust
// Autotraits and type/const generics are distinct
let a: Option<&(dyn Debug + Sync)> = any.cast();
assert!(a.is_none());
```

--------------------------------

### entry Macro

Source: https://docs.rs/crosstrait/latest/crosstrait/macro.entry.html

Build an entry for the type-trait registry.

```APIDOC
## macro_rules! entry

### Description
Build an entry for the type-trait registry.

### Syntax
```rust
macro_rules! entry {
    ( $ty:ty => $tr:ty $(, $flag:ident)? ) => { ... };
}
```

### Parameters
- `$ty`: The type for which the entry is being built.
- `$tr`: The trait associated with the entry.
- `$flag` (optional): An identifier flag.
```

--------------------------------

### Registry::new

Source: https://docs.rs/crosstrait/latest/crosstrait/struct.Registry.html

Builds a new registry from an iterator over key-value pairs.

```APIDOC
## Registry::new

### Description
Build a new registry from an iterator over key (`fn() -> [TypeId; 2]`) value (`&'a dyn Any + Send + Sync`) pairs.

### Signature
```rust
pub fn new<'b>(it: impl IntoIterator<Item = &'b Entry<'a>>) -> Self
where
    'a: 'b,
```
```

--------------------------------

### Create a new Registry

Source: https://docs.rs/crosstrait/latest/crosstrait/struct.Registry.html

Builds a new Registry from an iterator of Entry items. The 'a lifetime must outlive the 'b lifetime of the entries.

```rust
pub fn new<'b>(it: impl IntoIterator<Item = &'b Entry<'a>>) -> Self
where 'a: 'b,
```

--------------------------------

### Clone from implementation for Registry

Source: https://docs.rs/crosstrait/latest/crosstrait/struct.Registry.html

Provides the `clone_from` method for the `Registry` struct, enabling copy-assignment from another registry.

```rust
fn clone_from(&mut self, source: &Self)
```

--------------------------------

### Clone implementation for Registry

Source: https://docs.rs/crosstrait/latest/crosstrait/struct.Registry.html

Provides the `clone` method for the `Registry` struct, allowing for duplication of registry instances.

```rust
fn clone(&self) -> Registry<'a>
```

--------------------------------

### Default implementation for Registry

Source: https://docs.rs/crosstrait/latest/crosstrait/struct.Registry.html

Provides a default value for `Registry` using the `default` function, typically an empty registry.

```rust
fn default() -> Registry<'a>
```

--------------------------------

### Define Registry Entry Macro

Source: https://docs.rs/crosstrait/latest/src/crosstrait/lib.rs.html

Use the `entry!` macro to create a key-value pair for the type-trait registry. It takes the concrete type and the target trait as arguments.

```rust
macro_rules! entry {
    ( $ty:ty => $tr:ty $(, $flag:ident)? ) => {
        (
            (|| [::core::any::TypeId::of::<$tr>(), ::core::any::TypeId::of::<$ty>()]) as _,
            &$crate::caster!( $ty => $tr $(, $flag)? ) as _,
        )
    };
}
```

--------------------------------

### Build Caster (With Alloc/Std)

Source: https://docs.rs/crosstrait/latest/src/crosstrait/lib.rs.html

This macro defines the `Caster` struct for environments with `alloc` or `std`. It includes functions for downcasting references and boxed/RC/ARC types.

```rust
macro_rules! caster {
    ( $ty:ty => $tr:ty $(, $flag:ident)? ) => {
        $crate::Caster::<$tr> {
            ref_: |any| any.downcast_ref::<$ty>().map(|t| t as _),
            mut_: |any| any.downcast_mut::<$ty>().map(|t| t as _),
            box_: |any| any.downcast::<$ty>().map(|t| t as _),
            rc: |any| any.downcast::<$ty>().map(|t| t as _),
            arc: $crate::caster!( $ty $(, $flag)? ),
        }
    };
    ( $ty:ty ) => {
        |any| any.downcast::<$ty>().map(|t| t as _)
    };
    ( $ty:ty, no_arc ) => {
        |any| Err(any)
    };
}
```

--------------------------------

### CloneToUninit trait implementation (Nightly Only)

Source: https://docs.rs/crosstrait/latest/crosstrait/struct.Registry.html

Implements the experimental `clone_to_uninit` method for types that implement `Clone`. This is a nightly-only feature.

```rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)
```

--------------------------------

### register macro

Source: https://docs.rs/crosstrait/latest/crosstrait/macro.register.html

This macro provides several ways to register a type and a target trait, with optional flags.

```APIDOC
## register macro

### Description
Register a type and target trait in the registry.

### Syntax
```rust
macro_rules! register {
    ( $ty:ty => $tr:ty $(, $flag:ident)? ) => { ... };
    ( $reg:path: $ty:ty => $tr:ty $(, $flag:ident)? ) => { ... };
    ( $name:ident, $reg:path: $ty:ty => $tr:ty $(, $flag:ident)? ) => { ... };
}
```

### Usage
This macro can be invoked in three main forms:

1.  `register!($ty:ty => $tr:ty $(, $flag:ident)?);`
    Registers the type `$ty` with the trait `$tr`, optionally including a flag `$flag`.

2.  `register!($reg:path: $ty:ty => $tr:ty $(, $flag:ident)?);`
    Registers the type `$ty` with the trait `$tr` using the registry specified by the path `$reg`, optionally including a flag `$flag`.

3.  `register!($name:ident, $reg:path: $ty:ty => $tr:ty $(, $flag:ident)?);`
    Registers the type `$ty` with the trait `$tr` using the registry specified by the path `$reg`, with an identifier `$name`, optionally including a flag `$flag`.
```

--------------------------------

### Registry Implementation (With Std)

Source: https://docs.rs/crosstrait/latest/src/crosstrait/lib.rs.html

Defines the `Registry` struct using `std::collections::HashMap` for environments with `std`. It stores type-trait mappings.

```rust
pub struct Registry<'a>(std::collections::HashMap<[TypeId; 2], &'a (dyn Any + Send + Sync)>);
```

--------------------------------

### Build Caster (No Alloc/Std)

Source: https://docs.rs/crosstrait/latest/src/crosstrait/lib.rs.html

This macro defines the `Caster` struct for environments without `alloc` or `std`. It includes functions for downcasting references.

```rust
macro_rules! caster {
    ( $ty:ty => $tr:ty $(, $flag:ident)? ) => {
        $crate::Caster::<$tr> {
            ref_: |any| any.downcast_ref::<$ty>().map(|t| t as _),
            mut_: |any| any.downcast_mut::<$ty>().map(|t| t as _),
        }
    };
}
```

--------------------------------

### Registry Implementation (No Std)

Source: https://docs.rs/crosstrait/latest/src/crosstrait/lib.rs.html

Defines the `Registry` struct using `heapless::FnvIndexMap` for environments without `std`. It stores type-trait mappings.

```rust
pub struct Registry<'a>(
    // TODO: fixed size map, ~6kB RAM
    // Note that each key is size_of([TypeId; 2]) = 32 bytes.
    // Maybe risk collisions and reduce key size, reduce hash size, or use LinearMap
    heapless::FnvIndexMap<[TypeId; 2], &'a (dyn Any + Send + Sync), { 1 << 7 }>,
);
```

--------------------------------

### Add crosstrait Dependency

Source: https://docs.rs/crosstrait/latest/crosstrait/index.html

Add the crosstrait crate to your Cargo.toml file to use its functionality.

```toml
[dependencies]
crosstrait = "0.1"

```

--------------------------------

### Add crosstrait Dependency

Source: https://docs.rs/crosstrait/latest/crosstrait

Add the crosstrait crate to your Cargo.toml file to use its features.

```toml
[dependencies]
crosstrait = "0.1"
```

--------------------------------

### impl<T: ?Sized + 'static> Cast<Box<T>> for Box<dyn Any>

Source: https://docs.rs/crosstrait/latest/crosstrait/trait.Cast.html

Implementation of Cast for casting a `Box<dyn Any>` to a `Box<T>`. Available on `alloc` feature only.

```APIDOC
## impl<T: ?Sized + 'static> Cast<Box<T>> for Box<dyn Any>

### Description
Implementation of Cast for casting a `Box<dyn Any>` to a `Box<T>`. Available on `alloc` feature only.

### Method
```rust
fn cast(self) -> Option<Box<T>>
```
```

--------------------------------

### Macro for Registering Types

Source: https://docs.rs/crosstrait/latest/src/crosstrait/global.rs.html

A macro to register types and their associated traits within the global registry.

```APIDOC
## register! macro

### Description
Macro to register a type with a trait in the global type-trait registry.

### Syntax
```rust
register! { $ty:ty => $tr:ty $(, $flag:ident)? }
register! { $reg:path: $ty:ty => $tr:ty $(, $flag:ident)? }
```

### Parameters
- `$ty`: The concrete type to register.
- `$tr`: The trait object type to associate with the concrete type.
- `$reg`: (Optional) The specific registry slice to use (defaults to `REGISTRY_KV`).
- `$flag`: (Optional) A feature flag associated with the registration.

### Example
```rust
use crosstrait::register;

// Example of registering a type and trait
// Assuming MyType and MyTrait are defined elsewhere
// register! { MyType => MyTrait }

// Example with a specific registry and flag
// register! { my_custom_registry: MyType => MyTrait, some_feature }
```
```

--------------------------------

### Register Macro for Type-Trait Entries

Source: https://docs.rs/crosstrait/latest/src/crosstrait/global.rs.html

The `register!` macro simplifies adding type-trait entries to the global registry. It supports different forms for specifying the registry path and optional flags.

```rust
/// Register a type and target trait in the registry
#[macro_export]
macro_rules! register {
    ( $ty:ty => $tr:ty $(, $flag:ident)? ) => {
        $crate::register! { $crate::REGISTRY_KV: $ty => $tr $(, $flag)? }
    };
    ( $reg:path: $ty:ty => $tr:ty $(, $flag:ident)? ) => {
        $crate::gensym! { $crate::register!{ $reg: $ty => $tr $(, $flag)? } }
    };
    ( $name:ident, $reg:path: $ty:ty => $tr:ty $(, $flag:ident)? ) => {
        #[$crate::linkme::distributed_slice($reg)]
        #[linkme(crate=$crate::linkme)]
        static $name: $crate::Entry<'static> = $crate::entry!( $ty => $tr $(, $flag)? );
    };
}
```

--------------------------------

### Register Type and Trait

Source: https://docs.rs/crosstrait/latest/crosstrait/macro.register.html

Use this macro to register a type and its target trait in the registry. An optional flag can be provided.

```rust
macro_rules! register {
    ( $ty:ty => $tr:ty $(, $flag:ident)? ) => { ... };
    ( $reg:path: $ty:ty => $tr:ty $(, $flag:ident)? ) => { ... };
    ( $name:ident, $reg:path: $ty:ty => $tr:ty $(, $flag:ident)? ) => { ... };
}
```

--------------------------------

### Define an entry for the type-trait registry

Source: https://docs.rs/crosstrait/latest/crosstrait/macro.entry.html

Use this macro to define an entry for the type-trait registry. It takes a type and a trait as arguments, with an optional flag.

```rust
macro_rules! entry {
    ( $ty:ty => $tr:ty $(, $flag:ident)? ) => { ... };
}
```

--------------------------------

### Registry New Function

Source: https://docs.rs/crosstrait/latest/src/crosstrait/lib.rs.html

Constructs a new `Registry` from an iterator of entry pairs. It lazily evaluates the `TypeId` makers.

```rust
pub fn new<'b>(it: impl IntoIterator<Item = &'b Entry<'a>>) -> Self
where
    'a: 'b,
{
    Self(
        it.into_iter()
            .map(|(key, value)| ((*key)(), *value))
            .collect(),
    )
}
```

--------------------------------

### impl<T: ?Sized + 'static> Cast<Rc<T>> for Rc<dyn Any>

Source: https://docs.rs/crosstrait/latest/crosstrait/trait.Cast.html

Implementation of Cast for casting an `Rc<dyn Any>` to an `Rc<T>`. Available on `alloc` feature only.

```APIDOC
## impl<T: ?Sized + 'static> Cast<Rc<T>> for Rc<dyn Any>

### Description
Implementation of Cast for casting an `Rc<dyn Any>` to an `Rc<T>`. Available on `alloc` feature only.

### Method
```rust
fn cast(self) -> Option<Rc<T>>
```
```

--------------------------------

### Cast dyn Any to Box<T>

Source: https://docs.rs/crosstrait/latest/crosstrait/trait.Cast.html

Implementation of Cast for casting a `Box<dyn Any>` to a `Box<T>`. Requires the 'alloc' feature.

```rust
impl<T: ?Sized + 'static> Cast<Box<T>> for Box<dyn Any>
Available on **crate feature`alloc`** only.
Source§
#### fn cast(self) -> Option<Box<T>>
```

--------------------------------

### Global Registry Access

Source: https://docs.rs/crosstrait/latest/src/crosstrait/global.rs.html

Provides access to the global static type-trait registry.

```APIDOC
## REGISTRY

### Description
The global static `Registry` instance used for type-to-trait mappings.

### Usage
This `Lazy<Registry<'static>>` is initialized on first access and provides the backing store for casting operations.

### Example
```rust
use crosstrait::REGISTRY;

// Accessing the registry directly is usually not needed, 
// as the Castable and Cast traits use it internally.
// However, you can inspect it if necessary.
println!("Registry initialized: {}", REGISTRY.is_lazy());
```
```

--------------------------------

### Debug implementation for Registry

Source: https://docs.rs/crosstrait/latest/crosstrait/struct.Registry.html

Implements the `Debug` trait for `Registry`, allowing it to be formatted for debugging purposes.

```rust
fn fmt(&self, f: &mut Formatter<'_>) -> Result
```

--------------------------------

### Register Type-Trait Implementations

Source: https://docs.rs/crosstrait/latest/crosstrait/index.html

Use the `register!` macro to inform the registry about type-trait implementations. This macro verifies implementations at compile time. It supports registering foreign types and traits, and can be configured with `no_arc` for types that are not `Send + Sync`.

```rust
use core::any::Any;
use crosstrait::{Cast, Castable, CastableRef, entry, register, REGISTRY, Registry};

// Some example traits to play with
use core::{fmt::{Debug, Formatter, Write}, ops::{AddAssign, SubAssign}};

// Add types and trait implementations to the default registry
// Implementation status is verified at compile time
register! { i32 => dyn Debug }

// Registering foreign types and traits works fine
// Serialization/deserialization of `dyn Any` is a major use case
// register! { i32 => dyn erased_serde::Serialize }

// If a type is not Send + Sync, it can't cast as Arc.
// `no_arc` accounts for that
register! { Formatter => dyn Write, no_arc }

// Check for trait impl registration on concrete type
assert!(i32::castable::<dyn Debug>());

// Check for trait impl registration on Any
let any: &dyn Any = &42i32;
assert!(any.castable::<dyn Debug>());

// SubAssign<i32> is impl'd for i32 but not registered
assert!(!any.castable::<dyn SubAssign<i32>>());

// Cast ref
let a: &dyn Debug = any.cast().unwrap();
println!("42 = {{a:?}}");

// Cast mut
let mut value = 5i32;
let any: &mut dyn Any = &mut value;
let v: &mut dyn AddAssign<i32> = any.cast().unwrap();
*v += 3;
assert_eq!(value, 5 + 3);

// Cast Box
let any: Box<dyn Any> = Box::new(0i32);
let _: Box<dyn Debug> = any.cast().unwrap();

// Cast Rc
use std::rc::Rc;
let any: Rc<dyn Any> = Rc::new(0i32);
let _: Rc<dyn Debug> = any.cast().unwrap();

// Cast Arc
use std::sync::Arc;
let any: Arc<dyn Any + Sync + Send> = Arc::new(0i32);
let _: Arc<dyn Debug> = any.cast().unwrap();

// Explicit registry usage
let any: &dyn Any = &0i32;
let _: &dyn Debug = REGISTRY.cast_ref(any).unwrap();

// Custom non-static registry
let myreg = Registry::new(&[entry!(i32 => dyn Debug)]);
let _: &dyn Debug = myreg.cast_ref(any).unwrap();

// Autotraits and type/const generics are distinct
let a: Option<&(dyn Debug + Sync)> = any.cast();
assert!(a.is_none());

// Registration in the default registry can happen anywhere
// in any order in any downstream crate
register! { i32 => dyn AddAssign<i32> }

```

--------------------------------

### Register Type and Trait with Default Registry

Source: https://docs.rs/crosstrait/latest/crosstrait

Use the `register!` macro to associate a concrete type with a trait in the global registry. This enables casting operations for the registered type-trait pair. The implementation status is verified at compile time.

```rust
use core::any::Any;
use crosstrait::{Cast, Castable, CastableRef, entry, register, REGISTRY, Registry};

// Some example traits to play with
use core::{fmt::{Debug, Formatter, Write}, ops::{AddAssign, SubAssign}};

// Add types and trait implementations to the default registry
// Implementation status is verified at compile time
register! { i32 => dyn Debug }

// Registering foreign types and traits works fine
// Serialization/deserialization of `dyn Any` is a major use case
// register! { i32 => dyn erased_serde::Serialize }

// If a type is not Send + Sync, it can't cast as Arc.
// `no_arc` accounts for that
register! { Formatter => dyn Write, no_arc }
```

--------------------------------

### Cast dyn Any to Rc<T>

Source: https://docs.rs/crosstrait/latest/crosstrait/trait.Cast.html

Implementation of Cast for casting a `Rc<dyn Any>` to a `Rc<T>`. Requires the 'alloc' feature.

```rust
impl<T: ?Sized + 'static> Cast<Rc<T>> for Rc<dyn Any>
Available on **crate feature`alloc`** only.
Source§
#### fn cast(self) -> Option<Rc<T>>
```

--------------------------------

### impl<T: ?Sized + 'static> Cast<Arc<T>> for Arc<dyn Any + Sync + Send>

Source: https://docs.rs/crosstrait/latest/crosstrait/trait.Cast.html

Implementation of Cast for casting an `Arc<dyn Any + Sync + Send>` to an `Arc<T>`. Available on `alloc` feature only.

```APIDOC
## impl<T: ?Sized + 'static> Cast<Arc<T>> for Arc<dyn Any + Sync + Send>

### Description
Implementation of Cast for casting an `Arc<dyn Any + Sync + Send>` to an `Arc<T>`. Available on `alloc` feature only.

### Method
```rust
fn cast(self) -> Option<Arc<T>>
```
```

--------------------------------

### Cast dyn Any to &mut T

Source: https://docs.rs/crosstrait/latest/crosstrait/trait.Cast.html

Implementation of Cast for casting a `&mut dyn Any` to a `&mut T`.

```rust
impl<'b, T: ?Sized + 'static> Cast<&'b mut T> for &'b mut dyn Any
Source§
#### fn cast(self) -> Option<&'b mut T>
```

--------------------------------

### Global Type-Trait Registry

Source: https://docs.rs/crosstrait/latest/src/crosstrait/global.rs.html

The global static registry is initialized lazily using `once_cell::sync::Lazy`. It aggregates entries from `REGISTRY_KV` which is populated by `linkme::distributed_slice`.

```rust
use core::any::Any;

#[cfg(feature = "alloc")]
extern crate alloc;
#[cfg(feature = "alloc")]
use alloc::{boxed::Box, rc::Rc, sync::Arc};

use once_cell::sync::Lazy;

#[doc(hidden)]
pub use linkme;

use crate::{Entry, Registry};

/// Static slice of key maker fns and Caster trait objects
#[doc(hidden)]
#[linkme::distributed_slice]
pub static REGISTRY_KV: [Entry<'static>];

/// The global static type-trait registry
pub static REGISTRY: Lazy<Registry<'static>> = Lazy::new(|| Registry::new(REGISTRY_KV));
```

--------------------------------

### Cast dyn Any to Arc<T>

Source: https://docs.rs/crosstrait/latest/crosstrait/trait.Cast.html

Implementation of Cast for casting a `Arc<dyn Any + Sync + Send>` to a `Arc<T>`. Requires the 'alloc' feature.

```rust
impl<T: ?Sized + 'static> Cast<Arc<T>> for Arc<dyn Any + Sync + Send>
Available on **crate feature`alloc`** only.
Source§
#### fn cast(self) -> Option<Arc<T>>
```

--------------------------------

### fn cast(self) -> Option<T>

Source: https://docs.rs/crosstrait/latest/crosstrait/trait.Cast.html

Cast a `dyn Any` (reference or smart pointer) to a given trait object.

```APIDOC
## fn cast(self) -> Option<T>

### Description
Cast a `dyn Any` (reference or smart pointer) to a given trait object.

### Signature
```rust
fn cast(self) -> Option<T>
```
```

--------------------------------

### Explicit Registry Casting

Source: https://docs.rs/crosstrait/latest/crosstrait

Use a specific `Registry` instance to perform casting operations, rather than relying on the global `REGISTRY`. This allows for more controlled and isolated casting environments.

```rust
// Explicit registry usage
let any: &dyn Any = &0i32;
let _: &dyn Debug = REGISTRY.cast_ref(any).unwrap();

// Custom non-static registry
let myreg = Registry::new(&[entry!(i32 => dyn Debug)]);
let _: &dyn Debug = myreg.cast_ref(any).unwrap();
```

--------------------------------

### Static REGISTRY Declaration

Source: https://docs.rs/crosstrait/latest/crosstrait/static.REGISTRY.html

This is the declaration of the global static type-trait registry. It is lazily initialized.

```rust
pub static REGISTRY: Lazy<Registry<'static>>
```

--------------------------------

### Register Type and Trait with crosstrait

Source: https://docs.rs/crosstrait/latest/index.html

Use the `register!` macro to associate a concrete type with a trait object in the registry. This enables casting. Compile-time verification ensures trait implementations exist.

```rust
use core::any::Any;
use crosstrait::{Cast, Castable, CastableRef, entry, register, REGISTRY, Registry};

// Some example traits to play with
use core::{fmt::{Debug, Formatter, Write}, ops::{AddAssign, SubAssign}};

// Add types and trait implementations to the default registry
// Implementation status is verified at compile time
register! { i32 => dyn Debug }

// Registering foreign types and traits works fine
// Serialization/deserialization of `dyn Any` is a major use case
// register! { i32 => dyn erased_serde::Serialize }

// If a type is not Send + Sync, it can't cast as Arc.
// `no_arc` accounts for that
register! { Formatter => dyn Write, no_arc }

// Check for trait impl registration on concrete type
assert!(i32::castable::<dyn Debug>());

// Check for trait impl registration on Any
let any: &dyn Any = &42i32;
assert!(any.castable::<dyn Debug>());

// SubAssign<i32> is impl'd for i32 but not registered
assert!(!any.castable::<dyn SubAssign<i32>>());

// Cast ref
let a: &dyn Debug = any.cast().unwrap();
println!("42 = {{:?}}", a);

// Cast mut
let mut value = 5i32;
let any: &mut dyn Any = &mut value;
let v: &mut dyn AddAssign<i32> = any.cast().unwrap();
*v += 3;
assert_eq!(value, 5 + 3);

// Cast Box
let any: Box<dyn Any> = Box::new(0i32);
let _: Box<dyn Debug> = any.cast().unwrap();

// Cast Rc
use std::rc::Rc;
let any: Rc<dyn Any> = Rc::new(0i32);
let _: Rc<dyn Debug> = any.cast().unwrap();

// Cast Arc
use std::sync::Arc;
let any: Arc<dyn Any + Sync + Send> = Arc::new(0i32);
let _: Arc<dyn Debug> = any.cast().unwrap();

// Explicit registry usage
let any: &dyn Any = &0i32;
let _: &dyn Debug = REGISTRY.cast_ref(any).unwrap();

// Custom non-static registry
let myreg = Registry::new(&[entry!(i32 => dyn Debug)]);
let _: &dyn Debug = myreg.cast_ref(any).unwrap();

// Autotraits and type/const generics are distinct
let a: Option<&(dyn Debug + Sync)> = any.cast();
assert!(a.is_none());

// Registration in the default registry can happen anywhere
// in any order in any downstream crate
register! { i32 => dyn AddAssign<i32> }
```

--------------------------------

### Check Trait Implementation Registration

Source: https://docs.rs/crosstrait/latest/crosstrait

Verify if a trait implementation is registered for a concrete type or a `dyn Any` object using `castable`. This is useful for checking capabilities before attempting a cast.

```rust
// Check for trait impl registration on concrete type
assert!(i32::castable::<dyn Debug>());

// Check for trait impl registration on Any
let any: &dyn Any = &42i32;
assert!(any.castable::<dyn Debug>());

// SubAssign<i32> is impl'd for i32 but not registered
assert!(!any.castable::<dyn SubAssign<i32>>());
```

--------------------------------

### TryInto trait implementation

Source: https://docs.rs/crosstrait/latest/crosstrait/struct.Registry.html

Implements `TryInto<U>` for `T` when `U` implements `TryFrom<T>`, providing a fallible conversion method.

```rust
type Error = <U as TryFrom<T>>::Error
```

```rust
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
```

--------------------------------

### CastableRef Implementation for &dyn Any

Source: https://docs.rs/crosstrait/latest/crosstrait/trait.CastableRef.html

This snippet shows the implementation of the `CastableRef` trait for the `&dyn Any` type. It allows checking castability for any type that implements `Any`.

```rust
impl CastableRef for &dyn Any {
    // Required method
    fn castable<T: ?Sized + 'static>(self) -> bool;
}
```

--------------------------------

### impl<'b, T: ?Sized + 'static> Cast<&'b T> for &'b dyn Any

Source: https://docs.rs/crosstrait/latest/crosstrait/trait.Cast.html

Implementation of Cast for casting a reference to `dyn Any` to a reference of a trait object.

```APIDOC
## impl<'b, T: ?Sized + 'static> Cast<&'b T> for &'b dyn Any

### Description
Implementation of Cast for casting a reference to `dyn Any` to a reference of a trait object.

### Method
```rust
fn cast(self) -> Option<&'b T>
```
```

--------------------------------

### Into trait implementation

Source: https://docs.rs/crosstrait/latest/crosstrait/struct.Registry.html

Implements the `Into<U>` trait for `T` when `U` implements `From<T>`, allowing conversion from `T` to `U`.

```rust
fn into(self) -> U
```

--------------------------------

### Castable Method Signature

Source: https://docs.rs/crosstrait/latest/crosstrait/trait.Castable.html

The signature for the castable method. It returns a boolean indicating castability to a trait object.

```rust
fn castable<T: ?Sized + 'static>() -> bool;
```

--------------------------------

### Register Type and Trait with Crosstrait

Source: https://docs.rs/crosstrait

Use the `register!` macro to associate a concrete type with a trait object in the registry. This enables casting operations. For types not Send + Sync, use `no_arc`.

```rust
use core::any::Any;
use crosstrait::{Cast, Castable, CastableRef, entry, register, REGISTRY, Registry};

// Some example traits to play with
use core::{fmt::{Debug, Formatter, Write}, ops::{AddAssign, SubAssign}};

// Add types and trait implementations to the default registry
// Implementation status is verified at compile time
register! { i32 => dyn Debug }

// Registering foreign types and traits works fine
// Serialization/deserialization of `dyn Any` is a major use case
// register! { i32 => dyn erased_serde::Serialize }

// If a type is not Send + Sync, it can't cast as Arc.
// `no_arc` accounts for that
register! { Formatter => dyn Write, no_arc }
```

```rust
// Check for trait impl registration on concrete type
assert!(i32::castable::<dyn Debug>());

// Check for trait impl registration on Any
let any: &dyn Any = &42i32;
assert!(any.castable::<dyn Debug>());

// SubAssign<i32> is impl'd for i32 but not registered
assert!(!any.castable::<dyn SubAssign<i32>>());
```

```rust
// Cast ref
let a: &dyn Debug = any.cast().unwrap();
println!("42 = {{:?}}", a);
```

```rust
// Cast mut
let mut value = 5i32;
let any: &mut dyn Any = &mut value;
let v: &mut dyn AddAssign<i32> = any.cast().unwrap();
*v += 3;
assert_eq!(value, 5 + 3);
```

```rust
// Cast Box
let any: Box<dyn Any> = Box::new(0i32);
let _: Box<dyn Debug> = any.cast().unwrap();
```

```rust
// Cast Rc
use std::rc::Rc;
let any: Rc<dyn Any> = Rc::new(0i32);
let _: Rc<dyn Debug> = any.cast().unwrap();
```

```rust
// Cast Arc
use std::sync::Arc;
let any: Arc<dyn Any + Sync + Send> = Arc::new(0i32);
let _: Arc<dyn Debug> = any.cast().unwrap();
```

```rust
// Explicit registry usage
let any: &dyn Any = &0i32;
let _: &dyn Debug = REGISTRY.cast_ref(any).unwrap();
```

```rust
// Custom non-static registry
let myreg = Registry::new(&[entry!(i32 => dyn Debug)]);
let _: &dyn Debug = myreg.cast_ref(any).unwrap();
```

```rust
// Autotraits and type/const generics are distinct
let a: Option<&(dyn Debug + Sync)> = any.cast();
assert!(a.is_none());
```

```rust
// Registration in the default registry can happen anywhere
// in any order in any downstream crate
register! { i32 => dyn AddAssign<i32> }
```

--------------------------------

### Cast dyn Any to &T

Source: https://docs.rs/crosstrait/latest/crosstrait/trait.Cast.html

Implementation of Cast for casting a `&dyn Any` to a `&T`.

```rust
impl<'b, T: ?Sized + 'static> Cast<&'b T> for &'b dyn Any
Source§
#### fn cast(self) -> Option<&'b T>
```

--------------------------------

### impl<'b, T: ?Sized + 'static> Cast<&'b mut T> for &'b mut dyn Any

Source: https://docs.rs/crosstrait/latest/crosstrait/trait.Cast.html

Implementation of Cast for casting a mutable reference to `dyn Any` to a mutable reference of a trait object.

```APIDOC
## impl<'b, T: ?Sized + 'static> Cast<&'b mut T> for &'b mut dyn Any

### Description
Implementation of Cast for casting a mutable reference to `dyn Any` to a mutable reference of a trait object.

### Method
```rust
fn cast(self) -> Option<&'b mut T>
```
```

--------------------------------

### Any trait implementation

Source: https://docs.rs/crosstrait/latest/crosstrait/struct.Registry.html

Implements the `Any` trait for any type `T` that is `'static`, providing runtime type identification.

```rust
fn type_id(&self) -> TypeId
```

--------------------------------

### Cast Trait Implementation for Box<dyn Any>

Source: https://docs.rs/crosstrait/latest/src/crosstrait/global.rs.html

Implements the `Cast` trait for `Box<dyn Any>` to cast it to `Box<T>`. This feature requires the `alloc` feature to be enabled.

```rust
#[cfg(feature = "alloc")]
impl<T: ?Sized + 'static> Cast<Box<T>> for Box<dyn Any> {
    fn cast(self) -> Option<Box<T>> {
        REGISTRY.cast_box(self).ok()
    }
}
```

--------------------------------

### Registry struct definition

Source: https://docs.rs/crosstrait/latest/crosstrait/struct.Registry.html

Defines the Registry struct, which is used to store and manage type-trait mappings. It has private fields.

```rust
pub struct Registry<'a>(/* private fields */);
```

--------------------------------

### From trait implementation

Source: https://docs.rs/crosstrait/latest/crosstrait/struct.Registry.html

Implements the `From<T>` trait for `T` itself, meaning a value can be converted into itself.

```rust
fn from(t: T) -> T
```

--------------------------------

### Cast `dyn Any` to Trait Object Reference

Source: https://docs.rs/crosstrait/latest/crosstrait

Use the `cast()` method on a `dyn Any` reference to obtain a reference to another trait object. This operation returns an `Option` which is `None` if the cast is not possible.

```rust
// Cast ref
let a: &dyn Debug = any.cast().unwrap();
println!("42 = {a:?}");
```

--------------------------------

### Cast Any to a boxed trait object

Source: https://docs.rs/crosstrait/latest/crosstrait/struct.Registry.html

Casts a `Box<dyn Any>` to a `Box<T>`, consuming the original box. Returns an error containing the original box if the cast fails. The target trait `T` must be `'static`.

```rust
pub fn cast_box<T: ?Sized + 'static>( &self, any: Box<dyn Any>, ) -> Result<Box<T>, Box<dyn Any>>
```

--------------------------------

### TryFrom trait implementation

Source: https://docs.rs/crosstrait/latest/crosstrait/struct.Registry.html

Implements `TryFrom<U>` for `T` when `U` implements `Into<T>`, providing a fallible conversion method. The error type is `Infallible`.

```rust
type Error = Infallible
```

```rust
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
```

--------------------------------

### Cast `Box<dyn Any>`

Source: https://docs.rs/crosstrait/latest/crosstrait

Cast a `Box<dyn Any>` to a `Box<dyn Trait>`. This operation consumes the original box and returns a new box containing the trait object if the cast is successful.

```rust
// Cast Box
let any: Box<dyn Any> = Box::new(0i32);
let _: Box<dyn Debug> = any.cast().unwrap();
```

--------------------------------

### Cast Trait Implementation for &dyn Any (Reference)

Source: https://docs.rs/crosstrait/latest/src/crosstrait/global.rs.html

Implements the `Cast` trait for `&'b dyn Any` to cast it to a reference `&'b T`. Returns `None` if the cast is not possible.

```rust
/// Cast an `dyn Any` to another given trait object
///
/// Uses the global type-trait registry.
pub trait Cast<T> {
    /// Cast a `dyn Any` (reference or smart pointer) to a given trait object
    fn cast(self) -> Option<T>;
}

impl<'b, T: ?Sized + 'static> Cast<&'b T> for &'b dyn Any {
    fn cast(self) -> Option<&'b T> {
        REGISTRY.cast_ref(self)
    }
}
```

--------------------------------

### Cast Trait

Source: https://docs.rs/crosstrait/latest/src/crosstrait/global.rs.html

Provides a method to cast `dyn Any` references or smart pointers to a specified trait object.

```APIDOC
## Cast<T>

### Description
Trait to cast a `dyn Any` reference or smart pointer to a given trait object `T`.

### Methods
#### `cast(self) -> Option<T>`
Attempts to cast `self` to the target trait object `T`. Returns `Some(T)` on success, `None` otherwise.

### Implementations
- `impl<'b, T: ?Sized + 'static> Cast<&'b T> for &'b dyn Any`
- `impl<'b, T: ?Sized + 'static> Cast<&'b mut T> for &'b mut dyn Any`
- `impl<T: ?Sized + 'static> Cast<Box<T>> for Box<dyn Any>` (requires `alloc` feature)
- `impl<T: ?Sized + 'static> Cast<Rc<T>> for Rc<dyn Any>` (requires `alloc` feature)
- `impl<T: ?Sized + 'static> Cast<Arc<T>> for Arc<dyn Any + Sync + Send>` (requires `alloc` feature)

### Example
```rust
use crosstrait::Cast;

let value: &dyn Any = &10i32;
if let Some(num) = value.cast::<&i32>() {
    println!("Casted to i32: {}", num);
}

#[cfg(feature = "alloc")]
{
    let boxed_value: Box<dyn Any> = Box::new(20i32);
    if let Some(num) = boxed_value.cast::<Box<i32>>() {
        println!("Casted Box to Box<i32>: {}", num);
    }
}
```
```

--------------------------------

### Cast Trait Implementation for Rc<dyn Any>

Source: https://docs.rs/crosstrait/latest/src/crosstrait/global.rs.html

Implements the `Cast` trait for `Rc<dyn Any>` to cast it to `Rc<T>`. This feature requires the `alloc` feature to be enabled.

```rust
#[cfg(feature = "alloc")]
impl<T: ?Sized + 'static> Cast<Rc<T>> for Rc<dyn Any> {
    fn cast(self) -> Option<Rc<T>> {
        REGISTRY.cast_rc(self).ok()
    }
}
```

--------------------------------

### Cast Trait Implementation for &mut dyn Any (Mutable Reference)

Source: https://docs.rs/crosstrait/latest/src/crosstrait/global.rs.html

Implements the `Cast` trait for `&'b mut dyn Any` to cast it to a mutable reference `&'b mut T`. Returns `None` if the cast is not possible.

```rust
impl<'b, T: ?Sized + 'static> Cast<&'b mut T> for &'b mut dyn Any {
    fn cast(self) -> Option<&'b mut T> {
        REGISTRY.cast_mut(self)
    }
}
```

--------------------------------

### Cast `Arc<dyn Any + Sync + Send>`

Source: https://docs.rs/crosstrait/latest/crosstrait

Cast an `Arc<dyn Any + Sync + Send>` to an `Arc<dyn Trait>`. This is used for thread-safe shared ownership scenarios.

```rust
// Cast Arc
use std::sync::Arc;
let any: Arc<dyn Any + Sync + Send> = Arc::new(0i32);
let _: Arc<dyn Debug> = any.cast().unwrap();
```

--------------------------------

### Registry::cast_box

Source: https://docs.rs/crosstrait/latest/crosstrait/struct.Registry.html

Casts to a boxed trait object.

```APIDOC
## Registry::cast_box

### Description
Cast to a boxed trait object.

### Signature
```rust
pub fn cast_box<T: ?Sized + 'static>( &self, any: Box<dyn Any>, ) -> Result<Box<T>, Box<dyn Any>>
```
```

--------------------------------

### CastableRef Trait Implementation for &dyn Any

Source: https://docs.rs/crosstrait/latest/src/crosstrait/global.rs.html

Implements the `CastableRef` trait for `&dyn Any`, allowing checks if a reference to a dynamic Any can be cast to a specified trait object using the global registry.

```rust
/// Whether a `dyn Any` can be cast to a given trait object
pub trait CastableRef {
    /// Whether we can be cast to a given trait object
    fn castable<T: ?Sized + 'static>(self) -> bool;
}

impl CastableRef for &dyn Any {
    fn castable<T: ?Sized + 'static>(self) -> bool {
        REGISTRY.castable_ref::<T>(self)
    }
}
```

--------------------------------

### Cast Any to a mutable trait object reference

Source: https://docs.rs/crosstrait/latest/crosstrait/struct.Registry.html

Safely casts a mutable `dyn Any` reference to a mutable reference of the target trait `T`. Returns `None` if the cast fails. The target trait `T` must be `'static`.

```rust
pub fn cast_mut<'b, T: ?Sized + 'static>( &self, any: &'b mut dyn Any, ) -> Option<&'b mut T>
```

--------------------------------

### Cast Any to an immutable trait object reference

Source: https://docs.rs/crosstrait/latest/crosstrait/struct.Registry.html

Safely casts a `dyn Any` reference to an immutable reference of the target trait `T`. Returns `None` if the cast fails. The target trait `T` must be `'static`.

```rust
pub fn cast_ref<'b, T: ?Sized + 'static>( &self, any: &'b dyn Any, ) -> Option<&'b T>
```

--------------------------------

### Cast Any to a ref-counted trait object

Source: https://docs.rs/crosstrait/latest/crosstrait/struct.Registry.html

Casts an `Rc<dyn Any>` to an `Rc<T>`, consuming the original `Rc`. Returns an error containing the original `Rc` if the cast fails. The target trait `T` must be `'static`.

```rust
pub fn cast_rc<T: ?Sized + 'static>( &self, any: Rc<dyn Any>, ) -> Result<Rc<T>, Rc<dyn Any>>
```

--------------------------------

### CastableRef Trait

Source: https://docs.rs/crosstrait/latest/crosstrait/trait.CastableRef.html

Trait definition for CastableRef.

```APIDOC
## Trait CastableRef

Trait definition for CastableRef.

### Summary
```rust
pub trait CastableRef {
    fn castable<T: ?Sized + 'static>(self) -> bool;
}
```

### Required Methods

#### fn castable<T: ?Sized + 'static>(self) -> bool
Whether we can be cast to a given trait object.

### Dyn Compatibility
This trait is **not** dyn compatible. In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

### Implementations on Foreign Types

#### impl CastableRef for &dyn Any

##### fn castable<T: ?Sized + 'static>(self) -> bool

```

--------------------------------

### Cast `dyn Any` Mutable Reference

Source: https://docs.rs/crosstrait/latest/crosstrait

Perform a mutable cast from a `dyn Any` mutable reference to another trait object's mutable reference. This allows modifying the underlying data through the cast trait object.

```rust
// Cast mut
let mut value = 5i32;
let any: &mut dyn Any = &mut value;
let v: &mut dyn AddAssign<i32> = any.cast().unwrap();
*v += 3;
assert_eq!(value, 5 + 3);
```

--------------------------------

### CastableRef Trait

Source: https://docs.rs/crosstrait/latest/src/crosstrait/global.rs.html

Allows checking if a `&dyn Any` can be cast to a specific trait object using the global registry.

```APIDOC
## CastableRef

### Description
Trait to check if a `&dyn Any` can be cast to a given trait object.

### Methods
#### `castable<T: ?Sized + 'static>(self) -> bool`
Checks if the `&dyn Any` can be cast to the trait `T`.

### Example
```rust
use crosstrait::CastableRef;

let value: &dyn Any = &10i32;
if value.castable::<i32>() {
    println!("Can cast to i32");
}
```
```

--------------------------------

### Castable Trait

Source: https://docs.rs/crosstrait/latest/src/crosstrait/global.rs.html

Allows checking if a concrete type can be cast to a specific trait object.

```APIDOC
## Castable

### Description
Trait to check if a concrete type can be cast to a given trait object.

### Methods
#### `castable<T: ?Sized + 'static>() -> bool`
Checks if the implementing type can be cast to the trait `T`.

### Example
```rust
use crosstrait::Castable;

if i32::castable::<i32>() {
    println!("i32 can be cast to i32");
}
```
```

--------------------------------

### Cast Any to an atomically ref-counted trait object

Source: https://docs.rs/crosstrait/latest/crosstrait/struct.Registry.html

Casts an `Arc<dyn Any + Sync + Send>` to an `Arc<T>`, consuming the original `Arc`. Returns an error containing the original `Arc` if the cast fails. The target trait `T` must be `'static`.

```rust
pub fn cast_arc<T: ?Sized + 'static>( &self, any: Arc<dyn Any + Sync + Send>, ) -> Result<Arc<T>, Arc<dyn Any + Sync + Send>>
```

--------------------------------

### Cast `Rc<dyn Any>`

Source: https://docs.rs/crosstrait/latest/crosstrait

Cast an `Rc<dyn Any>` to an `Rc<dyn Trait>`. This operation is suitable for single-threaded scenarios where shared ownership is managed via `Rc`.

```rust
// Cast Rc
use std::rc::Rc;
let any: Rc<dyn Any> = Rc::new(0i32);
let _: Rc<dyn Debug> = any.cast().unwrap();
```

--------------------------------

### Borrow trait implementation

Source: https://docs.rs/crosstrait/latest/crosstrait/struct.Registry.html

Implements the `Borrow` trait for any type `T`, allowing immutable borrowing of `T` from `T` itself.

```rust
fn borrow(&self) -> &T
```

--------------------------------

### BorrowMut trait implementation

Source: https://docs.rs/crosstrait/latest/crosstrait/struct.Registry.html

Implements the `BorrowMut` trait for any type `T`, allowing mutable borrowing of `T` from `T` itself.

```rust
fn borrow_mut(&mut self) -> &mut T
```

--------------------------------

### Registry::castable_ref

Source: https://docs.rs/crosstrait/latest/crosstrait/struct.Registry.html

Checks if an Any type can be cast to a target trait T.

```APIDOC
## Registry::castable_ref

### Description
Whether the `Any` can be cast to the target trait T.

### Signature
```rust
pub fn castable_ref<T: ?Sized + 'static>(&self, any: &dyn Any) -> bool
```
```

--------------------------------

### castable_ref

Source: https://docs.rs/crosstrait/latest/src/crosstrait/lib.rs.html

Checks if an `Any` trait object can be cast to a target trait `T`.

```APIDOC
## castable_ref

### Description
Checks if the `Any` trait object can be cast to the target trait `T`.

### Signature
`pub fn castable_ref<T: ?Sized + 'static>(&self, any: &dyn Any) -> bool`

### Parameters
- `any`: A reference to a dynamic `Any` trait object.

### Returns
`bool`: `true` if the cast is possible, `false` otherwise.
```

--------------------------------

### Check if Any can be cast to a trait

Source: https://docs.rs/crosstrait/latest/crosstrait/struct.Registry.html

Determines if a given `Any` type can be safely cast to the specified trait `T`. The target trait `T` must be `'static`.

```rust
pub fn castable_ref<T: ?Sized + 'static>(&self, any: &dyn Any) -> bool
```

--------------------------------

### cast_box

Source: https://docs.rs/crosstrait/latest/src/crosstrait/lib.rs.html

Casts a boxed `Any` trait object to a boxed trait object of type `T`.

```APIDOC
## cast_box

### Description
Casts a boxed `Any` trait object to a boxed trait object of type `T`.

### Feature
Requires the `alloc` feature to be enabled.

### Signature
`#[cfg(feature = "alloc")]
pub fn cast_box<T: ?Sized + 'static>(&self, any: Box<dyn Any>) -> Result<Box<T>, Box<dyn Any>>`

### Parameters
- `any`: A boxed `Any` trait object.

### Returns
`Result<Box<T>, Box<dyn Any>>`: A `Result` containing a boxed `T` if the cast is successful, otherwise the original boxed `Any` trait object is returned in the `Err` variant.
```

--------------------------------

### fn castable<T: ?Sized + 'static>() -> bool

Source: https://docs.rs/crosstrait/latest/crosstrait/trait.Castable.html

Checks if the current type is castable to the specified trait object. This method is required for types implementing the Castable trait.

```APIDOC
## fn castable<T: ?Sized + 'static>() -> bool

### Description
Whether this type is castable to the given trait object.

### Returns
- `bool`: `true` if the type is castable, `false` otherwise.

### Type Parameters
- `T`: The trait object type to check castability against. `T` must be `?Sized + 'static`.
```
Tokens:
Raw