RustのAny特性の理解：Reflectionなしでの型の内省

Preface

For a discussion on why Rust does not introduce runtime reflection, refer to this RFC:

https://internals.rust-lang.org/t/pre-rfc-runtime-reflection/11039

Here is a rough summary:

Dependency Injection (DI) does not necessarily need to be implemented via reflection; Rust can offer better implementations:
The combination of derive macros and traits allows shifting implementation from runtime to compile time;
For example, procedural macros can enable compile-time reflection features, allowing functionalities like dependency injection: https://github.com/dtolnay/reflect

Rust provides the Any trait: all types (including user-defined ones) automatically implement this trait.

Therefore, we can use it to achieve some reflection-like features.

Any Analysis

Below is an explanation of the std::any module:

This module implements the Any trait, which enables dynamic typing of any 'static type through runtime reflection. Any itself can be used to obtain TypeId and, when used as a trait object, it offers more functionality.

As a &dyn Any (a borrowed trait object), it provides the is and downcast_ref methods to check whether the contained value is of a given type and to obtain a reference to the internal value of that type. As a &mut dyn Any, it also provides the downcast_mut method to obtain a mutable reference to the internal value.

Box<dyn Any> adds a downcast method, which attempts to cast it to Box<T>. Note that &dyn Any is limited to checking whether a value is of a specific concrete type and cannot be used to test if a type implements a particular trait.

In summary, std::any provides four main functions:

Obtain the TypeId of a variable;
Check if a variable is of a specific type;
Convert an Any to a specific type;
Retrieve the name of a type.

Below is the source code of the Any trait and the corresponding TypeId type:

pub trait Any: 'static {
    fn type_id(&self) -> TypeId;
}

// Implement Any for all types T with 'static lifetime
#[stable(feature = "rust1", since = "1.0.0")]
impl<T: 'static + ?Sized> Any for T {
    fn type_id(&self) -> TypeId { TypeId::of::<T>() }
}

// Check if a variable is of a specific type
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn is<T: Any>(&self) -> bool {
    let t = TypeId::of::<T>();
    let concrete = self.type_id();
    t == concrete
}

// Convert any to a specific type
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn downcast_ref<T: Any>(&self) -> Option<&T> {
    if self.is::<T>() {
        unsafe {
            Some(&*(self as *const dyn Any as *const T))
        }
    } else {
        None
    }
}

// Get the type name
pub const fn type_name<T: ?Sized>() -> &'static str {
    intrinsics::type_name::<T>()
}

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
pub struct TypeId {
    t: u64,
}

Note: All types with a 'static lifetime implement Any; support for non-'static lifetimes may be considered in the future.

In Rust, each type has a globally unique identifier (A TypeId represents a globally unique identifier for a type).

These TypeIds are generated by calling functions defined in the intrinsic module.

About the intrinsic module:

Intrinsic library functions are those implemented by the compiler itself and typically have the following characteristics:

Highly dependent on CPU architecture and must be implemented using assembly or with assembly support for optimal performance;

Closely tied to the compiler, making compiler implementation most suitable;

Therefore, the generation of type_id is determined by the compiler’s implementation!

For details, see: https://github.com/rust-lang/rust/blob/master/compiler/rustc_codegen_llvm/src/intrinsic.rs

Basic Usage of Any

The previous section mentioned that Any allows:

Obtaining the TypeId of a variable;
Checking if a variable is of a specific type;
Converting an Any to a specific type;
Getting the name of a type;

Let’s look at a concrete example:

use std::any::{Any, TypeId};

struct Person {
    pub name: String,
}

/// Get TypeId
fn is_string(s: &dyn Any) -> bool {
    TypeId::of::<String>() == s.type_id()
}

/// Check if it is a specific type
fn check_string(s: &dyn Any) {
    if s.is::<String>() {
        println!("It's a string!");
    } else {
        println!("Not a string...");
    }
}

/// Convert Any to a specific type
fn print_if_string(s: &dyn Any) {
    if let Some(ss) = s.downcast_ref::<String>() {
        println!("It's a string({}): '{}'", ss.len(), ss);
    } else {
        println!("Not a string...");
    }
}

/// Get type name
/// Note: the returned name is not unique!
/// For example, type_name::<Option<String>>() may return "Option<String>" or "std::option::Option<std::string::String>"
/// and may vary with compiler versions
fn get_type_name<T>(_: &T) -> String {
    std::any::type_name::<T>().to_string()
}

fn main() {
    let p = Person { name: "John".to_string() };
    assert!(!is_string(&p));
    assert!(is_string(&p.name));

    check_string(&p);
    check_string(&p.name);

    print_if_string(&p);
    print_if_string(&p.name);

    println!("Type name of p: {}", get_type_name(&p));
    println!("Type name of p.name: {}", get_type_name(&p.name));
}

Output:

Not a string...
It's a string!
Not a string...
It's a string(4): 'John'
Type name of p: 0_any::Person
Type name of p.name: alloc::string::String

Summary:

/// Get TypeId and compare: type_id
TypeId::of::<String>() == s.type_id()

/// Check if it's a specific type: s.is
s.is::<String>()

/// Convert Any to a specific type: s.downcast_ref
s.downcast_ref::<String>()

/// Get type name: type_name::<T>()
/// The returned name is not unique!
/// For example, type_name::<Option<String>>() may return "Option<String>" or "std::option::Option<std::string::String>"
/// and may vary with compiler versions
std::any::type_name::<T>().to_string()

Use Cases for `Any`

In Rust, Any is similar to Java's Object—you can pass in any type that has a 'static lifetime.

Therefore, in scenarios where function parameters are complex, we can simplify them using Any.

For example, printing the value of any type:

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

#[derive(Debug)]
struct MyType {
    name: String,
    age: u32,
}

fn print_any<T: Any + Debug>(value: &T) {
    let value_any = value as &dyn Any;

    if let Some(string) = value_any.downcast_ref::<String>() {
        println!("String ({}): {}", string.len(), string);
    } else if let Some(MyType { name, age }) = value_any.downcast_ref::<MyType>() {
        println!("MyType ({}, {})", name, age)
    } else {
        println!("{:?}", value)
    }
}

fn main() {
    let ty = MyType {
        name: "Rust".to_string(),
        age: 30,
    };
    let name = String::from("Rust");

    print_any(&ty);
    print_any(&name);
    print_any(&30);
}

As shown above, whether it's a String, a user-defined MyType, or a built-in i32, they can all be printed as long as they implement the Debug trait.

You can think of this as a kind of function overloading in Rust. It’s also useful when reading complex structured configurations—you can directly use Any.

Summary

The any feature is not true runtime reflection—it’s at most compile-time reflection. Rust only enables type checking and type conversion, not introspection of arbitrary structures.

The any mechanism fits the philosophy of zero-cost abstraction, because Rust only generates code for the types that actually invoke the relevant functions. When checking types, it returns the type ID managed internally by the compiler, without any extra overhead. You can even use TypeId::of::<String>() directly, avoiding the dynamic binding overhead of dyn Any.

Although Rust doesn’t offer reflection, procedural macros can implement most of the capabilities that reflection enables!

In fact, early versions of Rust did provide reflection features, but the related code was removed in 2014. The reasons were:

Reflection broke the original principle of encapsulation by allowing arbitrary access to a struct’s contents, making it unsafe;
The presence of reflection made the codebase bloated—removing it greatly simplified the compiler;
The design of the reflection system was relatively weak, and developers were uncertain whether future versions of Rust should still include it;

As for the reason Any is retained:

When debugging code involving generic types, having TypeId makes things easier and allows for clearer error messages;
It helps the compiler optimize code generation.