style: format Rust workspace

crates/xserv-tensor/src/tensor.rs

@@ -33,8 +33,20 @@ impl Tensor {
     // --- Creation ---
 
     /// Create a tensor from raw components (for advanced use like GPU KV cache).
-    pub fn from_storage(storage: Storage, shape: Dims, strides: Dims, offset: usize, dtype: DType) -> Self {
-        Self { storage, shape, strides, offset, dtype }
+    pub fn from_storage(
+        storage: Storage,
+        shape: Dims,
+        strides: Dims,
+        offset: usize,
+        dtype: DType,
+    ) -> Self {
+        Self {
+            storage,
+            shape,
+            strides,
+            offset,
+            dtype,
+        }
     }
 
     pub fn from_slice<T: TensorDType>(data: &[T], shape: &[usize]) -> Self {
@@ -60,7 +72,10 @@ impl Tensor {
             data.len(),
             numel * dtype.size_bytes(),
             "raw bytes length {} != expected {} (numel={} * elem_size={})",
-            data.len(), numel * dtype.size_bytes(), numel, dtype.size_bytes()
+            data.len(),
+            numel * dtype.size_bytes(),
+            numel,
+            dtype.size_bytes()
         );
         Self {
             storage: Storage::cpu(data.to_vec()),
@@ -112,14 +127,28 @@ impl Tensor {
 
     // --- Properties ---
 
-    pub fn shape(&self) -> &[usize] { &self.shape }
-    pub fn strides(&self) -> &[usize] { &self.strides }
-    pub fn dtype(&self) -> DType { self.dtype }
-    pub fn ndim(&self) -> usize { self.shape.len() }
-    pub fn numel(&self) -> usize { shape::num_elements(&self.shape) }
-    pub fn offset(&self) -> usize { self.offset }
+    pub fn shape(&self) -> &[usize] {
+        &self.shape
+    }
+    pub fn strides(&self) -> &[usize] {
+        &self.strides
+    }
+    pub fn dtype(&self) -> DType {
+        self.dtype
+    }
+    pub fn ndim(&self) -> usize {
+        self.shape.len()
+    }
+    pub fn numel(&self) -> usize {
+        shape::num_elements(&self.shape)
+    }
+    pub fn offset(&self) -> usize {
+        self.offset
+    }
 
-    pub fn device(&self) -> Device { self.storage.device() }
+    pub fn device(&self) -> Device {
+        self.storage.device()
+    }
 
     pub fn is_contiguous(&self) -> bool {
         shape::is_contiguous(&self.shape, &self.strides)
@@ -193,7 +222,11 @@ impl Tensor {
             shape::contiguous_strides(&new_shape)
         } else {
             let mut s = self.strides.clone();
-            let stride_val = if dim < self.strides.len() { self.strides[dim] } else { 1 };
+            let stride_val = if dim < self.strides.len() {
+                self.strides[dim]
+            } else {
+                1
+            };
             s.insert(dim, stride_val);
             s
         };
@@ -230,7 +263,12 @@ impl Tensor {
         let ndim = self.ndim();
         let mut idx = vec![0usize; ndim];
         for flat in 0..numel {
-            let src_offset = self.offset + idx.iter().zip(self.strides.iter()).map(|(i, s)| i * s).sum::<usize>();
+            let src_offset = self.offset
+                + idx
+                    .iter()
+                    .zip(self.strides.iter())
+                    .map(|(i, s)| i * s)
+                    .sum::<usize>();
             let src_byte_offset = src_offset * elem_size;
             let dst_byte_offset = flat * elem_size;
             dst[dst_byte_offset..dst_byte_offset + elem_size]
@@ -261,7 +299,10 @@ impl Tensor {
         }
         // Transfer the raw storage (preserving strides/offset).
         // Non-contiguous layout is preserved — the user can call contiguous() after.
-        let new_storage = self.storage.to_device(device).expect("device transfer failed");
+        let new_storage = self
+            .storage
+            .to_device(device)
+            .expect("device transfer failed");
         Self {
             storage: new_storage,
             shape: self.shape.clone(),
@@ -310,14 +351,20 @@ impl Tensor {
         }
     }
 
-    pub fn storage(&self) -> &Storage { &self.storage }
+    pub fn storage(&self) -> &Storage {
+        &self.storage
+    }
 }
 
 impl std::fmt::Debug for Tensor {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(
-            f, "Tensor(shape={:?}, dtype={}, device={}, contiguous={})",
-            self.shape.as_slice(), self.dtype, self.device(), self.is_contiguous()
+            f,
+            "Tensor(shape={:?}, dtype={}, device={}, contiguous={})",
+            self.shape.as_slice(),
+            self.dtype,
+            self.device(),
+            self.is_contiguous()
         )
     }
 }