# Trait bitflags::__core::marker::Reflect [−] [src]

    pub trait Reflect { }

Unstable (`reflect_marker`)

: 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)]
    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".)

## Implementors

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)