repeat [skip ci]

pola-rs · Mar 7, 2025 · 8eb93dc · 8eb93dc
1 parent 2d32fbc
commit 8eb93dc
Show file tree

Hide file tree

Showing 38 changed files with 76 additions and 83 deletions.
diff --git a/crates/polars-arrow/src/array/binview/mutable.rs b/crates/polars-arrow/src/array/binview/mutable.rs
@@ -340,7 +340,7 @@ impl<T: ViewType + ?Sized> MutableBinaryViewArray<T> {
             self.init_validity(false);
         }
         self.views
-            .extend(std::iter::repeat(View::default()).take(additional));
+            .extend(std::iter::repeat_n(View::default(), additional));
         if let Some(validity) = &mut self.validity {
             validity.extend_constant(additional, false);
         }
@@ -365,7 +365,7 @@ impl<T: ViewType + ?Sized> MutableBinaryViewArray<T> {
             })
             .unwrap_or_default();
         self.views
-            .extend(std::iter::repeat(view_value).take(additional));
+            .extend(std::iter::repeat_n(view_value, additional));
     }
 
     impl_mutable_array_mut_validity!();

diff --git a/crates/polars-arrow/src/array/boolean/mutable.rs b/crates/polars-arrow/src/array/boolean/mutable.rs
@@ -265,9 +265,10 @@ impl MutableBooleanArray {
         if value.is_none() && self.validity.is_none() {
             // When the validity is None, all elements so far are valid. When one of the elements is set of null,
             // the validity must be initialized.
-            self.validity = Some(MutableBitmap::from_trusted_len_iter(
-                std::iter::repeat(true).take(self.len()),
-            ));
+            self.validity = Some(MutableBitmap::from_trusted_len_iter(std::iter::repeat_n(
+                true,
+                self.len(),
+            )));
         }
         if let Some(x) = self.validity.as_mut() {
             x.set(index, value.is_some())

diff --git a/crates/polars-arrow/src/array/fixed_size_list/ffi.rs b/crates/polars-arrow/src/array/fixed_size_list/ffi.rs
@@ -36,7 +36,7 @@ impl<A: ffi::ArrowArrayRef> FromFfi<A> for FixedSizeListArray {
         let child = unsafe { array.child(0) }?;
         let values = ffi::try_from(child)?;
 
-        let length = if values.len() == 0 {
+        let length = if values.is_empty() {
             0
         } else {
             polars_ensure!(width > 0, InvalidOperation: "Zero-width array with values");

diff --git a/crates/polars-arrow/src/array/fixed_size_list/mod.rs b/crates/polars-arrow/src/array/fixed_size_list/mod.rs
@@ -61,7 +61,7 @@ impl FixedSizeListArray {
             values.len() / size,
             length,
         );
-        polars_ensure!(size != 0 || values.len() == 0, ComputeError:
+        polars_ensure!(size != 0 || values.is_empty(), ComputeError:
             "zero width FixedSizeListArray has values (length = {}).",
             values.len(),
         );
@@ -84,7 +84,7 @@ impl FixedSizeListArray {
 
     #[inline]
     fn has_invariants(&self) -> bool {
-        let has_valid_length = (self.size == 0 && self.values().len() == 0)
+        let has_valid_length = (self.size == 0 && self.values().is_empty())
             || (self.size > 0
                 && self.values().len() % self.size() == 0
                 && self.values().len() / self.size() == self.length);

diff --git a/crates/polars-arrow/src/array/static_array.rs b/crates/polars-arrow/src/array/static_array.rs
@@ -95,7 +95,7 @@ pub trait StaticArray:
     fn full_null(length: usize, dtype: ArrowDataType) -> Self;
 
     fn full(length: usize, value: Self::ValueT<'_>, dtype: ArrowDataType) -> Self {
-        Self::arr_from_iter_with_dtype(dtype, std::iter::repeat(value).take(length))
+        Self::arr_from_iter_with_dtype(dtype, std::iter::repeat_n(value, length))
     }
 }
 

diff --git a/crates/polars-arrow/src/bitmap/mutable.rs b/crates/polars-arrow/src/bitmap/mutable.rs
@@ -331,7 +331,7 @@ impl MutableBitmap {
             let required = (self.length + additional).saturating_add(7) / 8;
             // add remaining as full bytes
             self.buffer
-                .extend(std::iter::repeat(0b11111111u8).take(required - existing));
+                .extend(std::iter::repeat_n(0b11111111u8, required - existing));
             self.length += additional;
         }
     }

diff --git a/crates/polars-arrow/src/legacy/kernels/set.rs b/crates/polars-arrow/src/legacy/kernels/set.rs
@@ -30,7 +30,7 @@ where
         if truthy {
             av.extend_from_slice(&values[lower..upper])
         } else {
-            av.extend_trusted_len(std::iter::repeat(value).take(upper - lower))
+            av.extend_trusted_len(std::iter::repeat_n(value, upper - lower))
         }
     });
 
@@ -49,7 +49,7 @@ pub fn set_with_mask<T: NativeType>(
     let mut buf = Vec::with_capacity(array.len());
     BinaryMaskedSliceIterator::new(mask).for_each(|(lower, upper, truthy)| {
         if truthy {
-            buf.extend_trusted_len(std::iter::repeat(value).take(upper - lower))
+            buf.extend_trusted_len(std::iter::repeat_n(value, upper - lower))
         } else {
             buf.extend_from_slice(&values[lower..upper])
         }

diff --git a/crates/polars-arrow/src/legacy/kernels/sorted_join/left.rs b/crates/polars-arrow/src/legacy/kernels/sorted_join/left.rs
@@ -27,7 +27,10 @@ pub fn join<T: PartialOrd + Copy + Debug>(
 
     let first_right = right[right_idx as usize];
     let mut left_idx = left.partition_point(|v| v < &first_right) as IdxSize;
-    out_rhs.extend(std::iter::repeat(NullableIdxSize::null()).take(left_idx as usize));
+    out_rhs.extend(std::iter::repeat_n(
+        NullableIdxSize::null(),
+        left_idx as usize,
+    ));
     out_lhs.extend(left_offset..(left_idx + left_offset));
 
     for &val_l in &left[left_idx as usize..] {

diff --git a/crates/polars-arrow/src/trusted_len.rs b/crates/polars-arrow/src/trusted_len.rs
@@ -57,6 +57,8 @@ unsafe impl<A: Clone> TrustedLen for std::iter::Repeat<A> {}
 unsafe impl<A, F: FnMut() -> A> TrustedLen for std::iter::RepeatWith<F> {}
 unsafe impl<A: TrustedLen> TrustedLen for std::iter::Take<A> {}
 
+unsafe impl<A: Clone> TrustedLen for std::iter::RepeatN<A> {}
+
 unsafe impl<T> TrustedLen for &mut dyn TrustedLen<Item = T> {}
 unsafe impl<T> TrustedLen for Box<dyn TrustedLen<Item = T> + '_> {}
 
@@ -100,11 +102,11 @@ where
     }
 }
 
-impl<J: Clone> TrustMyLength<std::iter::Take<std::iter::Repeat<J>>, J> {
+impl<J: Clone> TrustMyLength<std::iter::RepeatN<J>, J> {
     /// Create a new `TrustMyLength` iterator that repeats `value` `len` times.
     pub fn new_repeat_n(value: J, len: usize) -> Self {
         // SAFETY: This is always safe since repeat(..).take(n) always repeats exactly `n` times`.
-        unsafe { Self::new(std::iter::repeat(value).take(len), len) }
+        unsafe { Self::new(std::iter::repeat_n(value, len), len) }
     }
 }
 

diff --git a/crates/polars-core/src/chunked_array/object/extension/mod.rs b/crates/polars-core/src/chunked_array/object/extension/mod.rs
@@ -77,7 +77,7 @@ pub(crate) fn create_extension<I: Iterator<Item = Option<T>> + TrustedLen, T: Si
     // when we transmute from &[u8] to T, T must be aligned correctly,
     // so we pad with bytes until the alignment matches
     let n_padding = (buf.as_ptr() as usize) % t_alignment;
-    buf.extend(std::iter::repeat(0).take(n_padding));
+    buf.extend(std::iter::repeat_n(0, n_padding));
 
     // transmute T as bytes and copy in buffer
     for opt_t in iter.into_iter() {

diff --git a/crates/polars-core/src/chunked_array/ops/full.rs b/crates/polars-core/src/chunked_array/ops/full.rs
@@ -80,7 +80,7 @@ impl ChunkFullNull for BinaryChunked {
 impl<'a> ChunkFull<&'a [u8]> for BinaryOffsetChunked {
     fn full(name: PlSmallStr, value: &'a [u8], length: usize) -> Self {
         let mut mutable = MutableBinaryArray::with_capacities(length, length * value.len());
-        mutable.extend_values(std::iter::repeat(value).take(length));
+        mutable.extend_values(std::iter::repeat_n(value, length));
         let arr: BinaryArray<i64> = mutable.into();
         let mut out = ChunkedArray::with_chunk(name, arr);
         out.set_sorted_flag(IsSorted::Ascending);

diff --git a/crates/polars-core/src/chunked_array/ops/rolling_window.rs b/crates/polars-core/src/chunked_array/ops/rolling_window.rs
@@ -231,7 +231,7 @@ mod inner_mod {
             let validity_slice = validity.as_mut_slice();
 
             let mut values = Vec::with_capacity(ca.len());
-            values.extend(std::iter::repeat(T::Native::default()).take(window_size - 1));
+            values.extend(std::iter::repeat_n(T::Native::default(), window_size - 1));
 
             for offset in 0..self.len() + 1 - window_size {
                 debug_assert!(offset + window_size <= arr.len());

diff --git a/crates/polars-core/src/chunked_array/ops/sort/mod.rs b/crates/polars-core/src/chunked_array/ops/sort/mod.rs
@@ -208,7 +208,7 @@ where
         let mut vals = Vec::with_capacity(ca.len());
 
         if !options.nulls_last {
-            let iter = std::iter::repeat(T::Native::default()).take(null_count);
+            let iter = std::iter::repeat_n(T::Native::default(), null_count);
             vals.extend(iter);
         }
 
@@ -225,7 +225,7 @@ where
         sort_impl_unstable(mut_slice, options);
 
         if options.nulls_last {
-            vals.extend(std::iter::repeat(T::Native::default()).take(ca.null_count()));
+            vals.extend(std::iter::repeat_n(T::Native::default(), ca.null_count()));
         }
 
         let arr = PrimitiveArray::new(
@@ -534,7 +534,7 @@ impl ChunkSort<BinaryOffsetType> for BinaryOffsetChunked {
                     length_so_far = values.len() as i64;
                     offsets.push(length_so_far);
                 }
-                offsets.extend(std::iter::repeat(length_so_far).take(null_count));
+                offsets.extend(std::iter::repeat_n(length_so_far, null_count));
 
                 // SAFETY: offsets are correctly created.
                 let arr = unsafe {
@@ -547,7 +547,7 @@ impl ChunkSort<BinaryOffsetType> for BinaryOffsetChunked {
                 ChunkedArray::with_chunk(self.name().clone(), arr)
             },
             (_, false) => {
-                offsets.extend(std::iter::repeat(length_so_far).take(null_count));
+                offsets.extend(std::iter::repeat_n(length_so_far, null_count));
 
                 for val in v {
                     values.extend_from_slice(val);

diff --git a/crates/polars-error/src/lib.rs b/crates/polars-error/src/lib.rs
@@ -150,11 +150,7 @@ impl From<regex::Error> for PolarsError {
 #[cfg(feature = "object_store")]
 impl From<object_store::Error> for PolarsError {
     fn from(err: object_store::Error) -> Self {
-        std::io::Error::new(
-            std::io::ErrorKind::Other,
-            format!("object-store error: {err:?}"),
-        )
-        .into()
+        std::io::Error::other(format!("object-store error: {err:?}")).into()
     }
 }
 

diff --git a/crates/polars-json/src/json/write/serialize.rs b/crates/polars-json/src/json/write/serialize.rs
@@ -73,7 +73,7 @@ fn null_serializer(
     take: usize,
 ) -> Box<dyn StreamingIterator<Item = [u8]> + Send + Sync> {
     let f = |_x: (), buf: &mut Vec<u8>| buf.extend_from_slice(b"null");
-    materialize_serializer(f, std::iter::repeat(()).take(len), offset, take)
+    materialize_serializer(f, std::iter::repeat_n((), len), offset, take)
 }
 
 fn primitive_serializer<'a, T: NativeType + itoa::Integer>(

diff --git a/crates/polars-ops/src/chunked_array/repeat_by.rs b/crates/polars-ops/src/chunked_array/repeat_by.rs
@@ -15,7 +15,7 @@ fn check_lengths(length_srs: usize, length_by: usize) -> PolarsResult<()> {
 
 fn new_by(by: &IdxCa, len: usize) -> IdxCa {
     if let Some(x) = by.get(0) {
-        let values = std::iter::repeat(x).take(len).collect::<Vec<IdxSize>>();
+        let values = std::iter::repeat_n(x, len).collect::<Vec<IdxSize>>();
         IdxCa::new(PlSmallStr::EMPTY, values)
     } else {
         IdxCa::full_null(PlSmallStr::EMPTY, len)
@@ -32,7 +32,7 @@ where
         (left_len, right_len) if left_len == right_len => {
             Ok(arity::binary(ca, by, |arr, by| {
                 let iter = arr.into_iter().zip(by).map(|(opt_v, opt_by)| {
-                    opt_by.map(|by| std::iter::repeat(opt_v.copied()).take(*by as usize))
+                    opt_by.map(|by| std::iter::repeat_n(opt_v.copied(), *by as usize))
                 });
 
                 // SAFETY: length of iter is trusted.
@@ -64,7 +64,7 @@ fn repeat_by_bool(ca: &BooleanChunked, by: &IdxCa) -> PolarsResult<ListChunked>
         (left_len, right_len) if left_len == right_len => {
             Ok(arity::binary(ca, by, |arr, by| {
                 let iter = arr.into_iter().zip(by).map(|(opt_v, opt_by)| {
-                    opt_by.map(|by| std::iter::repeat(opt_v).take(*by as usize))
+                    opt_by.map(|by| std::iter::repeat_n(opt_v, *by as usize))
                 });
 
                 // SAFETY: length of iter is trusted.
@@ -91,7 +91,7 @@ fn repeat_by_binary(ca: &BinaryChunked, by: &IdxCa) -> PolarsResult<ListChunked>
         (left_len, right_len) if left_len == right_len => {
             Ok(arity::binary(ca, by, |arr, by| {
                 let iter = arr.into_iter().zip(by).map(|(opt_v, opt_by)| {
-                    opt_by.map(|by| std::iter::repeat(opt_v).take(*by as usize))
+                    opt_by.map(|by| std::iter::repeat_n(opt_v, *by as usize))
                 });
 
                 // SAFETY: length of iter is trusted.

diff --git a/crates/polars-ops/src/frame/join/hash_join/single_keys_left.rs b/crates/polars-ops/src/frame/join/hash_join/single_keys_left.rs
@@ -171,7 +171,7 @@ where
                     match value {
                         // left and right matches
                         Some(indexes_b) => {
-                            result_idx_left.extend(std::iter::repeat(idx_a).take(indexes_b.len()));
+                            result_idx_left.extend(std::iter::repeat_n(idx_a, indexes_b.len()));
                             result_idx_right.extend_from_slice(bytemuck::cast_slice(indexes_b));
                         },
                         // only left values, right = null

diff --git a/crates/polars-ops/src/frame/join/merge_sorted.rs b/crates/polars-ops/src/frame/join/merge_sorted.rs
@@ -238,7 +238,7 @@ where
             }
             // b is depleted fill with a indicator
             let remaining = cap - out.len();
-            out.extend(std::iter::repeat(A_INDICATOR).take(remaining));
+            out.extend(std::iter::repeat_n(A_INDICATOR, remaining));
             return out;
         }
     }

diff --git a/crates/polars-ops/src/series/ops/is_in.rs b/crates/polars-ops/src/series/ops/is_in.rs
@@ -794,7 +794,7 @@ fn is_in_null(s: &Series, other: &Series, nulls_equal: bool) -> PolarsResult<Boo
                 // If other has null values, then all are true, else all are false.
                 BooleanChunked::from_iter_values(
                     ca_in.name().clone(),
-                    std::iter::repeat(other.has_nulls()).take(ca_in.len()),
+                    std::iter::repeat_n(other.has_nulls(), ca_in.len()),
                 )
             },
         })

diff --git a/crates/polars-parquet/src/parquet/encoding/delta_bitpacked/encoder.rs b/crates/polars-parquet/src/parquet/encoding/delta_bitpacked/encoder.rs
@@ -137,7 +137,7 @@ mod tests {
         //      0b00001011
         // ]
         let mut expected = vec![128u8, 2, 1, 6, 2, 7, 3, 0b01101101, 0b00001011];
-        expected.extend(std::iter::repeat(0).take(256 * 3 / 8 - 2)); // 128 values, 3 bits, 2 already used
+        expected.extend(std::iter::repeat_n(0, 256 * 3 / 8 - 2)); // 128 values, 3 bits, 2 already used
 
         let mut buffer = vec![];
         encode(data.into_iter(), &mut buffer, 1);

diff --git a/crates/polars-pipe/src/executors/sinks/joins/generic_probe_inner_left.rs b/crates/polars-pipe/src/executors/sinks/joins/generic_probe_inner_left.rs
@@ -164,7 +164,7 @@ impl<K: ExtraPayload> GenericJoinProbe<K> {
                     let indexes_right = &indexes_right.0;
                     self.join_tuples_a.extend_from_slice(indexes_right);
                     self.join_tuples_b
-                        .extend(std::iter::repeat(df_idx_left).take(indexes_right.len()));
+                        .extend(std::iter::repeat_n(df_idx_left, indexes_right.len()));
                 },
                 None => {
                     self.join_tuples_b.push(df_idx_left);
@@ -238,7 +238,7 @@ impl<K: ExtraPayload> GenericJoinProbe<K> {
                 let indexes_left = &indexes_left.0;
                 self.join_tuples_a.extend_from_slice(indexes_left);
                 self.join_tuples_b
-                    .extend(std::iter::repeat(df_idx_right).take(indexes_left.len()));
+                    .extend(std::iter::repeat_n(df_idx_right, indexes_left.len()));
             }
         }
     }

diff --git a/crates/polars-plan/src/plans/conversion/dsl_to_ir.rs b/crates/polars-plan/src/plans/conversion/dsl_to_ir.rs
@@ -567,8 +567,8 @@ pub fn to_alp_impl(lp: DslPlan, ctxt: &mut DslConversionContext) -> PolarsResult
                 )
                 .map_err(|e| e.context(failed_here!(sort)))?;
 
-                nulls_last.extend(std::iter::repeat(n).take(exprs.len()));
-                descending.extend(std::iter::repeat(d).take(exprs.len()));
+                nulls_last.extend(std::iter::repeat_n(n, exprs.len()));
+                descending.extend(std::iter::repeat_n(d, exprs.len()));
                 expanded_cols.extend(exprs);
             }
             sort_options.nulls_last = nulls_last;

diff --git a/crates/polars-python/src/interop/numpy/to_numpy_series.rs b/crates/polars-python/src/interop/numpy/to_numpy_series.rs
@@ -274,7 +274,7 @@ fn series_to_numpy_with_copy(py: Python, s: &Series, writable: bool) -> PyObject
         },
         Null => {
             let n = s.len();
-            let values = std::iter::repeat(f32::NAN).take(n);
+            let values = std::iter::repeat_n(f32::NAN, n);
             PyArray1::from_iter(py, values).into_py_any(py).unwrap()
         },
         Unknown(_) | BinaryOffset => unreachable!(),

diff --git a/crates/polars-python/src/map/series.rs b/crates/polars-python/src/map/series.rs
@@ -258,7 +258,7 @@ where
     I: Iterator<Item = Option<T>> + 'a,
 {
     let mut avs = Vec::with_capacity(len);
-    avs.extend(std::iter::repeat(AnyValue::Null).take(init_null_count));
+    avs.extend(std::iter::repeat_n(AnyValue::Null, init_null_count));
     avs.push(first_value);
 
     for opt_val in iter {
@@ -1184,7 +1184,7 @@ impl<'a> ApplyLambda<'a> for ListChunked {
     ) -> PyResult<Series> {
         let pypolars = polars(py).bind(py);
         let mut avs = Vec::with_capacity(self.len());
-        avs.extend(std::iter::repeat(AnyValue::Null).take(init_null_count));
+        avs.extend(std::iter::repeat_n(AnyValue::Null, init_null_count));
         avs.push(first_value);
 
         let call_with_value = |val: Series| {
@@ -1499,7 +1499,7 @@ impl<'a> ApplyLambda<'a> for ArrayChunked {
     ) -> PyResult<Series> {
         let pypolars = polars(py).bind(py);
         let mut avs = Vec::with_capacity(self.len());
-        avs.extend(std::iter::repeat(AnyValue::Null).take(init_null_count));
+        avs.extend(std::iter::repeat_n(AnyValue::Null, init_null_count));
         avs.push(first_value);
 
         let call_with_value = |val: Series| {
@@ -1951,7 +1951,7 @@ impl<'a> ApplyLambda<'a> for StructChunked {
         first_value: AnyValue<'a>,
     ) -> PyResult<Series> {
         let mut avs = Vec::with_capacity(self.len());
-        avs.extend(std::iter::repeat(AnyValue::Null).take(init_null_count));
+        avs.extend(std::iter::repeat_n(AnyValue::Null, init_null_count));
         avs.push(first_value);
 
         for val in iter_struct(self).skip(init_null_count + 1) {

diff --git a/crates/polars-python/src/series/export.rs b/crates/polars-python/src/series/export.rs
@@ -110,7 +110,7 @@ impl PySeries {
                 DataType::Null => {
                     let null: Option<u8> = None;
                     let n = series.len();
-                    let iter = std::iter::repeat(null).take(n);
+                    let iter = std::iter::repeat_n(null, n);
                     use std::iter::{Repeat, Take};
                     struct NullIter {
                         iter: Take<Repeat<Option<u8>>>,

diff --git a/crates/polars-utils/src/mmap.rs b/crates/polars-utils/src/mmap.rs
@@ -238,20 +238,14 @@ impl io::Seek for MemReader {
             io::SeekFrom::Start(position) => usize::min(position as usize, self.total_len()),
             io::SeekFrom::End(offset) => {
                 let Some(position) = self.total_len().checked_add_signed(offset as isize) else {
-                    return Err(io::Error::new(
-                        io::ErrorKind::Other,
-                        "Seek before to before buffer",
-                    ));
+                    return Err(io::Error::other("Seek before to before buffer"));
                 };
 
                 position
             },
             io::SeekFrom::Current(offset) => {
                 let Some(position) = self.position.checked_add_signed(offset as isize) else {
-                    return Err(io::Error::new(
-                        io::ErrorKind::Other,
-                        "Seek before to before buffer",
-                    ));
+                    return Err(io::Error::other("Seek before to before buffer"));
                 };
 
                 position