Refactor (#2573)

* refactor ChunkedArray::new_from_chunks -> from_chunks

* refactor ChunkedArray::new_from_slice -> from_slice

* refactor new_from_opt_iter, new_from_iter -> from_iter_options, from_iter_values

nodejs-polars/src/dataframe/frame.rs

@@ -748,7 +748,7 @@ pub fn transpose(cx: CallContext) -> JsResult<JsExternal> {
     if include_header {
         let name: String = params.get_or("headerName", "column".to_owned())?;
         let column_names = df.get_columns().iter().map(|s| s.name());
-        let s = Utf8Chunked::new_from_iter(&name, column_names).into_series();
+        let s = Utf8Chunked::from_iter_values(&name, column_names).into_series();
         new_df.insert_at_idx(0, s).unwrap();
     }
     new_df.try_into_js(&cx)

polars/polars-core/src/chunked_array/bitwise.rs

@@ -33,7 +33,7 @@ where
             })
             .collect::<Vec<_>>();
 
-        ChunkedArray::new_from_chunks(self.name(), chunks)
+        ChunkedArray::from_chunks(self.name(), chunks)
     }
 }
 
@@ -66,7 +66,7 @@ where
             })
             .collect::<Vec<_>>();
 
-        ChunkedArray::new_from_chunks(self.name(), chunks)
+        ChunkedArray::from_chunks(self.name(), chunks)
     }
 }
 
@@ -99,7 +99,7 @@ where
             })
             .collect::<Vec<_>>();
 
-        ChunkedArray::new_from_chunks(self.name(), chunks)
+        ChunkedArray::from_chunks(self.name(), chunks)
     }
 }
 
@@ -141,7 +141,7 @@ impl BitOr for &BooleanChunked {
                     as ArrayRef
             })
             .collect();
-        BooleanChunked::new_from_chunks(self.name(), chunks)
+        BooleanChunked::from_chunks(self.name(), chunks)
     }
 }
 
@@ -209,7 +209,7 @@ impl BitXor for &BooleanChunked {
             })
             .collect::<Vec<_>>();
 
-        ChunkedArray::new_from_chunks(self.name(), chunks)
+        ChunkedArray::from_chunks(self.name(), chunks)
     }
 }
 
@@ -255,7 +255,7 @@ impl BitAnd for &BooleanChunked {
                     as ArrayRef
             })
             .collect();
-        BooleanChunked::new_from_chunks(self.name(), chunks)
+        BooleanChunked::from_chunks(self.name(), chunks)
     }
 }
 

polars/polars-core/src/chunked_array/builder/from.rs

@@ -7,13 +7,13 @@ impl<T: PolarsNumericType> From<(&str, PrimitiveArray<T::Native>)> for ChunkedAr
         let name = tpl.0;
         let arr = tpl.1;
 
-        ChunkedArray::new_from_chunks(name, vec![Arc::new(arr)])
+        ChunkedArray::from_chunks(name, vec![Arc::new(arr)])
     }
 }
 
 impl<T: PolarsNumericType> From<&[T::Native]> for ChunkedArray<T> {
     fn from(slice: &[T::Native]) -> Self {
-        ChunkedArray::new_from_slice("", slice)
+        ChunkedArray::from_slice("", slice)
     }
 }
 
@@ -22,13 +22,13 @@ impl From<(&str, BooleanArray)> for BooleanChunked {
         let name = tpl.0;
         let arr = tpl.1;
 
-        ChunkedArray::new_from_chunks(name, vec![Arc::new(arr)])
+        ChunkedArray::from_chunks(name, vec![Arc::new(arr)])
     }
 }
 
 impl From<BooleanArray> for BooleanChunked {
     fn from(arr: BooleanArray) -> Self {
-        ChunkedArray::new_from_chunks("", vec![Arc::new(arr)])
+        ChunkedArray::from_chunks("", vec![Arc::new(arr)])
     }
 }
 
@@ -37,6 +37,6 @@ impl From<(&str, Utf8Array<i64>)> for Utf8Chunked {
         let name = tpl.0;
         let arr = tpl.1;
 
-        ChunkedArray::new_from_chunks(name, vec![Arc::new(arr)])
+        ChunkedArray::from_chunks(name, vec![Arc::new(arr)])
     }
 }

polars/polars-core/src/chunked_array/builder/list.rs

