Added support for nested Ref ops

Author: LucaCappelletti94

CHANGELOG.md

@@ -22,6 +22,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `TupleRow<Idx>` and `TupleRowMut<Idx>` traits for indexing rows in tuples of tuples
 - `FirstTupleRow` and `LastTupleRow` convenience traits for accessing the first and last rows in tuples of tuples
 - `FirstTupleIndex` and `LastTupleIndex` convenience traits for accessing the first and last elements in tuples
+- `TupleRefMap` trait for applying `TupleRef` to each element of a tuple of tuples
+- `TupleMutMap` trait for applying `TupleMut` to each element of a tuple of tuples
 
 ## [0.1.0] - 2025-12-05
 

README.md

@@ -31,6 +31,8 @@ The library provides several traits for working with tuples:
 - [`IntoTupleOption`](https://docs.rs/tuplities-option/latest/tuplities_option/trait.IntoTupleOption.html): Provides an [`into_options()`](https://docs.rs/tuplities-option/latest/tuplities_option/trait.IntoTupleOption.html#tymethod.into_options) method to convert a tuple into a tuple of options.
 - [`TupleRef`](https://docs.rs/tuplities-ref/latest/tuplities_ref/trait.TupleRef.html): Provides a [`tuple_ref()`](https://docs.rs/tuplities-ref/latest/tuplities_ref/trait.TupleRef.html#tymethod.tuple_ref) method to get references to each element in the tuple.
 - [`TupleMut`](https://docs.rs/tuplities-mut/latest/tuplities_mut/trait.TupleMut.html): Provides a [`tuple_mut()`](https://docs.rs/tuplities-mut/latest/tuplities_mut/trait.TupleMut.html#tymethod.tuple_mut) method to get mutable references to each element in the tuple.
+- [`TupleRefMap`](https://docs.rs/tuplities-ref/latest/tuplities_ref/trait.TupleRefMap.html): Provides a [`tuple_ref_map()`](https://docs.rs/tuplities-ref/latest/tuplities_ref/trait.TupleRefMap.html#tymethod.tuple_ref_map) method to apply `TupleRef` to each element of a tuple of tuples, returning a tuple of tuples of references.
+- [`TupleMutMap`](https://docs.rs/tuplities-mut/latest/tuplities_mut/trait.TupleMutMap.html): Provides a [`tuple_mut_map()`](https://docs.rs/tuplities-mut/latest/tuplities_mut/trait.TupleMutMap.html#tymethod.tuple_mut_map) method to apply `TupleMut` to each element of a tuple of tuples, returning a tuple of tuples of mutable references.
 - [`TuplePopFront`](https://docs.rs/tuplities-pop-front/latest/tuplities_pop_front/trait.TuplePopFront.html): Provides a [`pop_front()`](https://docs.rs/tuplities-pop-front/latest/tuplities_pop_front/trait.TuplePopFront.html#tymethod.pop_front) method to remove and return the first element of the tuple along with the remaining elements as a new tuple.
 - [`TuplePopBack`](https://docs.rs/tuplities-pop-back/latest/tuplities_pop_back/trait.TuplePopBack.html): Provides a [`pop_back()`](https://docs.rs/tuplities-pop-back/latest/tuplities_pop_back/trait.TuplePopBack.html#tymethod.pop_back) method to remove and return the last element of the tuple along with the remaining elements as a new tuple.
 - [`TuplePushFront<T>`](https://docs.rs/tuplities-push-front/latest/tuplities_push_front/trait.TuplePushFront.html): Provides a [`push_front(element)`](https://docs.rs/tuplities-push-front/latest/tuplities_push_front/trait.TuplePushFront.html#tymethod.push_front) method to add an element to the front of the tuple, returning a new tuple.

tuplities-derive/src/lib.rs

@@ -17,6 +17,7 @@ mod tuplities_insert;
 mod tuplities_last_tuple_row;
 mod tuplities_len;
 mod tuplities_mut;
+mod tuplities_mut_map;
 mod tuplities_option;
 mod tuplities_ord;
 mod tuplities_partial_eq;
@@ -26,6 +27,7 @@ mod tuplities_pop_front;
 mod tuplities_push_back;
 mod tuplities_push_front;
 mod tuplities_ref;
+mod tuplities_ref_map;
 mod tuplities_remove;
 mod tuplities_replicate;
 mod tuplities_reverse;
@@ -218,6 +220,22 @@ pub fn impl_tuple_mut(_attr: TokenStream, item: TokenStream) -> TokenStream {
     item.into()
 }
 
+/// Generate `TupleRefMap` trait implementations for all tuple sizes.
+#[proc_macro_attribute]
+pub fn impl_tuple_ref_map(_attr: TokenStream, item: TokenStream) -> TokenStream {
+    let mut item = proc_macro2::TokenStream::from(item);
+    item.extend(tuplities_ref_map::impl_tuple_ref_map());
+    item.into()
+}
+
+/// Generate `TupleMutMap` trait implementations for all tuple sizes.
+#[proc_macro_attribute]
+pub fn impl_tuple_mut_map(_attr: TokenStream, item: TokenStream) -> TokenStream {
+    let mut item = proc_macro2::TokenStream::from(item);
+    item.extend(tuplities_mut_map::impl_tuple_mut_map());
+    item.into()
+}
+
 /// Generate `TupleOption` and `IntoTupleOption` trait implementations for all tuple sizes.
 #[proc_macro_attribute]
 pub fn impl_tuple_option(_attr: TokenStream, item: TokenStream) -> TokenStream {

tuplities-derive/src/tuplities_mut_map.rs

@@ -0,0 +1,25 @@
+//! Submodule providing the derive macro for the `TupleMutMap` trait.
+
+use quote::quote;
+
+use crate::tuple_size::{generate_all_sizes, indices, type_params};
+
+/// Generate `TupleMutMap` trait implementations for all tuple sizes.
+pub fn impl_tuple_mut_map() -> proc_macro2::TokenStream {
+    generate_all_sizes(|size| {
+        let type_params = type_params(size);
+        let indices = indices(size);
+
+        quote! {
+            impl<#(#type_params: TupleMut,)*> TupleMutMap for (#(#type_params,)*)
+            {
+                type MutMap<'a> = (#(< #type_params as TupleMut >::Mut<'a>,)*) where Self: 'a;
+
+                #[inline]
+                fn tuple_mut_map(&mut self) -> Self::MutMap<'_> {
+                    (#(self.#indices.tuple_mut(),)*)
+                }
+            }
+        }
+    })
+}

tuplities-derive/src/tuplities_ref_map.rs

@@ -0,0 +1,25 @@
+//! Submodule providing the derive macro for the `TupleRefMap` trait.
+
+use quote::quote;
+
+use crate::tuple_size::{generate_all_sizes, indices, type_params};
+
+/// Generate `TupleRefMap` trait implementations for all tuple sizes.
+pub fn impl_tuple_ref_map() -> proc_macro2::TokenStream {
+    generate_all_sizes(|size| {
+        let type_params = type_params(size);
+        let indices = indices(size);
+
+        quote! {
+            impl<#(#type_params: TupleRef,)*> TupleRefMap for (#(#type_params,)*)
+            {
+                type RefMap<'a> = (#(< #type_params as TupleRef >::Ref<'a>,)*) where Self: 'a;
+
+                #[inline]
+                fn tuple_ref_map(&self) -> Self::RefMap<'_> {
+                    (#(self.#indices.tuple_ref(),)*)
+                }
+            }
+        }
+    })
+}

tuplities-mut/src/lib.rs

@@ -43,3 +43,30 @@ pub trait TupleMut {
     /// ```
     fn tuple_mut(&mut self) -> Self::Mut<'_>;
 }
+
+#[tuplities_derive::impl_tuple_mut_map]
+/// A trait for applying `TupleMut` to each element of a tuple.
+///
+/// This trait takes a mutable reference to a tuple where each element implements `TupleMut` and returns
+/// a tuple where each element is the result of calling `tuple_mut()` on the original elements.
+///
+/// # Examples
+///
+/// ```rust
+/// use tuplities_mut::TupleMutMap;
+///
+/// let mut matrix = ((1, 2), (3, 4), (5, 6));
+/// let mut_ref_matrix = matrix.tuple_mut_map();
+/// assert_eq!(mut_ref_matrix, ((&mut 1, &mut 2), (&mut 3, &mut 4), (&mut 5, &mut 6)));
+/// ```
+///
+/// Part of the [`tuplities`](https://docs.rs/tuplities/latest/tuplities/) crate.
+pub trait TupleMutMap {
+    /// The type of a tuple containing tuples of mutable references to each inner element.
+    type MutMap<'a>
+    where
+        Self: 'a;
+
+    /// Returns a tuple where each element is a tuple of mutable references to the inner elements.
+    fn tuple_mut_map(&mut self) -> Self::MutMap<'_>;
+}

tuplities-ref/src/lib.rs

@@ -38,3 +38,31 @@ pub trait TupleRef {
     /// ```
     fn tuple_ref(&self) -> Self::Ref<'_>;
 }
+
+#[tuplities_derive::impl_tuple_ref_map]
+
+/// A trait for applying `TupleRef` to each element of a tuple.
+///
+/// This trait takes a tuple where each element implements `TupleRef` and returns
+/// a tuple where each element is the result of calling `tuple_ref()` on the original elements.
+///
+/// # Examples
+///
+/// ```rust
+/// use tuplities_ref::TupleRefMap;
+///
+/// let matrix = ((1, 2), (3, 4), (5, 6));
+/// let ref_matrix = matrix.tuple_ref_map();
+/// assert_eq!(ref_matrix, ((&1, &2), (&3, &4), (&5, &6)));
+/// ```
+///
+/// Part of the [`tuplities`](https://docs.rs/tuplities/latest/tuplities/) crate.
+pub trait TupleRefMap {
+    /// The type of a tuple containing tuples of references to each inner element.
+    type RefMap<'a>
+    where
+        Self: 'a;
+
+    /// Returns a tuple where each element is a tuple of references to the inner elements.
+    fn tuple_ref_map(&self) -> Self::RefMap<'_>;
+}

tuplities/src/lib.rs

@@ -14,6 +14,7 @@ pub mod prelude {
     pub use tuplities_insert::TupleInsert;
     pub use tuplities_len::{PairTuple, SingletonTuple, TupleLen, UnitTuple};
     pub use tuplities_mut::TupleMut;
+    pub use tuplities_mut::TupleMutMap;
     pub use tuplities_option::{IntoTupleOption, TupleOption};
     pub use tuplities_ord::TupleOrd;
     pub use tuplities_partial_eq::TuplePartialEq;
@@ -23,6 +24,7 @@ pub mod prelude {
     pub use tuplities_push_back::TuplePushBack;
     pub use tuplities_push_front::TuplePushFront;
     pub use tuplities_ref::TupleRef;
+    pub use tuplities_ref::TupleRefMap;
     pub use tuplities_remove::TupleRemove;
     pub use tuplities_replicate::TupleReplicate;
     pub use tuplities_reverse::TupleReverse;