core::any - Rust
Description: API documentation for the Rust `any` mod in crate `core`.
Keywords: rust, rustlang, rust-lang, any

# Module core::any 1.0.0[−][src]

This module implements the `Any` trait, which enables dynamic typing of any `'static` type through runtime reflection.

`Any` itself can be used to get a `TypeId`, and has more features when used as a trait object. As `&Any` (a borrowed trait object), it has the `is` and `downcast_ref` methods, to test if the contained value is of a given type, and to get a reference to the inner value as a type. As `&mut Any`, there is also the `downcast_mut` method, for getting a mutable reference to the inner value. `Box<Any>` adds the `downcast` method, which attempts to convert to a `Box<T>`. See the `Box` documentation for the full details.

Note that &Any is limited to testing whether a value is of a specified concrete type, and cannot be used to test whether a type implements a trait.

# Examples

Consider a situation where we want to log out a value passed to a function. We know the value we're working on implements Debug, but we don't know its concrete type. We want to give special treatment to certain types: in this case printing out the length of String values prior to their value. We don't know the concrete type of our value at compile time, so we need to use runtime reflection instead.

    use std::fmt::Debug;
    use std::any::Any;

    // Logger function for any type that implements Debug.
    fn log<T: Any + Debug>(value: &T) {
        let value_any = value as &Any;

        // try to convert our value to a String.  If successful, we want to
        // output the String's length as well as its value.  If not, it's a
        // different type: just print it out unadorned.
        match value_any.downcast_ref::<String>() {
            Some(as_string) => {
                println!("String ({}): {}", as_string.len(), as_string);
            }
            None => {
                println!("{:?}", value);
            }
        }
    }

    // This function wants to log its parameter out prior to doing work with it.
    fn do_work<T: Any + Debug>(value: &T) {
        log(value);
        // ...do some other work
    }

    fn main() {
        let my_string = "Hello World".to_string();
        do_work(&my_string);

        let my_i8: i8 = 100;
        do_work(&my_i8);
    }Run

## Structs

TypeId | A `TypeId` represents a globally unique identifier for a type.

## Traits

Any | A type to emulate dynamic typing.

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## 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`)

Search multiple things at once by splitting your query with comma (e.g. `str,u8` or `String,struct:Vec,test`)