Let's say you have a trait that you want to implement for some of your components.

# use bevy::prelude::*;
#
/// Components that display a message when hovered.
pub trait Tooltip {
    /// Text displayed when hovering over an entity with this trait.
    fn tooltip(&self) -> &str;
}

In order to be useful within bevy, you'll want to be able to query for this trait.

# use bevy::prelude::*;

// Just add this attribute...
#[bevy_trait_query::queryable]
pub trait Tooltip {
    fn tooltip(&self) -> &str;
}

// ...and now you can use your trait in queries.
fn show_tooltips_system(
    tooltips: Query<&dyn Tooltip>,
    // ...
) {
    // ...
}
# bevy_ecs::system::assert_is_system(show_tooltips_system);

Since Rust unfortunately lacks any kind of reflection, it is necessary to register each component with the trait when the app gets built.

# use bevy::prelude::*;
# use bevy_trait_query::*;
#
# #[bevy_trait_query::queryable]
# pub trait Tooltip {
#     fn tooltip(&self) -> &str;
# }
#
#[derive(Component)]
struct Player(String);

#[derive(Component)]
enum Villager {
    Farmer,
    // ...
}

#[derive(Component)]
struct Monster;

/* ...trait implementations omitted for brevity... */

# impl Tooltip for Player {
#     fn tooltip(&self) -> &str {
#         &self.0
#     }
# }
#
# impl Tooltip for Villager {
#     fn tooltip(&self) -> &str {
#         "Villager"
#     }
# }
#
# impl Tooltip for Monster {
#     fn tooltip(&self) -> &str {
#         "Run!"
#     }
# }
#
struct TooltipPlugin;

impl Plugin for TooltipPlugin {
    fn build(&self, app: &mut App) {
        // We must import this trait in order to register our components.
        // If we don't register them, they will be invisible to the game engine.
        use bevy_trait_query::RegisterExt;

        app
            .register_component_as::<dyn Tooltip, Player>()
            .register_component_as::<dyn Tooltip, Villager>()
            .register_component_as::<dyn Tooltip, Monster>()
            .add_systems(Update, show_tooltips);
    }
}
# fn show_tooltips() {}
#
# fn main() {
#     App::new().add_plugins((DefaultPlugins, TooltipPlugin)).update();
# }

Unlike queries for concrete types, it's possible for an entity to have multiple components that match a trait query.

# use bevy::prelude::*;
# use bevy_trait_query::*;
#
# #[bevy_trait_query::queryable]
# pub trait Tooltip {
#     fn tooltip(&self) -> &str;
# }
#
# #[derive(Component)]
# struct Player(String);
#
# #[derive(Component)]
# struct Monster;
#
# impl Tooltip for Player {
#     fn tooltip(&self) -> &str {
#         &self.0
#     }
# }
#
# impl Tooltip for Monster {
#     fn tooltip(&self) -> &str {
#         "Run!"
#     }
# }
#
# fn main() {
#     App::new()
#         .add_plugins(DefaultPlugins)
#         .register_component_as::<dyn Tooltip, Player>()
#         .register_component_as::<dyn Tooltip, Monster>()
#         .add_systems(Startup, setup)
#         .update();
# }
#
# fn setup(mut commands: Commands) {
#     commands.spawn(Player("Fourier".to_owned()));
#     commands.spawn(Monster);
# }

fn show_tooltips(
    tooltips: Query<&dyn Tooltip>,
    // ...
) {
    // Iterate over each entity that has tooltips.
    for entity_tooltips in &tooltips {
        // Iterate over each component implementing `Tooltip` for the current entity.
        for tooltip in entity_tooltips {
            println!("Tooltip: {}", tooltip.tooltip());
        }
    }

    // If you instead just want to iterate over all tooltips, you can do:
    for tooltip in tooltips.iter().flatten() {
        println!("Tooltip: {}", tooltip.tooltip());
    }
}

Alternatively, if you expect to only have component implementing the trait for each entity, you can use the filter One. This has significantly better performance than iterating over all trait impls.

# use bevy::prelude::*;
# use bevy_trait_query::*;
#
# #[bevy_trait_query::queryable]
# pub trait Tooltip {
#     fn tooltip(&self) -> &str;
# }
#
use bevy_trait_query::One;

fn show_tooltips(
    tooltips: Query<One<&dyn Tooltip>>,
    // ...
) {
    for tooltip in &tooltips {
        println!("Tooltip: {}", tooltip.tooltip());
    }
}
# bevy_ecs::system::assert_is_system(show_tooltips);

Trait queries support basic change detection filtration.

• queries requesting shared access yield ReadTraits which is similar to Ref
• queries requesting exclusive access yield WriteTraits which is similar to Mut

To get all the components that implement the target trait, and have also changed in some way since the last tick, you can:

# use bevy::prelude::*;
# use bevy_trait_query::*;
#
# #[bevy_trait_query::queryable]
# pub trait Tooltip {
#     fn tooltip(&self) -> &str;
# }
#
fn show_tooltips(
    tooltips_query: Query<All<&dyn Tooltip>>
    // tooltips_query: Query<&dyn Tooltip>  // <-- equivalent to line above
    // ...
) {
    // Iterate over all entities with at least one component implementing `Tooltip`
    for entity_tooltips in &tooltips_query {
        // Iterate over each component for the current entity that changed since the last time the system was run.
        for tooltip in entity_tooltips.iter_changed() {
            println!("Changed Tooltip: {}", tooltip.tooltip());
        }
    }
}

Similar to iter_changed, we have iter_added to detect entities which have had a trait-implementing component added since the last tick.

If you know you have only one component that implements the target trait, you can use OneAdded or OneChanged which behave more like the typical bevy Added/Changed filters:

# use bevy::prelude::*;
# use bevy_trait_query::*;
#
# #[bevy_trait_query::queryable]
# pub trait Tooltip {
#     fn tooltip(&self) -> &str;
# }
#
fn show_tooltips(
    tooltips_query: Query<One<&dyn Tooltip>, OneChanged<dyn Tooltip>>
    // ...
) {
    // Iterate over each entity that has one tooltip implementing component that has also changed
    for tooltip in &tooltips_query {
        println!("Changed Tooltip: {}", tooltip.tooltip());
    }
}

Note in the above example how OneChanged does not take a reference to the trait object!

Performance

The performance of trait queries is quite competitive. Here are some benchmarks for simple cases: