Added helper traits

Author: LucaCappelletti94

CHANGELOG.md

@@ -20,12 +20,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `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
 - `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
-- Renamed `TupleLen::Idx` associated type to `TupleLen::Len` for better naming consistency
+- `FirstTupleRow` and `LastTupleRow` convenience traits for accessing the first and last rows in tuples of tuples
 
 ## [0.1.0] - 2025-12-05
 

README.md

@@ -51,6 +51,8 @@ The library provides several traits for working with tuples:
 - [`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.
 - [`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).
+- [`FirstTupleRow`](https://docs.rs/tuplities-row/latest/tuplities_row/trait.FirstTupleRow.html): A convenience trait providing a [`first_tuple_row()`](https://docs.rs/tuplities-row/latest/tuplities_row/trait.FirstTupleRow.html#tymethod.first_tuple_row) method to access the first element of each tuple in a tuple of tuples.
+- [`LastTupleRow`](https://docs.rs/tuplities-row/latest/tuplities_row/trait.LastTupleRow.html): A convenience trait providing a [`last_tuple_row()`](https://docs.rs/tuplities-row/latest/tuplities_row/trait.LastTupleRow.html#tymethod.last_tuple_row) method to access the last element of each tuple in a tuple of tuples.
 
 ## Features
 

tuplities-replicate/src/lib.rs

@@ -22,6 +22,20 @@ pub trait TupleReplicate<T> {
     ///
     /// let tuple: (i32, i32, i32) = TupleReplicate::tuple_replicate(42);
     /// assert_eq!(tuple, (42, 42, 42));
+    /// let _tuple_empty: () = TupleReplicate::tuple_replicate(42);
+    /// let tuple_single: (i32,) = TupleReplicate::tuple_replicate(42);
+    /// assert_eq!(tuple_single, (42,));
+    /// let tuple_two: (i32, i32) = TupleReplicate::tuple_replicate(42);
+    /// assert_eq!(tuple_two, (42, 42));
+    ///
+    /// let tuple_refs: (&str, &str, &str) = TupleReplicate::tuple_replicate("hello");
+    /// assert_eq!(tuple_refs, ("hello", "hello", "hello"));
+    ///
+    /// let tuple_strings: (String, String) = TupleReplicate::tuple_replicate(String::from("world"));
+    /// assert_eq!(tuple_strings, (String::from("world"), String::from("world")));
+    ///
+    /// let tuple_refs2: (&i32, &i32) = TupleReplicate::tuple_replicate(&100);
+    /// assert_eq!(tuple_refs2, (&100, &100));
     /// ```
     fn tuple_replicate(value: T) -> Self;
 }

tuplities-row/src/lib.rs

@@ -61,3 +61,66 @@ 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 tuple_row_mut(&mut self) -> <Self::RowType as TupleMut>::Mut<'_>;
 }
+
+/// A convenience trait for accessing the first row (index 0) in tuples of tuples.
+///
+/// This trait is automatically implemented for any tuple of tuples that implements `TupleRow<U0>`.
+///
+/// # Examples
+///
+/// ```
+/// use tuplities_row::FirstTupleRow;
+///
+/// let matrix = ((1, 2), (3, 4), (5, 6));
+/// let first_row = matrix.first_tuple_row();
+/// assert_eq!(first_row, (&1, &3, &5));
+/// ```
+///
+/// Part of the [`tuplities`](https://docs.rs/tuplities/latest/tuplities/) crate.
+pub trait FirstTupleRow: TupleRow<typenum::U0> {
+    /// Returns a tuple of references to the first element in each inner tuple.
+    fn first_tuple_row(&self) -> <Self::RowType as TupleRef>::Ref<'_> {
+        self.tuple_row()
+    }
+}
+
+impl<T: TupleRow<typenum::U0>> FirstTupleRow for T {}
+
+/// A convenience trait for accessing the last row in tuples of tuples.
+///
+/// This trait is automatically implemented for tuples of tuples where the implementation
+/// depends on the length of the inner tuples. It provides access to the last element
+/// of each inner tuple.
+///
+/// # Examples
+///
+/// ```
+/// use tuplities_row::LastTupleRow;
+///
+/// let matrix = ((1, 2, 3), (4, 5, 6), (7, 8, 9));
+/// let last_row = matrix.last_tuple_row();
+/// assert_eq!(last_row, (&3, &6, &9));
+/// ```
+///
+/// Part of the [`tuplities`](https://docs.rs/tuplities/latest/tuplities/) crate.
+pub trait LastTupleRow:
+    TupleRow<
+        <<Self as TupleLen>::Len as core::ops::Sub<typenum::U1>>::Output,
+        Len: core::ops::Sub<typenum::U1, Output: typenum::Unsigned>,
+    >
+{
+    /// Returns a tuple of references to the last element in each inner tuple.
+    fn last_tuple_row(&self) -> <Self::RowType as TupleRef>::Ref<'_>;
+}
+
+impl<T> LastTupleRow for T
+where
+    T: TupleRow<
+            <<T as TupleLen>::Len as core::ops::Sub<typenum::U1>>::Output,
+            Len: core::ops::Sub<typenum::U1, Output: typenum::Unsigned>,
+        >,
+{
+    fn last_tuple_row(&self) -> <Self::RowType as TupleRef>::Ref<'_> {
+        self.tuple_row()
+    }
+}

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::{TupleRow, TupleRowMut};
+    pub use tuplities_row::{FirstTupleRow, LastTupleRow, TupleRow, TupleRowMut};
     pub use tuplities_split::TupleSplit;
     pub use tuplities_try_from::{TupleTryFrom, TupleTryInto};
 }