Add TupleRef, inspect_fn!

Cargo.toml

@@ -1,7 +1,7 @@
 workspace = { members = ["procs"] }
 [package]
 name = "statecs"
-version = "0.3.3"
+version = "0.4.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -14,3 +14,6 @@ procs = { path = "procs" }
 [dev-dependencies]
 tokio-test = "0.4.4"
 tokio = { version = "1", features = ["full"] }
+
+[lints.clippy]
+multiple_bound_locations = "allow"

src/entity.rs

@@ -11,6 +11,43 @@ pub trait TupleExtend {
  fn extend<T>(self, v: T) -> Self::AfterExtend<T>;
 }
 
+pub trait TupleRef {
+ type RefType<'a>
+ where
+ Self: 'a;
+ type MutRefType<'a>
+ where
+ Self: 'a;
+ fn ref_tuple(&self) -> Self::RefType<'_>;
+ fn mut_tuple(&mut self) -> Self::MutRefType<'_>;
+}
+
+pub trait TupleRefRef<'a> {
+ type RefType: 'a;
+ fn _ref_tuple(self) -> Self::RefType;
+}
+
+impl<'a, T> TupleRefRef<'a> for &'a T
+where
+ T: TupleRef,
+{
+ type RefType = T::RefType<'a>;
+
+ fn _ref_tuple(self) -> Self::RefType {
+ self.ref_tuple()
+ }
+}
+impl<'a, T> TupleRefRef<'a> for &'a mut T
+where
+ T: TupleRef,
+{
+ type RefType = T::MutRefType<'a>;
+
+ fn _ref_tuple(self) -> Self::RefType {
+ self.mut_tuple()
+ }
+}
+
 #[cfg(test)]
 mod test {
  use super::*;
@@ -80,6 +117,21 @@ macro_rules! impl_extend_merge {
  v$(.extend($ids))*
  }
  }
+ #[allow(non_snake_case)]
+ impl<$($ids,)*> $crate::entity::TupleRef for ($($ids,)*) {
+ type RefType<'a> = ($(&'a $ids,)*) where Self: 'a;
+ type MutRefType<'a> = ($(&'a mut $ids,)*) where Self: 'a;
+ #[allow(clippy::unused_unit)]
+ fn ref_tuple(&self) -> Self::RefType<'_> {
+ let ($($ids,)*) = self;
+ ($($ids,)*)
+ }
+ #[allow(clippy::unused_unit)]
+ fn mut_tuple(&mut self) -> Self::MutRefType<'_> {
+ let ($($ids,)*) = self;
+ ($($ids,)*)
+ }
+ }
  };
  (expand_trait_type, $tp:ty, ($first:ident $(,$ids:ident)*)) => {
  impl_extend_merge!(expand_trait_type, <$tp as TupleExtend>::AfterExtend<$first>, ($($ids),*))

src/lib.rs

@@ -5,7 +5,7 @@ pub(crate) mod tuple_proc;
 
 pub mod prelude {
  pub use crate::component::{ComponentGet, ComponentPut};
- pub use crate::entity::{TupleExtend, TupleMerge};
+ pub use crate::entity::{TupleExtend, TupleMerge, TupleRefRef};
  pub use crate::system::system;
  pub use crate::system::system_wrap;
 

src/tuple_proc.rs

@@ -39,22 +39,50 @@ macro_rules! cascade_fn {
 }
 
 #[macro_export]
-macro_rules! cascade_obj {
- (($obj:expr, $val:expr) => $expr:expr) => {
- $expr.into_tuple_processor().cascade_obj($obj, $val)
- };
+macro_rules! inspect {
+ ($val:expr => $expr:expr) => {{
+ use $crate::IntoTupleProcessor;
+ use $crate::TupleRefRef;
+ $expr.into_tuple_processor().apply($val)
+ }};
 }
 
 #[macro_export]
-macro_rules! cascade_obj_fn {
- (ref $expr:expr) => {
- |obj, x| cascade_obj!((obj, x) => $expr)
+macro_rules! inspect_fn {
+ (once $expr:expr) => {{
+ let __e = $expr;
+ move |x| { $crate::inspect!(x => __e) }
+ }};
+ ($expr:expr) => {{
+ let mut __e = $expr;
+ fn do_ref_tuple<'a, T: $crate::TupleRefRef<'a>>(a: T) -> T::RefType {
+ a._ref_tuple()
+ }
+ move |x| { $crate::inspect!(do_ref_tuple(x) => &__e) }
+ }};
+}
+
+#[macro_export]
+macro_rules! mutate_fn {
+ (once $expr:expr) => {
+ let __e = $expr;
+ |x| { $crate::tuple_proc::mutate!(x => __e) }
  };
  ($expr:expr) => {
- move |obj, x| cascade_obj!((obj, x) => $expr)
+ let mut __e = $expr;
+ |x| { $crate::tuple_proc::mutate!(x => &mut __e) }
  };
 }
 
+#[macro_export]
+macro_rules! mutate {
+ ($val:expr => $expr:expr) => {{
+ use $crate::entity::TupleRefRef;
+ use $crate::IntoTupleProcessor;
+ $expr.into_tuple_processor().apply($val.mut_tuple())
+ }};
+}
+
 #[cfg(test)]
 mod tests {
  use crate::*;
@@ -295,27 +323,12 @@ macro_rules! impl_tuple_proc {
  let (r, b) = _E!(e => |($($ids,)*)| self.0($($ids,)*) => NoMerge);
  r.cascade_merge(b.merge(()))
  }
- }
- #[allow(non_snake_case)]
- impl<Obj, F, OType, $($ids,)*> TupleProcessFn<F, ((Obj, ($($ids,)*)), OType)>
- where
- F: FnOnce(Obj, ($($ids,)*)) -> OType,
- {
  #[system_wrap(
- E: ($($ids,)*)
+ _E: ($($ids,)*)
  )]
- pub fn cascade_obj<E, const I: usize, const J: usize>(
- self,
- obj: Obj,
- e: E,
- )
- -> <OType as CascadeInto<I, J>>::Output<outof![E]>
- where
- outof![E]: TupleMerge,
- OType: CascadeInto<I, J>
- {
- let (r, b) = E!(e => |($($ids,)*)| self.0(obj, ($($ids,)*)) => NoMerge);
- r.cascade_merge(b.merge(()))
+ pub fn apply<_E>(self, e: _E) -> OType {
+ let (r, _) = _E!(e => |($($ids,)*)| self.0($($ids,)*) => NoMerge);
+ r
  }
  }
  };