Renamed Row into TupleRow

Author: LucaCappelletti94

CHANGELOG.md

@@ -18,7 +18,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `TupleTryFrom<T, E>` and `TupleTryInto<U, E>` traits for fallible conversions between tuples where elements implement `TryFrom`/`TryInto`
 - `TupleFrom<T>` and `TupleInto<U>` traits for infallible conversions between tuples where elements implement `From`/`Into`
 - Support for tuple conversions with proper error handling and type safety
-- `Row<Idx>` and `RowMut<Idx>` traits for indexing rows in tuples of tuples
+- `TupleRow<Idx>` and `TupleRowMut<Idx>` traits for indexing rows in tuples of tuples
+
+### Changed in Unreleased
+
+- Renamed `Row` and `RowMut` traits to `TupleRow` and `TupleRowMut` respectively to avoid naming collisions
+- Renamed `row()` and `row_mut()` methods to `tuple_row()` and `tuple_row_mut()` for consistency
 
 ## [0.1.0] - 2025-12-05
 

README.md

@@ -48,8 +48,8 @@ The library provides several traits for working with tuples:
 - [`SingletonTuple`](https://docs.rs/tuplities-len/latest/tuplities_len/trait.SingletonTuple.html): A marker trait implemented for single-element tuples `(T,)` with `TupleLen<Idx = U1>`.
 - [`TupleIndex<Idx>`](https://docs.rs/tuplities-index/latest/tuplities_index/trait.TupleIndex.html): Provides an [`index()`](https://docs.rs/tuplities-index/latest/tuplities_index/trait.TupleIndex.html#tymethod.index) method to access the element at the specified index [`typenum`](https://docs.rs/typenum/latest/typenum/)'s `Idx` of the tuple.
 - [`TupleIndexMut<Idx>`](https://docs.rs/tuplities-index/latest/tuplities_index/trait.TupleIndexMut.html): Provides an [`index_mut()`](https://docs.rs/tuplities-index/latest/tuplities_index/trait.TupleIndexMut.html#tymethod.index_mut) method to access a mutable reference to the element at the specified index [`typenum`](https://docs.rs/typenum/latest/typenum/)'s `Idx` of the tuple.
-- [`Row<Idx>`](https://docs.rs/tuplities-row/latest/tuplities_row/trait.Row.html): Provides a [`row()`](https://docs.rs/tuplities-row/latest/tuplities_row/trait.Row.html#tymethod.row) method to access elements at the specified index across all tuples in a tuple of tuples (row-wise indexing).
-- [`RowMut<Idx>`](https://docs.rs/tuplities-row/latest/tuplities_row/trait.RowMut.html): Provides a [`row_mut()`](https://docs.rs/tuplities-row/latest/tuplities_row/trait.RowMut.html#tymethod.row_mut) method to access mutable elements at the specified index across all tuples in a tuple of tuples (mutable row-wise indexing).
+- [`TupleRow<Idx>`](https://docs.rs/tuplities-row/latest/tuplities_row/trait.TupleRow.html): Provides a [`tuple_row()`](https://docs.rs/tuplities-row/latest/tuplities_row/trait.TupleRow.html#tymethod.tuple_row) method to access elements at the specified index across all tuples in a tuple of tuples (row-wise indexing).
+- [`TupleRowMut<Idx>`](https://docs.rs/tuplities-row/latest/tuplities_row/trait.TupleRowMut.html): Provides a [`tuple_row_mut()`](https://docs.rs/tuplities-row/latest/tuplities_row/trait.TupleRowMut.html#tymethod.tuple_row_mut) method to access mutable elements at the specified index across all tuples in a tuple of tuples (mutable row-wise indexing).
 
 ## Features
 

tuplities-derive/src/tuplities_row.rs

@@ -1,21 +1,21 @@
-//! Submodule providing the derive macro for the `Row` trait.
+//! Submodule providing the derive macro for the `TupleRow` trait.
 
 use quote::quote;
 
 use crate::tuple_size::{generate_all_sizes, indices, type_params};
 
-/// Generate `Row` trait implementations for all tuple sizes.
+/// Generate `TupleRow` trait implementations for all tuple sizes.
 pub fn impl_row() -> proc_macro2::TokenStream {
     generate_all_sizes(|size| {
         let type_params = type_params(size);
         let indices = indices(size);
 
         quote! {
-            impl<Idx: typenum::Unsigned, #(#type_params: tuplities_index::TupleIndex<Idx>,)*> Row<Idx> for (#(#type_params,)*)
+            impl<Idx: typenum::Unsigned, #(#type_params: tuplities_index::TupleIndex<Idx>,)*> TupleRow<Idx> for (#(#type_params,)*)
             {
                 type RowType = (#(#type_params::Type,)*);
 
-                fn row(&self) -> <Self::RowType as tuplities_ref::TupleRef>::Ref<'_> {
+                fn tuple_row(&self) -> <Self::RowType as tuplities_ref::TupleRef>::Ref<'_> {
                     (#(self.#indices.tuple_index(),)*)
                 }
             }

tuplities-derive/src/tuplities_row_mut.rs

@@ -1,19 +1,19 @@
-//! Submodule providing the derive macro for the `RowMut` trait.
+//! Submodule providing the derive macro for the `TupleRowMut` trait.
 
 use quote::quote;
 
 use crate::tuple_size::{generate_all_sizes, indices, type_params};
 
-/// Generate `RowMut` trait implementations for all tuple sizes.
+/// Generate `TupleRowMut` trait implementations for all tuple sizes.
 pub fn impl_row_mut() -> proc_macro2::TokenStream {
     generate_all_sizes(|size| {
         let type_params = type_params(size);
         let indices = indices(size);
 
         quote! {
-            impl<Idx: typenum::Unsigned, #(#type_params: tuplities_index::TupleIndexMut<Idx>,)*> RowMut<Idx> for (#(#type_params,)*)
+            impl<Idx: typenum::Unsigned, #(#type_params: tuplities_index::TupleIndexMut<Idx>,)*> TupleRowMut<Idx> for (#(#type_params,)*)
             {
-                fn row_mut(&mut self) -> <Self::RowType as tuplities_mut::TupleMut>::Mut<'_> {
+                fn tuple_row_mut(&mut self) -> <Self::RowType as tuplities_mut::TupleMut>::Mut<'_> {
                     (#(self.#indices.tuple_index_mut(),)*)
                 }
             }

tuplities-row/src/lib.rs

@@ -1,6 +1,6 @@
 #![no_std]
 
-//! [tuplities](https://github.com/lucacappelletti94/tuplities) suite crate providing the `Row` and `RowMut` traits.
+//! [tuplities](https://github.com/lucacappelletti94/tuplities) suite crate providing the `TupleRow` and `TupleRowMut` traits.
 
 use tuplities_len::TupleLen;
 use tuplities_mut::TupleMut;
@@ -9,46 +9,46 @@ use tuplities_ref::TupleRef;
 /// A trait for indexing rows in tuples of tuples.
 ///
 /// This trait allows accessing elements at a specific index across all tuples in a tuple of tuples.
-/// For a tuple of tuples like `((A, B), (C, D))`, `Row<U0>` would return `(&A, &C)` and `Row<U1>` would return `(&B, &D)`.
+/// For a tuple of tuples like `((A, B), (C, D))`, `TupleRow<U0>` would return `(&A, &C)` and `TupleRow<U1>` would return `(&B, &D)`.
 ///
 /// Each inner tuple must implement `TupleIndex<Idx>`, and the returned row tuple implements `TupleRef`.
 ///
 /// # Examples
 ///
 /// ```
-/// use tuplities_row::Row;
+/// use tuplities_row::TupleRow;
 /// use typenum::U0;
 ///
 /// let matrix = ((1, 2), (3, 4), (5, 6));
-/// let first_row = Row::<U0>::row(&matrix);
+/// let first_row = TupleRow::<U0>::tuple_row(&matrix);
 /// assert_eq!(first_row, (&1, &3, &5));
 /// ```
 ///
 /// Part of the [`tuplities`](https://docs.rs/tuplities/latest/tuplities/) crate.
 #[tuplities_derive::impl_row]
-pub trait Row<Idx: typenum::Unsigned>: TupleLen {
+pub trait TupleRow<Idx: typenum::Unsigned>: TupleLen {
     /// The type of the row tuple containing elements at index `Idx`.
     type RowType: TupleRef + TupleLen<Idx = <Self as TupleLen>::Idx>;
 
     /// Returns a tuple of references to the elements at index `Idx` in each inner tuple.
-    fn row(&self) -> <Self::RowType as TupleRef>::Ref<'_>;
+    fn tuple_row(&self) -> <Self::RowType as TupleRef>::Ref<'_>;
 }
 
 /// A trait for mutable indexing rows in tuples of tuples.
 ///
 /// This trait allows mutable access to elements at a specific index across all tuples in a tuple of tuples.
-/// For a tuple of tuples like `((A, B), (C, D))`, `RowMut<U0>` would return `(&mut A, &mut C)` and `RowMut<U1>` would return `(&mut B, &mut D)`.
+/// For a tuple of tuples like `((A, B), (C, D))`, `TupleRowMut<U0>` would return `(&mut A, &mut C)` and `TupleRowMut<U1>` would return `(&mut B, &mut D)`.
 ///
 /// Each inner tuple must implement `TupleIndexMut<Idx>`, and the returned row tuple implements `TupleMut`.
 ///
 /// # Examples
 ///
 /// ```
-/// use tuplities_row::RowMut;
+/// use tuplities_row::TupleRowMut;
 /// use typenum::U0;
 ///
 /// let mut matrix = ((1, 2), (3, 4), (5, 6));
-/// let first_row = RowMut::<U0>::row_mut(&mut matrix);
+/// let first_row = TupleRowMut::<U0>::tuple_row_mut(&mut matrix);
 /// *first_row.0 = 10;
 /// *first_row.1 = 30;
 /// *first_row.2 = 50;
@@ -57,7 +57,7 @@ pub trait Row<Idx: typenum::Unsigned>: TupleLen {
 ///
 /// Part of the [`tuplities`](https://docs.rs/tuplities/latest/tuplities/) crate.
 #[tuplities_derive::impl_row_mut]
-pub trait RowMut<Idx: typenum::Unsigned>: Row<Idx, RowType: TupleMut> {
+pub trait TupleRowMut<Idx: typenum::Unsigned>: TupleRow<Idx, RowType: TupleMut> {
     /// Returns a tuple of mutable references to the elements at index `Idx` in each inner tuple.
-    fn row_mut(&mut self) -> <Self::RowType as TupleMut>::Mut<'_>;
+    fn tuple_row_mut(&mut self) -> <Self::RowType as TupleMut>::Mut<'_>;
 }

tuplities/src/lib.rs

@@ -26,7 +26,7 @@ pub mod prelude {
     pub use tuplities_remove::TupleRemove;
     pub use tuplities_replicate::TupleReplicate;
     pub use tuplities_reverse::TupleReverse;
-    pub use tuplities_row::{Row, RowMut};
+    pub use tuplities_row::{TupleRow, TupleRowMut};
     pub use tuplities_split::TupleSplit;
     pub use tuplities_try_from::{TupleTryFrom, TupleTryInto};
 }