Query for entity with 2 component types doesn't compile

[Koettlitz]

I want to write a system that takes in a query for all entities with two specific components:

use bevy::ecs::component::Component;
use bevy::prelude::Query;

fn my_system(_: Query<&A, &B>) { /* execute systems logic */ }

#[derive(Component)]
struct A;

#[derive(Component)]
struct B;

This doesn't compile with the following error:

error[E0271]: type mismatch resolving `for<'w, 's> <ReadFetch<B> as Fetch<'w, 's>>::Item == bool`
   --> src\main.rs:4:17
    |
4   | fn my_system(_: Query<&A, &B>) { /* execute systems logic */ }
    |                 ^^^^^^^^^^^^^ expected `bool`, found `&B`
    |
    = note: required because of the requirements on the impl of `FilterFetch` for `ReadFetch<B>`

I don't really get the error. Why does it expect a bool here?
I'm a very beginner to bevy, so I maybe understand the concept of queries wrong, but I thought a query can be used to get all entities, that have specific components. Is it possible to write such a query?

[nicopap]

You should write Query<(&A, &B)> instead of Query<&A, &B>.

Query<C, F> is a generic type that accepts two type parameters:

• C: What you want to query for
• F: The filters, that can limit what will be in the query.

C will be the things you get in the for loop when iterating over the query:

fn my_system(query: Query<&Transform>) {
    for transform in query.iter() {
        //...
    }
}

Here the "query item" (what the query returns) is of type Transform, and you get a Transform when using query.iter() or query.get.

F are "filter", you still get the query items do not change, but the filters limit which items are retrieved:

// now with filter, only retrieve cameras
fn my_system(query: Query<&Transform, With<Camera>>) {
    for transform in query.iter() {
        //...
    }
}

It is especially useful in combination with a marker component.

#[derive(Component)]
struct MyMarker;

// now with filter, only retrieve entities that have MyMarker component
// Since we do not care about the value of the MyMarker component (because
// it will always be the same), we just use it as a filter in combination with `With`
fn my_system(query: Query<&Transform, With<MyMarker>>) {
    for transform in query.iter() {
        //...
    }
}

The query is filtered based on the "query item" of the filter, which is a true/false answer to the question: should this item be in the iter()? therefore it is a bool. Which explains the error message.

Now what you want is two different components, so you'll want your "query item" to be the two components in a tuple. To do this, you'll have the C part of your query be a tuple containing both the components you want:

// notice the parenthesis
fn my_system(query: Query<(&A, &B)>) {
    for (a, b) in query.iter() {
        //... 
    }
}

[Koettlitz]

Ah I see, thanks! But do the component instances of each tuple belong to the same entity?

[alice-i-cecile]

Yes: each item returned in the query corresponds to a single entity, and only entities with both A and B are returned.

To get all components A and all components B, regardless of whether they coexist, you can either do Query<(Option<&A>, Option<&B>)> or simply add two queries.

[alice-i-cecile]

The correct syntax is:

fn my_system(_: Query<(&A, &B)>) { /* execute systems logic */ }

This is a bit confusing, so let's start at the beginning. Query has two (non-lifetime) type parameters: Q and F. Q defines the data that should be accessed, F declares how it should be filtered.

Each time you use a top-level comma, you're moving onto the next type parameter. However, we use tuples to allow you to create compound types, for "fetch me A and B".

Finally, we use a default type parameter for F of (), which means "no filters". As a result, Query<(&A, &B)> is the same as Query<(&A, &B), ()> where Q = (&A, &B) and F = ().