edition = 2024

Cargo.toml

···
 [package]
 name = "ecsdb"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 
 [dependencies]
 anyhow = "1.0.99"

ecsdb_derive/Cargo.toml

···
 [package]
 name = "ecsdb_derive"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 
 [lib]
 proc-macro = true

ecsdb_derive/src/lib.rs

···
 
 use proc_macro::TokenStream;
 use quote::{format_ident, quote};
-use syn::{punctuated::Punctuated, Attribute, Data, Expr, Fields, Lit, Meta, Token};
+use syn::{Attribute, Data, Expr, Fields, Lit, Meta, Token, punctuated::Punctuated};
 
 #[proc_macro_derive(Component, attributes(component))]
 pub fn derive_component_fn(input: TokenStream) -> TokenStream {
···
 
     let component_derive: proc_macro2::TokenStream = impl_derive_component(ast).into();
 
-    let gen = quote! {
+    quote! {
         #component_derive
 
         impl ecsdb::resource::Resource for #name { }
-    };
-
-    gen.into()
+    }
+    .into()
 }
 
 fn impl_derive_bundle(ast: syn::DeriveInput) -> TokenStream {

src/entity.rs

···
-use rusqlite::{params, OptionalExtension};
+use rusqlite::{OptionalExtension, params};
 use tracing::{debug, trace};
 
 use crate::{
+    Component, CreatedAt, DynComponent, Ecs, EntityId, Error, LastUpdated,
     component::Bundle,
     query::{self},
-    Component, CreatedAt, DynComponent, Ecs, EntityId, Error, LastUpdated,
 };
 
 #[derive(Debug, Copy, Clone)]
···
             .conn
             .prepare_cached("select data from components where entity = ?1 and component = ?2")?;
 
-        let row = query
+        query
             .query_and_then(params![self.id(), name], |row| {
                 let data = row.get_ref("data")?;
                 Ok(T::from_rusqlite(&rusqlite::types::ToSqlOutput::Borrowed(
···
                 ))?)
             })?
             .next()
-            .transpose();
-
-        row
+            .transpose()
     }
 }
 
···
             .conn
             .prepare_cached("select data from components where entity = ?1 and component = ?2")?;
 
-        let row = query
+        query
             .query_and_then(params![self.id(), name], |row| {
                 let data = row.get("data")?;
                 Ok(DynComponent(
···
                 ))
             })?
             .next()
-            .transpose();
-
-        row
+            .transpose()
     }
 }
 

src/lib.rs

···
 
     pub fn query_filtered<'a, D, F>(
         &'a self,
-        filter: impl QueryFilterValue,
+        filter: impl QueryFilterValue + 'a,
     ) -> impl Iterator<Item = D::Output<'a>> + 'a
     where
         D: query::QueryData + 'a,
···
     #[instrument(name = "find", level = "debug", skip_all)]
     pub fn try_query_fitered<'a, D, F>(
         &'a self,
-        filter_value: impl query::QueryFilterValue,
+        filter_value: impl query::QueryFilterValue + 'a,
     ) -> Result<impl Iterator<Item = D::Output<'a>> + 'a, Error>
     where
         D: query::QueryData + 'a,
···
 impl Ecs {
     pub fn find<'a>(
         &'a self,
-        filter_value: impl query::QueryFilterValue,
+        filter_value: impl query::QueryFilterValue + 'a,
     ) -> impl Iterator<Item = Entity<'a>> + 'a {
         self.try_find(filter_value).unwrap()
     }
 
     pub fn try_find<'a>(
         &'a self,
-        filter_value: impl query::QueryFilterValue,
+        filter_value: impl query::QueryFilterValue + 'a,
     ) -> Result<impl Iterator<Item = Entity<'a>> + 'a, Error> {
         self.try_query_fitered::<Entity<'a>, ()>(filter_value)
     }

src/query/mod.rs

···
 use tracing::trace;
 
-use crate::{component::Bundle, Entity, EntityId};
+use crate::{Entity, EntityId, component::Bundle};
 
 use super::Component;
 use std::marker::PhantomData;
