From 8eb93dc69bd091fd842565341e78a472ce557b5a Mon Sep 17 00:00:00 2001 From: ritchie Date: Fri, 7 Mar 2025 15:47:08 +0100 Subject: [PATCH] repeat [skip ci] --- crates/polars-arrow/src/array/binview/mutable.rs | 4 ++-- crates/polars-arrow/src/array/boolean/mutable.rs | 7 ++++--- .../polars-arrow/src/array/fixed_size_list/ffi.rs | 2 +- .../polars-arrow/src/array/fixed_size_list/mod.rs | 4 ++-- crates/polars-arrow/src/array/static_array.rs | 2 +- crates/polars-arrow/src/bitmap/mutable.rs | 2 +- crates/polars-arrow/src/legacy/kernels/set.rs | 4 ++-- .../src/legacy/kernels/sorted_join/left.rs | 5 ++++- crates/polars-arrow/src/trusted_len.rs | 6 ++++-- .../src/chunked_array/object/extension/mod.rs | 2 +- crates/polars-core/src/chunked_array/ops/full.rs | 2 +- .../src/chunked_array/ops/rolling_window.rs | 2 +- .../polars-core/src/chunked_array/ops/sort/mod.rs | 8 ++++---- crates/polars-error/src/lib.rs | 6 +----- crates/polars-json/src/json/write/serialize.rs | 2 +- crates/polars-ops/src/chunked_array/repeat_by.rs | 8 ++++---- .../src/frame/join/hash_join/single_keys_left.rs | 2 +- crates/polars-ops/src/frame/join/merge_sorted.rs | 2 +- crates/polars-ops/src/series/ops/is_in.rs | 2 +- .../parquet/encoding/delta_bitpacked/encoder.rs | 2 +- .../sinks/joins/generic_probe_inner_left.rs | 4 ++-- .../polars-plan/src/plans/conversion/dsl_to_ir.rs | 4 ++-- .../src/interop/numpy/to_numpy_series.rs | 2 +- crates/polars-python/src/map/series.rs | 8 ++++---- crates/polars-python/src/series/export.rs | 2 +- crates/polars-utils/src/mmap.rs | 10 ++-------- crates/polars/tests/it/arrow/array/binary/mod.rs | 4 ++-- crates/polars/tests/it/arrow/array/boolean/mod.rs | 6 +++--- .../tests/it/arrow/array/boolean/mutable.rs | 4 ++-- .../tests/it/arrow/array/equal/fixed_size_list.rs | 2 +- .../tests/it/arrow/array/fixed_size_binary/mod.rs | 2 +- .../tests/it/arrow/array/primitive/mutable.rs | 2 +- crates/polars/tests/it/arrow/bitmap/assign_ops.rs | 15 ++++++--------- crates/polars/tests/it/arrow/bitmap/mutable.rs | 4 ++-- crates/polars/tests/it/arrow/compute/boolean.rs | 4 ++-- crates/polars/tests/it/io/ipc.rs | 2 +- .../tests/it/io/parquet/read/primitive_nested.rs | 8 ++++---- crates/polars/tests/it/lazy/expressions/slice.rs | 2 +- 38 files changed, 76 insertions(+), 83 deletions(-) diff --git a/crates/polars-arrow/src/array/binview/mutable.rs b/crates/polars-arrow/src/array/binview/mutable.rs index cb3b38243ab1..8c56491946ae 100644 --- a/crates/polars-arrow/src/array/binview/mutable.rs +++ b/crates/polars-arrow/src/array/binview/mutable.rs @@ -340,7 +340,7 @@ impl MutableBinaryViewArray { 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 MutableBinaryViewArray { }) .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 index 4a53d763a7b9..07f54e26d107 100644 --- 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 index 297d7ae8e5f2..fcf0a9065d54 100644 --- 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 FromFfi 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 index 7b4005c807be..dc63a692cc9a 100644 --- 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 index a92a80be8954..f889b973cc0c 100644 --- 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 index 7bca9de0bf82..b9f150150430 100644 --- 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 index 338fc4b1a17c..46a53ff75955 100644 --- 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( 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 index 3d41574bcbf8..6e35ba7c48bc 100644 --- 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( 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 index 242e8d2878a5..794f995caca6 100644 --- a/crates/polars-arrow/src/trusted_len.rs +++ b/crates/polars-arrow/src/trusted_len.rs @@ -57,6 +57,8 @@ unsafe impl TrustedLen for std::iter::Repeat {} unsafe impl A> TrustedLen for std::iter::RepeatWith {} unsafe impl TrustedLen for std::iter::Take {} +unsafe impl TrustedLen for std::iter::RepeatN {} + unsafe impl TrustedLen for &mut dyn TrustedLen {} unsafe impl TrustedLen for Box + '_> {} @@ -100,11 +102,11 @@ where } } -impl TrustMyLength>, J> { +impl TrustMyLength, 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 index 05838a666ac9..e67b55c019a6 100644 --- 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> + 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 index a9de1d05d93f..367c9d000dd7 100644 --- 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 = 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 index 7d0d3d54f9a3..2112fabd3452 100644 --- 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 index c801c420d964..6385d2c394b9 100644 --- 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 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 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 index 7d938769d9cd..3b0bed0ede83 100644 --- a/crates/polars-error/src/lib.rs +++ b/crates/polars-error/src/lib.rs @@ -150,11 +150,7 @@ impl From for PolarsError { #[cfg(feature = "object_store")] impl From 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 index 4e3ec6cfeb58..d0ff1b93d8a9 100644 --- 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 + Send + Sync> { let f = |_x: (), buf: &mut Vec| 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 index ad30240c650d..0452319d2312 100644 --- 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::>(); + let values = std::iter::repeat_n(x, len).collect::>(); 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 (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 (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 index 3dda2a995551..8897a6f5cbbe 100644 --- 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 index a3970d3fa0fb..7a0aa5197b1d 100644 --- 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 index 3520658b58a2..9166c7629544 100644 --- 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 GenericJoinProbe { 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 GenericJoinProbe { 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 index 62ad0011460e..0696163bfb74 100644 --- 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 index 788f32e493af..27f099d316da 100644 --- 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 index edc7967122b2..bb8506372098 100644 --- a/crates/polars-python/src/map/series.rs +++ b/crates/polars-python/src/map/series.rs @@ -258,7 +258,7 @@ where I: Iterator> + '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 { 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 { 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 { 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 index 6888a4a0de83..b4d974a8961a 100644 --- 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 = 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>>, diff --git a/crates/polars-utils/src/mmap.rs b/crates/polars-utils/src/mmap.rs index 922e78d30cc2..9a362dcd625f 100644 --- 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 diff --git a/crates/polars/tests/it/arrow/array/binary/mod.rs b/crates/polars/tests/it/arrow/array/binary/mod.rs index 5c06c8e7680c..2478bafa1bc3 100644 --- a/crates/polars/tests/it/arrow/array/binary/mod.rs +++ b/crates/polars/tests/it/arrow/array/binary/mod.rs @@ -84,7 +84,7 @@ fn from() { #[test] fn from_trusted_len_iter() { - let iter = std::iter::repeat(b"hello").take(2).map(Some); + let iter = std::iter::repeat_n(b"hello", 2).map(Some); let a = BinaryArray::::from_trusted_len_iter(iter); assert_eq!(a.len(), 2); } @@ -101,7 +101,7 @@ fn try_from_trusted_len_iter() { #[test] fn from_iter() { - let iter = std::iter::repeat(b"hello").take(2).map(Some); + let iter = std::iter::repeat_n(b"hello", 2).map(Some); let a: BinaryArray = iter.collect(); assert_eq!(a.len(), 2); } diff --git a/crates/polars/tests/it/arrow/array/boolean/mod.rs b/crates/polars/tests/it/arrow/array/boolean/mod.rs index 2c0e3c4d6d76..1803e87093b0 100644 --- a/crates/polars/tests/it/arrow/array/boolean/mod.rs +++ b/crates/polars/tests/it/arrow/array/boolean/mod.rs @@ -113,7 +113,7 @@ fn empty() { #[test] fn from_trusted_len_iter() { - let iter = std::iter::repeat(true).take(2).map(Some); + let iter = std::iter::repeat_n(true, 2).map(Some); let a = BooleanArray::from_trusted_len_iter(iter.clone()); assert_eq!(a.len(), 2); let a = unsafe { BooleanArray::from_trusted_len_iter_unchecked(iter) }; @@ -134,7 +134,7 @@ fn try_from_trusted_len_iter() { #[test] fn from_trusted_len_values_iter() { - let iter = std::iter::repeat(true).take(2); + let iter = std::iter::repeat_n(true, 2); let a = BooleanArray::from_trusted_len_values_iter(iter.clone()); assert_eq!(a.len(), 2); let a = unsafe { BooleanArray::from_trusted_len_values_iter_unchecked(iter) }; @@ -143,7 +143,7 @@ fn from_trusted_len_values_iter() { #[test] fn from_iter() { - let iter = std::iter::repeat(true).take(2).map(Some); + let iter = std::iter::repeat_n(true, 2).map(Some); let a: BooleanArray = iter.collect(); assert_eq!(a.len(), 2); } diff --git a/crates/polars/tests/it/arrow/array/boolean/mutable.rs b/crates/polars/tests/it/arrow/array/boolean/mutable.rs index 5264c552edab..bbacf16d2d93 100644 --- a/crates/polars/tests/it/arrow/array/boolean/mutable.rs +++ b/crates/polars/tests/it/arrow/array/boolean/mutable.rs @@ -76,14 +76,14 @@ fn pop_all_some() { #[test] fn from_trusted_len_iter() { - let iter = std::iter::repeat(true).take(2).map(Some); + let iter = std::iter::repeat_n(true, 2).map(Some); let a = MutableBooleanArray::from_trusted_len_iter(iter); assert_eq!(a, MutableBooleanArray::from([Some(true), Some(true)])); } #[test] fn from_iter() { - let iter = std::iter::repeat(true).take(2).map(Some); + let iter = std::iter::repeat_n(true, 2).map(Some); let a: MutableBooleanArray = iter.collect(); assert_eq!(a, MutableBooleanArray::from([Some(true), Some(true)])); } diff --git a/crates/polars/tests/it/arrow/array/equal/fixed_size_list.rs b/crates/polars/tests/it/arrow/array/equal/fixed_size_list.rs index 04238ab7362f..0c9629d85422 100644 --- a/crates/polars/tests/it/arrow/array/equal/fixed_size_list.rs +++ b/crates/polars/tests/it/arrow/array/equal/fixed_size_list.rs @@ -11,7 +11,7 @@ fn create_fixed_size_list_array, T: AsRef<[Option]>>( let data = data.as_ref().iter().map(|x| { Some(match x { Some(x) => x.as_ref().iter().map(|x| Some(*x)).collect::>(), - None => std::iter::repeat(None).take(3).collect::>(), + None => std::iter::repeat_n(None, 3).collect::>(), }) }); diff --git a/crates/polars/tests/it/arrow/array/fixed_size_binary/mod.rs b/crates/polars/tests/it/arrow/array/fixed_size_binary/mod.rs index cdf9f8442dc5..f1ad6334912e 100644 --- a/crates/polars/tests/it/arrow/array/fixed_size_binary/mod.rs +++ b/crates/polars/tests/it/arrow/array/fixed_size_binary/mod.rs @@ -61,7 +61,7 @@ fn null() { #[test] fn from_iter() { - let iter = std::iter::repeat(vec![1u8, 2]).take(2).map(Some); + let iter = std::iter::repeat_n(vec![1u8, 2], 2).map(Some); let a = FixedSizeBinaryArray::from_iter(iter, 2); assert_eq!(a.len(), 2); } diff --git a/crates/polars/tests/it/arrow/array/primitive/mutable.rs b/crates/polars/tests/it/arrow/array/primitive/mutable.rs index 4bc29890de07..e5f3ef81d77b 100644 --- a/crates/polars/tests/it/arrow/array/primitive/mutable.rs +++ b/crates/polars/tests/it/arrow/array/primitive/mutable.rs @@ -305,7 +305,7 @@ fn set_values() { #[test] fn try_from_trusted_len_iter() { - let iter = std::iter::repeat(Some(1)).take(2).map(PolarsResult::Ok); + let iter = std::iter::repeat_n(Some(1), 2).map(PolarsResult::Ok); let a = MutablePrimitiveArray::try_from_trusted_len_iter(iter).unwrap(); assert_eq!(a, MutablePrimitiveArray::from([Some(1), Some(1)])); } diff --git a/crates/polars/tests/it/arrow/bitmap/assign_ops.rs b/crates/polars/tests/it/arrow/bitmap/assign_ops.rs index 939133f0a5fe..8465441c1766 100644 --- a/crates/polars/tests/it/arrow/bitmap/assign_ops.rs +++ b/crates/polars/tests/it/arrow/bitmap/assign_ops.rs @@ -5,15 +5,12 @@ use super::bitmap_strategy; #[test] fn basics() { - let mut b = MutableBitmap::from_iter(std::iter::repeat(true).take(10)); + let mut b = MutableBitmap::from_iter(std::iter::repeat_n(true, 10)); unary_assign(&mut b, |x: u8| !x); - assert_eq!( - b, - MutableBitmap::from_iter(std::iter::repeat(false).take(10)) - ); + assert_eq!(b, MutableBitmap::from_iter(std::iter::repeat_n(false, 10))); - let mut b = MutableBitmap::from_iter(std::iter::repeat(true).take(10)); - let c = Bitmap::from_iter(std::iter::repeat(true).take(10)); + let mut b = MutableBitmap::from_iter(std::iter::repeat_n(true, 10)); + let c = Bitmap::from_iter(std::iter::repeat_n(true, 10)); binary_assign(&mut b, &c, |x: u8, y| x | y); assert_eq!( b, @@ -25,8 +22,8 @@ fn basics() { fn binary_assign_oob() { // this check we don't have an oob access if the bitmaps are size T + 1 // and we do some slicing. - let a = MutableBitmap::from_iter(std::iter::repeat(true).take(65)); - let b = MutableBitmap::from_iter(std::iter::repeat(true).take(65)); + let a = MutableBitmap::from_iter(std::iter::repeat_n(true, 65)); + let b = MutableBitmap::from_iter(std::iter::repeat_n(true, 65)); let a: Bitmap = a.into(); let a = a.sliced(10, 20); diff --git a/crates/polars/tests/it/arrow/bitmap/mutable.rs b/crates/polars/tests/it/arrow/bitmap/mutable.rs index ffee6e28431b..fd9f846ed993 100644 --- a/crates/polars/tests/it/arrow/bitmap/mutable.rs +++ b/crates/polars/tests/it/arrow/bitmap/mutable.rs @@ -394,7 +394,7 @@ fn extend_constant1() { MutableBitmap::from_iter( std::iter::repeat(false) .take(i) - .chain(std::iter::repeat(true).take(j)) + .chain(std::iter::repeat_n(true, j)) ) ); @@ -406,7 +406,7 @@ fn extend_constant1() { MutableBitmap::from_iter( std::iter::repeat(true) .take(i) - .chain(std::iter::repeat(false).take(j)) + .chain(std::iter::repeat_n(false, j)) ) ); } diff --git a/crates/polars/tests/it/arrow/compute/boolean.rs b/crates/polars/tests/it/arrow/compute/boolean.rs index 488a53b4732d..c209421976c3 100644 --- a/crates/polars/tests/it/arrow/compute/boolean.rs +++ b/crates/polars/tests/it/arrow/compute/boolean.rs @@ -432,10 +432,10 @@ fn test_any_all() { let array = BooleanArray::from(&[None, Some(true), Some(true)]); assert!(any(&array)); assert!(all(&array)); - let array = BooleanArray::from_iter(std::iter::repeat(false).take(10).map(Some)); + let array = BooleanArray::from_iter(std::iter::repeat_n(false, 10).map(Some)); assert!(!any(&array)); assert!(!all(&array)); - let array = BooleanArray::from_iter(std::iter::repeat(true).take(10).map(Some)); + let array = BooleanArray::from_iter(std::iter::repeat_n(true, 10).map(Some)); assert!(any(&array)); assert!(all(&array)); let array = BooleanArray::from_iter([true, false, true, true].map(Some)); diff --git a/crates/polars/tests/it/io/ipc.rs b/crates/polars/tests/it/io/ipc.rs index 959886e33b72..b8930f12baf7 100644 --- a/crates/polars/tests/it/io/ipc.rs +++ b/crates/polars/tests/it/io/ipc.rs @@ -5,7 +5,7 @@ use polars::prelude::*; #[test] fn test_ipc_compression_variadic_buffers() { let mut df = df![ - "foo" => std::iter::repeat("Home delivery vat 24 %").take(3).collect::>() + "foo" => std::iter::repeat_n("Home delivery vat 24 %",3).collect::>() ] .unwrap(); diff --git a/crates/polars/tests/it/io/parquet/read/primitive_nested.rs b/crates/polars/tests/it/io/parquet/read/primitive_nested.rs index 430df46d1239..6d231108d0d8 100644 --- a/crates/polars/tests/it/io/parquet/read/primitive_nested.rs +++ b/crates/polars/tests/it/io/parquet/read/primitive_nested.rs @@ -79,8 +79,8 @@ fn read_array_impl>( (def_level_encoding.0, max_def_level == 0), ) { ((Encoding::Rle, true), (Encoding::Rle, true)) => compose_array( - std::iter::repeat(0).take(length), - std::iter::repeat(0).take(length), + std::iter::repeat_n(0, length), + std::iter::repeat_n(0, length), max_rep_level, max_def_level, values, @@ -90,7 +90,7 @@ fn read_array_impl>( let rep_levels = HybridRleDecoder::new(rep_levels, num_bits, length); compose_array( hybrid_rle_iter(rep_levels)?, - std::iter::repeat(0).take(length), + std::iter::repeat_n(0, length), max_rep_level, max_def_level, values, @@ -100,7 +100,7 @@ fn read_array_impl>( let num_bits = get_bit_width(def_level_encoding.1); let def_levels = HybridRleDecoder::new(def_levels, num_bits, length); compose_array( - std::iter::repeat(0).take(length), + std::iter::repeat_n(0, length), hybrid_rle_iter(def_levels)?, max_rep_level, max_def_level, diff --git a/crates/polars/tests/it/lazy/expressions/slice.rs b/crates/polars/tests/it/lazy/expressions/slice.rs index 52ac5422a935..78fe3f87b1e6 100644 --- a/crates/polars/tests/it/lazy/expressions/slice.rs +++ b/crates/polars/tests/it/lazy/expressions/slice.rs @@ -6,7 +6,7 @@ use super::*; fn test_slice_args() -> PolarsResult<()> { let groups: StringChunked = std::iter::repeat("a") .take(10) - .chain(std::iter::repeat("b").take(20)) + .chain(std::iter::repeat_n("b", 20)) .collect(); let df = df![