[ndslice]: slice: Slice::view

Differential Revision: [D75993130](https://our.internmc.facebook.com/intern/diff/D75993130/)

**NOTE FOR REVIEWERS**: This PR has internal Meta-specific changes or comments, please review them on [Phabricator](https://our.internmc.facebook.com/intern/diff/D75993130/)!

ghstack-source-id: 288271741
Pull Request resolved: #167

Author: Shayne Fletcher

controller/src/lib.rs

@@ -430,7 +430,7 @@ impl ControllerMessageHandler for ControllerActor {
 
         let slice = Slice::new(0usize, vec![self.world_size], vec![1])
             .unwrap()
-            .view_limit(Limit::from(CASTING_FANOUT_SIZE));
+            .reshape_with_limit(Limit::from(CASTING_FANOUT_SIZE));
 
         self.comm_actor_ref.send(
             this,

ndslice/src/reshape.rs

@@ -18,10 +18,9 @@
 //!
 //! For [`Shape`]s, reshaping also expands dimension labels using a
 //! `label/N` naming convention, preserving the semantics of the
-//! original shape in the reshaped view_limit.
+//! original shape in the reshaped reshape_with_limit.
 //!
-//! See [`view_limit`] and [`reshape_shape`] for entry points.
-
+//! See [`reshape_with_limit`] and [`reshape_shape`] for entry points.
 use std::fmt;
 
 use crate::shape::Shape;
@@ -34,7 +33,6 @@ pub type Coord = Vec<usize>;
 /// A reshaped version of a `Shape`, with factored dimensions and
 /// updated labels.
 ///
-///
 /// This type preserves coordinate bijections with the original shape
 /// and provides access to the transformed layout and label mappings.
 pub struct ReshapedShape {
@@ -151,7 +149,7 @@ pub fn to_original_coord<'a>(
 ///
 /// This limit controls how a given dimension is factored during
 /// reshaping. Values larger than `limit` are recursively decomposed
-/// into smaller factors (e.g., `view_limit([1024],
+/// into smaller factors (e.g., `reshape_with_limit([1024],
 /// Limit::new(32))` → `[32, 32]`).
 ///
 /// The default limit is `32`, which balances fanout depth and layout
@@ -195,7 +193,7 @@ impl From<usize> for Limit {
 /// view by factoring large extents into smaller ones.
 ///
 /// This is implemented for [`Slice`], enabling ergonomic access to
-/// [`view_limit`] as a method.
+/// [`reshape_with_limit`] as a method.
 ///
 /// # Example
 /// ```
@@ -204,7 +202,7 @@ impl From<usize> for Limit {
 /// use ndslice::reshape::ReshapeSliceExt;
 ///
 /// let slice = Slice::new_row_major(vec![1024]);
-/// let reshaped = slice.view_limit(Limit::new(32));
+/// let reshaped = slice.reshape_with_limit(Limit::new(32));
 /// assert_eq!(reshaped.sizes(), &[32, 32]);
 /// ```
 /// # Returns
@@ -214,20 +212,20 @@ pub trait ReshapeSliceExt {
     /// Returns a reshaped version of this structure by factoring each
     /// dimension into smaller extents no greater than `limit`,
     /// preserving memory layout and flat index semantics. See
-    /// [`view_limit`] for full behavior and rationale.
+    /// [`reshape_with_limit`] for full behavior and rationale.
     ///
     /// # Arguments
     /// - `limit`: maximum size allowed in any reshaped dimension
     ///
     /// # Returns
     /// A reshaped [`Slice`] with increased dimensionality and a
     /// bijective mapping to the original.
-    fn view_limit(&self, limit: Limit) -> Slice;
+    fn reshape_with_limit(&self, limit: Limit) -> Slice;
 }
 
 impl ReshapeSliceExt for Slice {
-    fn view_limit(&self, limit: Limit) -> Slice {
-        view_limit(self, limit)
+    fn reshape_with_limit(&self, limit: Limit) -> Slice {
+        reshape_with_limit(self, limit)
     }
 }
 
@@ -244,7 +242,7 @@ impl ReshapeShapeExt for Shape {
     }
 }
 
-/// For convenient `slice.view_limit()`, `shape.reshape()`
+/// For convenient `slice.reshape_with_limit()`, `shape.reshape()`
 /// syntax, `use reshape::prelude::*`.
 pub mod prelude {
     pub use super::ReshapeShapeExt;
@@ -274,13 +272,13 @@ pub mod prelude {
 /// ```
 /// use ndslice::Slice;
 /// use ndslice::reshape::Limit;
-/// use ndslice::reshape::view_limit;
+/// use ndslice::reshape::reshape_with_limit;
 ///
 /// let slice = Slice::new_row_major(vec![1024]);
-/// let reshaped = view_limit(&slice, Limit::new(32));
+/// let reshaped = reshape_with_limit(&slice, Limit::new(32));
 /// assert_eq!(reshaped.sizes(), &[32, 32]);
 /// ```
-pub fn view_limit(slice: &Slice, limit: Limit) -> Slice {
+pub fn reshape_with_limit(slice: &Slice, limit: Limit) -> Slice {
     let orig_sizes = slice.sizes();
     let orig_strides = slice.strides();
 
@@ -309,7 +307,7 @@ pub fn view_limit(slice: &Slice, limit: Limit) -> Slice {
 /// smaller ones, producing a new shape with expanded dimensionality
 /// and updated labels.
 ///
-/// This uses [`view_limit`] on the underlying slice and [`expand_labels`]
+/// This uses [`reshape_with_limit`] on the underlying slice and [`expand_labels`]
 /// to generate labels for each factored dimension.
 ///
 /// # Arguments
@@ -325,7 +323,7 @@ pub fn view_limit(slice: &Slice, limit: Limit) -> Slice {
 /// occur unless the reshaped slice and labels are inconsistent (a
 /// programming logic error).
 pub fn reshape_shape(shape: &Shape, limit: Limit) -> ReshapedShape {
-    let reshaped_slice = shape.slice().view_limit(limit);
+    let reshaped_slice = shape.slice().reshape_with_limit(limit);
     let original_labels = shape.labels();
     let original_sizes = shape.slice().sizes();
 
@@ -446,7 +444,7 @@ mod tests {
     #[test]
     fn test_reshape_split_1d_row_major() {
         let s = Slice::new_row_major(vec![1024]);
-        let reshaped = s.view_limit(Limit::from(8));
+        let reshaped = s.reshape_with_limit(Limit::from(8));
 
         assert_eq!(reshaped.offset(), 0);
         assert_eq!(reshaped.sizes(), &vec![8, 8, 8, 2]);
@@ -462,7 +460,7 @@ mod tests {
     #[test]
     fn test_reshape_6_with_limit_2() {
         let s = Slice::new_row_major(vec![6]);
-        let reshaped = view_limit(&s, Limit::from(2));
+        let reshaped = reshape_with_limit(&s, Limit::from(2));
         assert_eq!(factor_dims(s.sizes(), Limit::from(2)), vec![vec![2, 3]]);
         assert_layout_preserved!(&s, &reshaped);
     }
@@ -471,7 +469,7 @@ mod tests {
     fn test_reshape_identity_noop_2d() {
         // All dimensions ≤ limit.
         let original = Slice::new_row_major(vec![4, 8]);
-        let reshaped = original.view_limit(Limit::from(8));
+        let reshaped = original.reshape_with_limit(Limit::from(8));
 
         assert_eq!(reshaped.sizes(), original.sizes());
         assert_eq!(reshaped.strides(), original.strides());
@@ -491,7 +489,7 @@ mod tests {
     fn test_reshape_empty_slice() {
         // 0-dimensional slice.
         let original = Slice::new_row_major(vec![]);
-        let reshaped = view_limit(&original, Limit::from(8));
+        let reshaped = reshape_with_limit(&original, Limit::from(8));
 
         assert_eq!(reshaped.sizes(), original.sizes());
         assert_eq!(reshaped.strides(), original.strides());
@@ -504,7 +502,7 @@ mod tests {
     fn test_reshape_mixed_dims_3d() {
         // 3D slice with one dimension exceeding the limit.
         let original = Slice::new_row_major(vec![6, 8, 10]);
-        let reshaped = original.view_limit(Limit::from(4));
+        let reshaped = original.reshape_with_limit(Limit::from(4));
 
         assert_eq!(
             factor_dims(original.sizes(), Limit::from(4)),
@@ -519,7 +517,7 @@ mod tests {
     fn test_reshape_all_large_dims() {
         // 3D slice with all dimensions exceeding the limit.
         let original = Slice::new_row_major(vec![12, 18, 20]);
-        let reshaped = original.view_limit(Limit::from(4));
+        let reshaped = original.reshape_with_limit(Limit::from(4));
 
         assert_eq!(
             factor_dims(original.sizes(), Limit::from(4)),
@@ -534,7 +532,7 @@ mod tests {
     fn test_reshape_split_1d_factors_3_3_2_2() {
         // 36 = 3 × 3 × 2 × 2.
         let original = Slice::new_row_major(vec![36]);
-        let reshaped = view_limit(&original, Limit::from(3));
+        let reshaped = reshape_with_limit(&original, Limit::from(3));
 
         assert_eq!(
             factor_dims(original.sizes(), Limit::from(3)),
@@ -548,7 +546,7 @@ mod tests {
     fn test_reshape_large_prime_dimension() {
         // Prime larger than limit, cannot be factored.
         let original = Slice::new_row_major(vec![7]);
-        let reshaped = view_limit(&original, Limit::from(4));
+        let reshaped = reshape_with_limit(&original, Limit::from(4));
 
         // Should remain as-is since 7 is prime > 4
         assert_eq!(factor_dims(original.sizes(), Limit::from(4)), vec![vec![7]]);
@@ -561,7 +559,7 @@ mod tests {
     fn test_reshape_split_1d_factors_5_3_2() {
         // 30 = 5 × 3 × 2, all ≤ limit.
         let original = Slice::new_row_major(vec![30]);
-        let reshaped = view_limit(&original, Limit::from(5));
+        let reshaped = reshape_with_limit(&original, Limit::from(5));
 
         assert_eq!(
             factor_dims(original.sizes(), Limit::from(5)),
@@ -577,7 +575,7 @@ mod tests {
     fn test_reshape_factors_2_6_2_8_8() {
         // 12 = 6 × 2, 64 = 8 × 8 — all ≤ 8
         let original = Slice::new_row_major(vec![2, 12, 64]);
-        let reshaped = original.view_limit(Limit::from(8));
+        let reshaped = original.reshape_with_limit(Limit::from(8));
 
         assert_eq!(
             factor_dims(original.sizes(), Limit::from(8)),
@@ -593,7 +591,7 @@ mod tests {
     fn test_reshape_all_dims_within_limit() {
         // Original shape: [2, 3, 4] — all ≤ limit (4).
         let original = Slice::new_row_major(vec![2, 3, 4]);
-        let reshaped = original.view_limit(Limit::from(4));
+        let reshaped = original.reshape_with_limit(Limit::from(4));
 
         assert_eq!(
             factor_dims(original.sizes(), Limit::from(4)),
@@ -610,7 +608,7 @@ mod tests {
     fn test_reshape_degenerate_dimension() {
         // Degenerate dimension should remain unchanged.
         let original = Slice::new_row_major(vec![1, 12]);
-        let reshaped = original.view_limit(Limit::from(4));
+        let reshaped = original.reshape_with_limit(Limit::from(4));
 
         assert_eq!(
             factor_dims(original.sizes(), Limit::from(4)),
@@ -633,7 +631,7 @@ mod tests {
 
         // Reshape the selected slice using limit=2 in row-major
         // layout.
-        let reshaped = selected.slice().view_limit(Limit::from(2));
+        let reshaped = selected.slice().reshape_with_limit(Limit::from(2));
 
         assert_eq!(
             factor_dims(selected.slice().sizes(), Limit::from(2)),
@@ -654,7 +652,7 @@ mod tests {
         let selected = original.select("host", 2).unwrap();
         // Reshape the selected slice using limit=2 in row-major
         // layout.
-        let reshaped = selected.slice().view_limit(Limit::from(2));
+        let reshaped = selected.slice().reshape_with_limit(Limit::from(2));
 
         assert_layout_preserved!(selected.slice(), &reshaped);
     }
@@ -670,7 +668,7 @@ mod tests {
         let selected_host = selected_zone.select("host", 2).unwrap();
         assert_eq!(selected_host.slice().sizes(), &[1, 1, 5]);
         // Reshape with limit = 2.
-        let reshaped = selected_host.slice().view_limit(Limit::from(2));
+        let reshaped = selected_host.slice().reshape_with_limit(Limit::from(2));
 
         assert_eq!(
             factor_dims(selected_host.slice().sizes(), Limit::from(2)),
@@ -694,7 +692,7 @@ mod tests {
         assert_eq!(selected_host.slice().sizes(), &[1, 1, 8]);
 
         // Reshape with limit = 2 → gpu=8 should factor
-        let reshaped = selected_host.slice().view_limit(Limit::from(2));
+        let reshaped = selected_host.slice().reshape_with_limit(Limit::from(2));
 
         assert_eq!(
             factor_dims(selected_host.slice().sizes(), Limit::from(2)),
@@ -748,7 +746,7 @@ mod tests {
         assert_eq!(reshaped.shape.labels(), &["gpu/0", "gpu/1", "gpu/2"]);
         assert_eq!(reshaped.shape.slice().sizes(), &[2, 2, 2]);
 
-        let expected = shape.slice().view_limit(Limit::from(2));
+        let expected = shape.slice().reshape_with_limit(Limit::from(2));
         assert_eq!(reshaped.shape.slice(), &expected);
     }
 
@@ -778,7 +776,7 @@ mod tests {
         );
         assert_eq!(reshaped.shape.slice().sizes(), &[2, 2, 2, 2]);
 
-        let expected = shape.slice().view_limit(Limit::from(2));
+        let expected = shape.slice().reshape_with_limit(Limit::from(2));
         assert_eq!(reshaped.shape.slice(), &expected);
     }
 
@@ -808,7 +806,7 @@ mod tests {
         assert_eq!(reshaped.shape.slice().sizes(), &[1, 1, 2, 2, 2]);
 
         // Check against low-level equivalent reshaped slice
-        let expected = selected_host.slice().view_limit(Limit::from(2));
+        let expected = selected_host.slice().reshape_with_limit(Limit::from(2));
         assert_eq!(reshaped.shape.slice(), &expected);
     }
 }