···
     F: QueryFilter,
     V: QueryFilterValue,
 {
-    pub fn iter(&self) -> impl Iterator<Item = D::Output<'a>> + 'a {
+    pub fn iter(&self) -> impl Iterator<Item = D::Output<'a>> + 'a + use<'a, D, F, V> {
         self.try_iter().unwrap()
     }
 
-    pub fn reverse_iter(&self) -> impl Iterator<Item = D::Output<'a>> + 'a {
+    pub fn reverse_iter(&self) -> impl Iterator<Item = D::Output<'a>> + 'a + use<'a, D, F, V> {
         self.try_reverse_iter().unwrap()
     }
 
-    pub fn entities(&self) -> impl Iterator<Item = Entity<'a>> + 'a {
+    pub fn entities(&self) -> impl Iterator<Item = Entity<'a>> + 'a + use<'a, D, F, V> {
         self.try_entities().unwrap()
     }
 
-    pub fn reverse_entities(&self) -> impl Iterator<Item = Entity<'a>> + 'a {
+    pub fn reverse_entities(&self) -> impl Iterator<Item = Entity<'a>> + 'a + use<'a, D, F, V> {
         self.try_reverse_entities().unwrap()
     }
 
-    pub fn try_iter(&self) -> Result<impl Iterator<Item = D::Output<'a>> + 'a, crate::Error> {
+    pub fn try_iter(
+        &self,
+    ) -> Result<impl Iterator<Item = D::Output<'a>> + 'a + use<'a, D, F, V>, crate::Error> {
         Ok(self.try_entities()?.filter_map(|e| D::from_entity(e)))
     }
 
     pub fn try_reverse_iter(
         &self,
-    ) -> Result<impl Iterator<Item = D::Output<'a>> + 'a, crate::Error> {
+    ) -> Result<impl Iterator<Item = D::Output<'a>> + 'a + use<'a, D, F, V>, crate::Error> {
         Ok(self
             .try_reverse_entities()?
             .filter_map(|e| D::from_entity(e)))
     }
 
-    pub fn try_entities(&self) -> Result<impl Iterator<Item = Entity<'a>> + 'a, crate::Error> {
+    pub fn try_entities(
+        &self,
+    ) -> Result<impl Iterator<Item = Entity<'a>> + 'a + use<'a, D, F, V>, crate::Error> {
         let mut query = self.as_sql_query();
 
         query.order_by = ir::OrderBy::Asc;
···
 
     pub fn try_reverse_entities(
         &self,
-    ) -> Result<impl Iterator<Item = Entity<'a>> + 'a, crate::Error> {
+    ) -> Result<impl Iterator<Item = Entity<'a>> + 'a + use<'a, D, F, V>, crate::Error> {
         let mut query = self.as_sql_query();
         query.order_by = ir::OrderBy::Desc;
         self.ecs.fetch::<Entity>(query)

src/resource.rs

···
         let mut query = self
             .conn
             .prepare_cached("select data from resources where name = ?1")?;
-        let row = query
+        query
             .query_and_then(params![name], |row| {
                 let data = row.get_ref("data")?;
                 Ok(R::from_rusqlite(&rusqlite::types::ToSqlOutput::Borrowed(
···
                 ))?)
             })?
             .next()
-            .transpose();
-
-        row
+            .transpose()
     }
 
     pub fn resource_mut<'a, R: Resource + Default>(&'a mut self) -> impl DerefMut<Target = R> + 'a {

src/system.rs

···
 use serde::{Deserialize, Serialize};
 use tracing::{debug, error, info, instrument};
 
-use crate::{self as ecsdb, query, Component, Ecs, Entity};
+use crate::{self as ecsdb, Component, Ecs, Entity, query};
 
 use core::marker::PhantomData;
 use std::{
···
     use std::marker::PhantomData;
 
     use crate::query::With;
-    use crate::{query, Ecs, Entity, IntoSystem, System, SystemEntity};
+    use crate::{Ecs, Entity, IntoSystem, System, SystemEntity, query};
 
     #[test]
     fn run_system() {