Struct Query 

pub struct Query<'a, Q: Query> { /* private fields */ }

Borrow of an ECS query result — a curated wrapper around hecs’s query types, not a transparent passthrough to them: no hecs::* type appears in any method here, and nothing leaks through beyond what’s listed below.

Iterating

iter returns a plain Iterator, so the usual adapters (.filter(...), .map(...), .take(...), .collect(), …) all compose directly — reach for .filter(...) for a predicate over the yielded values (health below a threshold, say); with/ without below are for filtering by which components an entity has, not their values.

fn move_system(mut q: Query<(&mut Position, &Velocity)>) {
    for (pos, vel) in q.iter() {
        pos.x += vel.x;
        pos.y += vel.y;
    }
}

Query also implements IntoIterator for &mut Query, so for item in &mut q works too, identically to for item in q.iter().

Include hecs::Entity in Q (e.g. Query<(Entity, &Position)>) if you need the entity id back alongside its components — it’s a query term like any other, not a separate mechanism.

Narrowing by component (with/without)

with/without narrow which entities match, without adding to (or needing) the yielded item type, and — unlike calling straight through to hecs — chain: each returns another Query, so .with::<&Enemy>().without::<&Dead>().iter() keeps every method on this page available at each step, no hecs::With/hecs::Without naming required on your end.

Single-entity lookups

Use Query::get to fetch components for one known Entity without scanning the whole result set, and Query::single/Query::get_single when you expect exactly one match (e.g. “the player”, “the active camera”).

Implementations

impl<'a, Q: Query> Query<'a, Q>

pub fn iter(&mut self) -> impl Iterator<Item = Q::Item<'_>>

Iterate every entity matching this query. An ordinary Iterator — .filter(...), .map(...), .count(), .collect(), and every other standard adapter work directly on the result, no hecs types involved.

pub fn get(&mut self, entity: Entity) -> Option<Q::Item<'_>>

Look up a single entity’s components for this query. None if the entity doesn’t exist or doesn’t match Q.

pub fn with<R: Query>(self) -> Query<'a, With<Q, R>>

Narrow this query to only entities that ALSO have component(s) R, without R itself being part of the yielded items. Consumes self and returns another Query — chain further .with/.without, or call .iter/.get/.single directly on the result.

pub fn without<R: Query>(self) -> Query<'a, Without<Q, R>>

Narrow this query to only entities that do NOT have component(s) R. Same shape as with.

pub fn single(&mut self) -> Q::Item<'_>

Return the single entity’s components for this query.

Panics if there isn’t exactly one match. Intended for singleton-style queries (the player, the active camera, …) where zero or multiple matches indicate a bug. See Query::get_single for a non-panicking version. Include hecs::Entity in Q if you need the id alongside the components.

pub fn get_single(&mut self) -> Option<Q::Item<'_>>

Like Query::single, but returns None instead of panicking when there isn’t exactly one match.

Trait Implementations

impl<'q, Q: Query> IntoIterator for &'q mut Query<'_, Q>

type Item = <Q as Query>::Item<'q>

The type of the elements being iterated over.

type IntoIter = QueryIter<'q, Q>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<Q> SystemParam for Query<'static, Q>

where Q: Query + 'static,

type Item<'a> = Query<'a, Q>

type State = ()

fn fetch<'a>( _state: &'a mut Self::State, world: &'a World, _resources: &'a Resources, ) -> Self::Item<'a>

fn requires() -> Vec<RequiredResource>

Resource types this parameter unconditionally needs present to avoid panicking. Used by App to validate — before running a non-convergent stage’s systems — that every hard requirement is already satisfied, failing fast with a clear message instead of panicking deep inside whichever system happens to run first.