Trait core::marker::Reflect [−] [src]

pub trait Reflect { }

Unstable (reflect_marker #27749)
: requires RFC and more experience

Types that can be reflected over.

This trait is implemented for all types. Its purpose is to ensure that when you write a generic function that will employ reflection, that must be reflected (no pun intended) in the generic bounds of that function. Here is an example:

#![feature(reflect_marker)] fn main() { use std::marker::Reflect; use std::any::Any; #[allow(dead_code)] fn foo<T: Reflect + 'static>(x: &T) { let any: &Any = x; if any.is::<u32>() { println!("u32"); } } }

#![feature(reflect_marker)]
use std::marker::Reflect;
use std::any::Any;

fn foo<T: Reflect + 'static>(x: &T) {
    let any: &Any = x;
    if any.is::<u32>() { println!("u32"); }
}

Without the declaration T: Reflect, foo would not type check (note: as a matter of style, it would be preferable to write T: Any, because T: Any implies T: Reflect and T: 'static, but we use Reflect here to show how it works). The Reflect bound thus serves to alert foo's caller to the fact that foo may behave differently depending on whether T = u32 or not. In particular, thanks to the Reflect bound, callers know that a function declared like fn bar<T>(...) will always act in precisely the same way no matter what type T is supplied, because there are no bounds declared on T. (The ability for a caller to reason about what a function may do based solely on what generic bounds are declared is often called the "parametricity property".)

Trait core::marker::Reflect [−] [src]

Implementors