@@ -400,6 +400,6 @@ impl<'a> AnonymousListBuilder<'a> {
 
     pub fn finish(self) -> ListChunked {
         let arr = self.builder.finish().unwrap();
-        ListChunked::new_from_chunks(&self.name, vec![Arc::new(arr)])
+        ListChunked::from_chunks(&self.name, vec![Arc::new(arr)])
     }
 }

polars/polars-core/src/chunked_array/builder/mod.rs

@@ -41,35 +41,35 @@ where
         for (values, opt_buffer) in iter {
             chunks.push(to_array::<T>(values, opt_buffer))
         }
-        ChunkedArray::new_from_chunks("from_iter", chunks)
+        ChunkedArray::from_chunks("from_iter", chunks)
     }
 }
 
 pub trait NewChunkedArray<T, N> {
-    fn new_from_slice(name: &str, v: &[N]) -> Self;
-    fn new_from_opt_slice(name: &str, opt_v: &[Option<N>]) -> Self;
+    fn from_slice(name: &str, v: &[N]) -> Self;
+    fn from_slice_options(name: &str, opt_v: &[Option<N>]) -> Self;
 
     /// Create a new ChunkedArray from an iterator.
-    fn new_from_opt_iter(name: &str, it: impl Iterator<Item = Option<N>>) -> Self;
+    fn from_iter_options(name: &str, it: impl Iterator<Item = Option<N>>) -> Self;
 
     /// Create a new ChunkedArray from an iterator.
-    fn new_from_iter(name: &str, it: impl Iterator<Item = N>) -> Self;
+    fn from_iter_values(name: &str, it: impl Iterator<Item = N>) -> Self;
 }
 
 impl<T> NewChunkedArray<T, T::Native> for ChunkedArray<T>
 where
     T: PolarsNumericType,
 {
-    fn new_from_slice(name: &str, v: &[T::Native]) -> Self {
+    fn from_slice(name: &str, v: &[T::Native]) -> Self {
         let arr = PrimitiveArray::<T::Native>::from_slice(v).to(T::get_dtype().to_arrow());
-        ChunkedArray::new_from_chunks(name, vec![Arc::new(arr)])
+        ChunkedArray::from_chunks(name, vec![Arc::new(arr)])
     }
 
-    fn new_from_opt_slice(name: &str, opt_v: &[Option<T::Native>]) -> Self {
-        Self::new_from_opt_iter(name, opt_v.iter().copied())
+    fn from_slice_options(name: &str, opt_v: &[Option<T::Native>]) -> Self {
+        Self::from_iter_options(name, opt_v.iter().copied())
     }
 
-    fn new_from_opt_iter(
+    fn from_iter_options(
         name: &str,
         it: impl Iterator<Item = Option<T::Native>>,
     ) -> ChunkedArray<T> {
@@ -79,7 +79,7 @@ where
     }
 
     /// Create a new ChunkedArray from an iterator.
-    fn new_from_iter(name: &str, it: impl Iterator<Item = T::Native>) -> ChunkedArray<T> {
+    fn from_iter_values(name: &str, it: impl Iterator<Item = T::Native>) -> ChunkedArray<T> {
         let ca: NoNull<ChunkedArray<_>> = it.collect();
         let mut ca = ca.into_inner();
         ca.rename(name);
@@ -88,15 +88,15 @@ where
 }
 
 impl NewChunkedArray<BooleanType, bool> for BooleanChunked {
-    fn new_from_slice(name: &str, v: &[bool]) -> Self {
-        Self::new_from_iter(name, v.iter().copied())
+    fn from_slice(name: &str, v: &[bool]) -> Self {
+        Self::from_iter_values(name, v.iter().copied())
     }
 
-    fn new_from_opt_slice(name: &str, opt_v: &[Option<bool>]) -> Self {
-        Self::new_from_opt_iter(name, opt_v.iter().copied())
+    fn from_slice_options(name: &str, opt_v: &[Option<bool>]) -> Self {
+        Self::from_iter_options(name, opt_v.iter().copied())
     }
 
-    fn new_from_opt_iter(
+    fn from_iter_options(
         name: &str,
         it: impl Iterator<Item = Option<bool>>,
     ) -> ChunkedArray<BooleanType> {
@@ -106,7 +106,7 @@ impl NewChunkedArray<BooleanType, bool> for BooleanChunked {
     }
 
     /// Create a new ChunkedArray from an iterator.
-    fn new_from_iter(name: &str, it: impl Iterator<Item = bool>) -> ChunkedArray<BooleanType> {
+    fn from_iter_values(name: &str, it: impl Iterator<Item = bool>) -> ChunkedArray<BooleanType> {
         let mut ca: ChunkedArray<_> = it.collect();
         ca.rename(name);
         ca
@@ -117,13 +117,11 @@ impl<S> NewChunkedArray<Utf8Type, S> for Utf8Chunked
 where
     S: AsRef<str>,
 {
-    fn new_from_slice(name: &str, v: &[S]) -> Self {
+    fn from_slice(name: &str, v: &[S]) -> Self {
         let values_size = v.iter().fold(0, |acc, s| acc + s.as_ref().len());
 
         let mut builder = MutableUtf8Array::<i64>::with_capacities(v.len(), values_size);
-        v.iter().for_each(|val| {
-            builder.push(Some(val.as_ref()));
-        });
+        builder.extend_trusted_len_values(v.iter().map(|s| s.as_ref()));
 
         let field = Arc::new(Field::new(name, DataType::Utf8));
 
@@ -136,29 +134,34 @@ where
         }
     }
 
-    fn new_from_opt_slice(name: &str, opt_v: &[Option<S>]) -> Self {
+    fn from_slice_options(name: &str, opt_v: &[Option<S>]) -> Self {
         let values_size = opt_v.iter().fold(0, |acc, s| match s {
             Some(s) => acc + s.as_ref().len(),
             None => acc,
         });
-        let mut builder = Utf8ChunkedBuilder::new(name, opt_v.len(), values_size);
+        let mut builder = MutableUtf8Array::<i64>::with_capacities(opt_v.len(), values_size);
+        builder.extend_trusted_len(opt_v.iter().map(|s| s.as_ref()));
 
-        opt_v.iter().for_each(|opt| match opt {
-            Some(v) => builder.append_value(v.as_ref()),
-            None => builder.append_null(),
-        });
-        builder.finish()
+        let field = Arc::new(Field::new(name, DataType::Utf8));
+
+        ChunkedArray {
+            field,
+            chunks: vec![builder.into_arc()],
+            phantom: PhantomData,
+            categorical_map: None,
+            ..Default::default()
+        }
     }
 
-    fn new_from_opt_iter(name: &str, it: impl Iterator<Item = Option<S>>) -> Self {
+    fn from_iter_options(name: &str, it: impl Iterator<Item = Option<S>>) -> Self {
         let cap = get_iter_capacity(&it);
         let mut builder = Utf8ChunkedBuilder::new(name, cap, cap * 5);
         it.for_each(|opt| builder.append_option(opt));
         builder.finish()
     }
 
     /// Create a new ChunkedArray from an iterator.
-    fn new_from_iter(name: &str, it: impl Iterator<Item = S>) -> Self {
+    fn from_iter_values(name: &str, it: impl Iterator<Item = S>) -> Self {
         let cap = get_iter_capacity(&it);
         let mut builder = Utf8ChunkedBuilder::new(name, cap, cap * 5);
         it.for_each(|v| builder.append_value(v));
@@ -186,8 +189,8 @@ mod test {
         let mut builder = ListPrimitiveChunkedBuilder::<i32>::new("a", 10, 5, DataType::Int32);
 
         // create a series containing two chunks
-        let mut s1 = Int32Chunked::new_from_slice("a", &[1, 2, 3]).into_series();
-        let s2 = Int32Chunked::new_from_slice("b", &[4, 5, 6]).into_series();
+        let mut s1 = Int32Chunked::from_slice("a", &[1, 2, 3]).into_series();
+        let s2 = Int32Chunked::from_slice("b", &[4, 5, 6]).into_series();
         s1.append(&s2).unwrap();
 
         builder.append_series(&s1);

polars/polars-core/src/chunked_array/cast.rs

@@ -54,7 +54,7 @@ impl ChunkCast for CategoricalChunked {
                 Ok(ca.into_series())
             }
             DataType::UInt32 => {
-                let ca = UInt32Chunked::new_from_chunks(self.name(), self.chunks.clone());
+                let ca = UInt32Chunked::from_chunks(self.name(), self.chunks.clone());
                 Ok(ca.into_series())
             }
             #[cfg(feature = "dtype-categorical")]
@@ -73,7 +73,7 @@ where
             #[cfg(feature = "dtype-categorical")]
             (DataType::UInt32, DataType::Categorical)
             | (DataType::Categorical, DataType::Categorical) => {
-                let ca = CategoricalChunked::new_from_chunks(self.name(), self.chunks.clone())
+                let ca = CategoricalChunked::from_chunks(self.name(), self.chunks.clone())
                     .set_state(self);
                 Ok(ca.into_series())
             }
@@ -140,7 +140,7 @@ impl ChunkCast for ListChunked {
                     .downcast_iter()
                     .map(|list| cast_inner_list_type(list, &**child_type))
                     .collect::<Result<_>>()?;
-                let ca = ListChunked::new_from_chunks(self.name(), chunks);
+                let ca = ListChunked::from_chunks(self.name(), chunks);
                 Ok(ca.into_series())
             }
             _ => Err(PolarsError::ComputeError("Cannot cast list type".into())),

polars/polars-core/src/chunked_array/comparison.rs

@@ -32,7 +32,7 @@ where
             })
             .collect::<Vec<_>>();
 
-        ChunkedArray::new_from_chunks("", chunks)
+        ChunkedArray::from_chunks("", chunks)
     }
 }
 
@@ -223,7 +223,7 @@ fn compare_bools(
         .map(|(l, r)| Arc::new(f(l, r)) as ArrayRef)
         .collect();
 
-    BooleanChunked::new_from_chunks(lhs.name(), chunks)
+    BooleanChunked::from_chunks(lhs.name(), chunks)
 }
 
 impl ChunkCompare<&BooleanChunked> for BooleanChunked {
@@ -442,7 +442,7 @@ impl Utf8Chunked {
             })
             .collect::<Vec<_>>();
 
-        ChunkedArray::new_from_chunks("", chunks)
+        ChunkedArray::from_chunks("", chunks)
     }
 }
 
@@ -780,7 +780,7 @@ impl Not for &BooleanChunked {
                 Arc::new(arr) as ArrayRef
             })
             .collect::<Vec<_>>();
-        ChunkedArray::new_from_chunks(self.name(), chunks)
+        ChunkedArray::from_chunks(self.name(), chunks)
     }
 }
 
@@ -1074,8 +1074,8 @@ mod test {
     #[test]
     fn test_kleene() {
         let a = BooleanChunked::new("", &[Some(true), Some(false), None]);
-        let trues = BooleanChunked::new_from_slice("", &[true, true, true]);
-        let falses = BooleanChunked::new_from_slice("", &[false, false, false]);
+        let trues = BooleanChunked::from_slice("", &[true, true, true]);
+        let falses = BooleanChunked::from_slice("", &[false, false, false]);
 
         let c = &a | &trues;
         assert_eq!(Vec::from(&c), &[Some(true), Some(true), Some(true)]);
@@ -1086,9 +1086,9 @@ mod test {
 
     #[test]
     fn test_broadcasting_bools() {
-        let a = BooleanChunked::new_from_slice("", &[true, false, true]);
-        let true_ = BooleanChunked::new_from_slice("", &[true]);
-        let false_ = BooleanChunked::new_from_slice("", &[false]);
+        let a = BooleanChunked::from_slice("", &[true, false, true]);
+        let true_ = BooleanChunked::from_slice("", &[true]);
+        let false_ = BooleanChunked::from_slice("", &[false]);
 
         let out = a.equal(&true_);
         assert_eq!(Vec::from(&out), &[Some(true), Some(false), Some(true)]);
@@ -1147,9 +1147,9 @@ mod test {
 
     #[test]
     fn test_broadcasting_numeric() {
-        let a = Int32Chunked::new_from_slice("", &[1, 2, 3]);
-        let one = Int32Chunked::new_from_slice("", &[1]);
-        let three = Int32Chunked::new_from_slice("", &[3]);
+        let a = Int32Chunked::from_slice("", &[1, 2, 3]);
+        let one = Int32Chunked::from_slice("", &[1]);
+        let three = Int32Chunked::from_slice("", &[3]);
 
         let out = a.equal(&one);
         assert_eq!(Vec::from(&out), &[Some(true), Some(false), Some(false)]);

polars/polars-core/src/chunked_array/float.rs

@@ -28,6 +28,6 @@ where
             .downcast_iter()
             .map(|arr| Arc::new(set_at_nulls(arr, T::Native::nan())) as ArrayRef)
             .collect();
-        ChunkedArray::new_from_chunks(self.name(), chunks)
+        ChunkedArray::from_chunks(self.name(), chunks)
     }
 }