polars-df 0.25.1 → 0.26.1

data/ext/polars/src/on_startup.rs

@@ -5,6 +5,7 @@ use std::sync::OnceLock;
 
 use arrow::array::Array;
 use magnus::{IntoValue, Ruby, Value, prelude::*, value::Opaque};
+use polars::chunked_array::object::ObjectArray;
 use polars::prelude::*;
 use polars_core::chunked_array::object::builder::ObjectChunkedBuilder;
 use polars_core::chunked_array::object::registry;
@@ -23,7 +24,7 @@ use crate::ruby::gvl::GvlExt;
 use crate::ruby::ruby_convert_registry::{FromRubyConvertRegistry, RubyConvertRegistry};
 use crate::ruby::ruby_udf;
 use crate::ruby::thread::{is_non_ruby_thread, run_in_ruby_thread};
-use crate::ruby::utils::to_pl_err;
+use crate::ruby::utils::{TryIntoValue, to_pl_err};
 use crate::series::RbSeries;
 
 fn ruby_function_caller_series(
@@ -86,16 +87,23 @@ pub unsafe fn register_startup_deps(catch_keyboard_interrupt: bool) {
 
         let object_converter = Arc::new(|av: AnyValue| {
             let object = Ruby::attach(|rb| ObjectValue {
-                inner: Wrap(av).into_value_with(rb).into(),
+                inner: Wrap(av).try_into_value_with(rb).unwrap().into(),
             });
             Box::new(object) as Box<dyn Any>
         });
         let rbobject_converter = Arc::new(|av: AnyValue| {
-            let object = Ruby::attach(|rb| Wrap(av).into_value_with(rb));
+            let object = Ruby::attach(|rb| Wrap(av).try_into_value_with(rb).unwrap());
             Box::new(object) as Box<dyn Any>
         });
-        fn object_array_getter(_arr: &dyn Array, _idx: usize) -> Option<AnyValue<'_>> {
-            todo!();
+        fn object_array_getter(arr: &dyn Array, idx: usize) -> Option<AnyValue<'_>> {
+            let arr = arr
+                .as_any()
+                .downcast_ref::<ObjectArray<ObjectValue>>()
+                .unwrap();
+            arr.get(idx).map(|v| AnyValue::Object(v))
+        }
+        fn with_gil(f: &mut dyn FnMut()) {
+            Ruby::attach(|_| f())
         }
 
         crate::ruby::ruby_convert_registry::register_converters(RubyConvertRegistry {
@@ -170,13 +178,13 @@ pub unsafe fn register_startup_deps(catch_keyboard_interrupt: bool) {
                 }),
                 schema: Arc::new(|schema| {
                     Ruby::attach(|rb| {
-                        Ok(Wrap(
+                        Wrap(
                             schema
                                 .downcast_ref::<polars_core::schema::Schema>()
                                 .unwrap()
                                 .clone(),
                         )
-                        .into_value_with(rb))
+                        .try_into_value_with(rb)
                     })
                 }),
             },
@@ -190,6 +198,7 @@ pub unsafe fn register_startup_deps(catch_keyboard_interrupt: bool) {
             rbobject_converter,
             physical_dtype,
             Arc::new(object_array_getter),
+            Arc::new(with_gil),
         );
 
         // Register SERIES UDF.

data/ext/polars/src/ruby/capsule.rs

@@ -0,0 +1,27 @@
+use std::any::Any;
+use std::ffi::CString;
+
+#[magnus::wrap(class = "Polars::Capsule")]
+pub struct RbCapsule {
+    value: Box<dyn Any + Send>,
+    name: Option<CString>,
+}
+
+impl RbCapsule {
+    pub fn new<T: 'static + Send>(value: T, name: Option<CString>) -> Self {
+        Self {
+            value: Box::new(value),
+            name,
+        }
+    }
+
+    pub fn to_i(&self) -> usize {
+        (&*self.value as *const dyn Any as *const ()) as usize
+    }
+
+    // TODO use &CStr when Magnus supports it
+    // https://github.com/matsadler/magnus/pull/182
+    pub fn name(&self) -> Option<&str> {
+        self.name.as_deref().map(|v| v.to_str().unwrap())
+    }
+}

data/ext/polars/src/ruby/mod.rs

@@ -1,3 +1,4 @@
+pub mod capsule;
 pub mod exceptions;
 pub mod gvl;
 pub mod lazy;

data/ext/polars/src/ruby/numo.rs

@@ -40,14 +40,13 @@ where
 pub struct RbArray1<T>(T);
 
 impl<T: Element> RbArray1<T> {
-    pub fn from_iter<I>(values: I) -> RbResult<Value>
+    pub fn from_iter<I>(rb: &Ruby, values: I) -> RbResult<Value>
     where
         I: IntoIterator<Item = T>,
     {
-        let ruby = Ruby::get().unwrap();
-        ruby.class_object()
+        rb.class_object()
             .const_get::<_, RModule>("Numo")?
             .const_get::<_, RClass>(T::class_name())?
-            .funcall("cast", (ruby.ary_from_iter(values),))
+            .funcall("cast", (rb.ary_from_iter(values),))
     }
 }

data/ext/polars/src/ruby/rb_modules.rs

@@ -1,12 +1,10 @@
 use magnus::{Module, RClass, Ruby, value::Lazy};
 
-static BIGDECIMAL: Lazy<RClass> =
-    Lazy::new(|rb| rb.class_object().const_get("BigDecimal").unwrap());
 static DATE: Lazy<RClass> = Lazy::new(|rb| rb.class_object().const_get("Date").unwrap());
 static DATETIME: Lazy<RClass> = Lazy::new(|rb| rb.class_object().const_get("DateTime").unwrap());
 
-pub(crate) fn bigdecimal(rb: &Ruby) -> RClass {
-    rb.get_inner(&BIGDECIMAL)
+pub(crate) fn bigdecimal(rb: &Ruby) -> Option<RClass> {
+    rb.class_object().const_get("BigDecimal").ok()
 }
 
 pub(crate) fn date(rb: &Ruby) -> RClass {

data/ext/polars/src/ruby/ruby_udf.rs

@@ -82,15 +82,13 @@ impl AnonymousColumnsUdf for RubyUdfExpression {
 
     fn deep_clone(self: Arc<Self>) -> Arc<dyn AnonymousColumnsUdf> {
         Arc::new(Self {
-            ruby_function: ArcValue::new(
-                Ruby::attach(|rb| {
-                    // TODO fix
-                    rb.get_inner(*self.ruby_function.0)
-                        .funcall::<_, _, Value>("dup", ())
-                        .map(Opaque::from)
-                })
-                .unwrap(),
-            ),
+            ruby_function: ArcValue::new(Ruby::attach(|rb| {
+                // TODO fix
+                rb.get_inner(*self.ruby_function.0)
+                    .funcall::<_, _, Value>("dup", ())
+                    .map(Opaque::from)
+                    .unwrap()
+            })),
             output_type: self.output_type.clone(),
             materialized_field: OnceLock::new(),
             is_elementwise: self.is_elementwise,

data/ext/polars/src/ruby/utils.rs

@@ -1,8 +1,9 @@
 use std::sync::Arc;
 
-use magnus::{Error, Ruby, Value, gc, value::Opaque};
+use magnus::{Error, IntoValue, Ruby, Value, gc, value::Opaque};
 use polars::error::PolarsError;
 
+use crate::RbResult;
 use crate::ruby::gvl::GvlExt;
 
 pub(crate) fn to_pl_err(e: Error) -> PolarsError {
@@ -26,3 +27,13 @@ impl Drop for ArcValue {
         Ruby::attach(|_| gc::unregister_address(&*self.0));
     }
 }
+
+pub trait TryIntoValue {
+    fn try_into_value_with(self, ruby: &Ruby) -> RbResult<Value>;
+}
+
+impl<T: IntoValue> TryIntoValue for T {
+    fn try_into_value_with(self, ruby: &Ruby) -> RbResult<Value> {
+        Ok(self.into_value_with(ruby))
+    }
+}

data/ext/polars/src/series/aggregation.rs

@@ -3,11 +3,12 @@ use magnus::{IntoValue, Ruby, Value};
 use polars::prelude::*;
 
 use crate::prelude::*;
+use crate::ruby::utils::TryIntoValue;
 use crate::utils::EnterPolarsExt;
 use crate::{RbResult, RbSeries};
 
 fn scalar_to_rb(scalar: RbResult<Scalar>, rb: &Ruby) -> RbResult<Value> {
-    Ok(Wrap(scalar?.as_any_value()).into_value_with(rb))
+    Wrap(scalar?.as_any_value()).try_into_value_with(rb)
 }
 
 impl RbSeries {
@@ -35,6 +36,17 @@ impl RbSeries {
         })
     }
 
+    pub fn is_empty(rb: &Ruby, self_: &Self, ignore_nulls: bool) -> RbResult<bool> {
+        rb.enter_polars(|| {
+            let s = self_.series.read();
+            PolarsResult::Ok(if ignore_nulls {
+                s.is_full_null()
+            } else {
+                s.is_empty()
+            })
+        })
+    }
+
     pub fn arg_max(rb: &Ruby, self_: &Self) -> RbResult<Option<usize>> {
         rb.enter_polars_ok(|| self_.series.read().arg_max())
     }

data/ext/polars/src/series/export.rs

@@ -1,50 +1,51 @@
 use magnus::{IntoValue, Ruby, Value, value::ReprValue};
 use polars_core::prelude::*;
 
+use crate::interop::arrow::to_rb::series_to_stream;
 use crate::prelude::*;
+use crate::ruby::utils::TryIntoValue;
 use crate::{RbPolarsErr, RbResult, RbSeries};
 
 impl RbSeries {
     /// Convert this Series to a Ruby array.
     /// This operation copies data.
-    pub fn to_a(&self) -> RbResult<Value> {
-        let series = &self.series.read();
+    pub fn to_a(ruby: &Ruby, self_: &Self) -> RbResult<Value> {
+        let series = &self_.series.read();
 
-        fn to_a_recursive(series: &Series) -> RbResult<Value> {
-            let ruby = Ruby::get().unwrap();
+        fn to_a_recursive(ruby: &Ruby, series: &Series) -> RbResult<Value> {
             let rblist = match series.dtype() {
                 DataType::Boolean => ruby
-                    .ary_from_iter(series.bool().map_err(RbPolarsErr::from)?)
+                    .ary_from_iter(series.bool().map_err(RbPolarsErr::from)?.iter())
                     .as_value(),
                 DataType::UInt8 => ruby
-                    .ary_from_iter(series.u8().map_err(RbPolarsErr::from)?)
+                    .ary_from_iter(series.u8().map_err(RbPolarsErr::from)?.iter())
                     .as_value(),
                 DataType::UInt16 => ruby
-                    .ary_from_iter(series.u16().map_err(RbPolarsErr::from)?)
+                    .ary_from_iter(series.u16().map_err(RbPolarsErr::from)?.iter())
                     .as_value(),
                 DataType::UInt32 => ruby
-                    .ary_from_iter(series.u32().map_err(RbPolarsErr::from)?)
+                    .ary_from_iter(series.u32().map_err(RbPolarsErr::from)?.iter())
                     .as_value(),
                 DataType::UInt64 => ruby
-                    .ary_from_iter(series.u64().map_err(RbPolarsErr::from)?)
+                    .ary_from_iter(series.u64().map_err(RbPolarsErr::from)?.iter())
                     .as_value(),
                 DataType::UInt128 => ruby
-                    .ary_from_iter(series.u128().map_err(RbPolarsErr::from)?)
+                    .ary_from_iter(series.u128().map_err(RbPolarsErr::from)?.iter())
                     .as_value(),
                 DataType::Int8 => ruby
-                    .ary_from_iter(series.i8().map_err(RbPolarsErr::from)?)
+                    .ary_from_iter(series.i8().map_err(RbPolarsErr::from)?.iter())
                     .as_value(),
                 DataType::Int16 => ruby
-                    .ary_from_iter(series.i16().map_err(RbPolarsErr::from)?)
+                    .ary_from_iter(series.i16().map_err(RbPolarsErr::from)?.iter())
                     .as_value(),
                 DataType::Int32 => ruby
-                    .ary_from_iter(series.i32().map_err(RbPolarsErr::from)?)
+                    .ary_from_iter(series.i32().map_err(RbPolarsErr::from)?.iter())
                     .as_value(),
                 DataType::Int64 => ruby
-                    .ary_from_iter(series.i64().map_err(RbPolarsErr::from)?)
+                    .ary_from_iter(series.i64().map_err(RbPolarsErr::from)?.iter())
                     .as_value(),
                 DataType::Int128 => ruby
-                    .ary_from_iter(series.i128().map_err(RbPolarsErr::from)?)
+                    .ary_from_iter(series.i128().map_err(RbPolarsErr::from)?.iter())
                     .as_value(),
                 DataType::Float16 => ruby
                     .ary_from_iter(
@@ -53,14 +54,15 @@ impl RbSeries {
                             .cast(&DataType::Float32)
                             .map_err(RbPolarsErr::from)?
                             .f32()
-                            .map_err(RbPolarsErr::from)?,
+                            .map_err(RbPolarsErr::from)?
+                            .iter(),
                     )
                     .as_value(),
                 DataType::Float32 => ruby
-                    .ary_from_iter(series.f32().map_err(RbPolarsErr::from)?)
+                    .ary_from_iter(series.f32().map_err(RbPolarsErr::from)?.iter())
                     .as_value(),
                 DataType::Float64 => ruby
-                    .ary_from_iter(series.f64().map_err(RbPolarsErr::from)?)
+                    .ary_from_iter(series.f64().map_err(RbPolarsErr::from)?.iter())
                     .as_value(),
                 DataType::Categorical(_, _) | DataType::Enum(_, _) => {
                     with_match_categorical_physical_type!(series.dtype().cat_physical().unwrap(), |$C| {
@@ -71,10 +73,7 @@ impl RbSeries {
                     let v = ruby.ary_new_capa(series.len());
                     for i in 0..series.len() {
                         let obj: Option<&ObjectValue> = series.get_object(i).map(|any| any.into());
-                        match obj {
-                            Some(val) => v.push(val.to_value()).unwrap(),
-                            None => v.push(ruby.qnil()).unwrap(),
-                        };
+                        v.push(obj.cloned().into_value_with(ruby))?;
                     }
                     v.as_value()
                 }
@@ -87,7 +86,7 @@ impl RbSeries {
                                 v.push(ruby.qnil()).unwrap();
                             }
                             Some(s) => {
-                                let rblst = to_a_recursive(s.as_ref())?;
+                                let rblst = to_a_recursive(ruby, s.as_ref())?;
                                 v.push(rblst)?;
                             }
                         }
@@ -103,7 +102,7 @@ impl RbSeries {
                                 v.push(ruby.qnil()).unwrap();
                             }
                             Some(s) => {
-                                let rblst = to_a_recursive(s.as_ref())?;
+                                let rblst = to_a_recursive(ruby, s.as_ref())?;
                                 v.push(rblst)?;
                             }
                         }
@@ -112,35 +111,35 @@ impl RbSeries {
                 }
                 DataType::Date => {
                     let ca = series.date().map_err(RbPolarsErr::from)?;
-                    return Ok(Wrap(ca).into_value_with(&ruby));
+                    return Wrap(ca).try_into_value_with(ruby);
                 }
                 DataType::Time => {
                     let ca = series.time().map_err(RbPolarsErr::from)?;
-                    return Ok(Wrap(ca).into_value_with(&ruby));
+                    return Wrap(ca).try_into_value_with(ruby);
                 }
                 DataType::Datetime(_, _) => {
                     let ca = series.datetime().map_err(RbPolarsErr::from)?;
-                    return Ok(Wrap(ca).into_value_with(&ruby));
+                    return Wrap(ca).try_into_value_with(ruby);
                 }
                 DataType::Decimal(_, _) => {
                     let ca = series.decimal().map_err(RbPolarsErr::from)?;
-                    return Ok(Wrap(ca).into_value_with(&ruby));
+                    return Wrap(ca).try_into_value_with(ruby);
                 }
                 DataType::String => {
                     let ca = series.str().map_err(RbPolarsErr::from)?;
-                    return Ok(Wrap(ca).into_value_with(&ruby));
+                    return Wrap(ca).try_into_value_with(ruby);
                 }
                 DataType::Struct(_) => {
                     let ca = series.struct_().map_err(RbPolarsErr::from)?;
-                    return Ok(Wrap(ca).into_value_with(&ruby));
+                    return Wrap(ca).try_into_value_with(ruby);
                 }
                 DataType::Duration(_) => {
                     let ca = series.duration().map_err(RbPolarsErr::from)?;
-                    return Ok(Wrap(ca).into_value_with(&ruby));
+                    return Wrap(ca).try_into_value_with(ruby);
                 }
                 DataType::Binary => {
                     let ca = series.binary().map_err(RbPolarsErr::from)?;
-                    return Ok(Wrap(ca).into_value_with(&ruby));
+                    return Wrap(ca).try_into_value_with(ruby);
                 }
                 DataType::Null => {
                     let null: Option<u8> = None;
@@ -163,10 +162,7 @@ impl RbSeries {
                     }
                     impl ExactSizeIterator for NullIter {}
 
-                    Ruby::get()
-                        .unwrap()
-                        .ary_from_iter(NullIter { iter, n })
-                        .as_value()
+                    ruby.ary_from_iter(NullIter { iter, n }).as_value()
                 }
                 DataType::Unknown(_) => {
                     panic!("to_a not implemented for unknown")
@@ -175,12 +171,16 @@ impl RbSeries {
                     unreachable!()
                 }
                 DataType::Extension(_, _) => {
-                    return to_a_recursive(series.ext().unwrap().storage());
+                    return to_a_recursive(ruby, series.ext().unwrap().storage());
                 }
             };
             Ok(rblist.as_value())
         }
 
-        to_a_recursive(series)
+        to_a_recursive(ruby, series)
+    }
+
+    pub fn __arrow_c_stream__(ruby: &Ruby, self_: &Self) -> RbResult<Value> {
+        series_to_stream(&self_.series.read(), ruby)
     }
 }

data/ext/polars/src/series/general.rs

@@ -10,6 +10,7 @@ use crate::ruby::exceptions::{RbIndexError, RbRuntimeError, RbValueError};
 use crate::ruby::gvl::GvlExt;
 use crate::ruby::plan_callback::PlanCallbackExt;
 use crate::ruby::ruby_function::RubyObject;
+use crate::ruby::utils::TryIntoValue;
 use crate::utils::EnterPolarsExt;
 use crate::{RbDataFrame, RbErr, RbPolarsErr, RbResult, RbSeries};
 
@@ -112,7 +113,7 @@ impl RbSeries {
                 let rbseries = RbSeries::new(s);
                 rb_modules::pl_utils(ruby).funcall("wrap_s", (rbseries,))
             }
-            _ => Ok(Wrap(av).into_value_with(ruby)),
+            _ => Wrap(av).try_into_value_with(ruby),
         }
     }
 
@@ -156,8 +157,8 @@ impl RbSeries {
         self.series.write().rename(name.into());
     }
 
-    pub fn dtype(rb: &Ruby, self_: &Self) -> Value {
-        Wrap(self_.series.read().dtype().clone()).into_value_with(rb)
+    pub fn dtype(rb: &Ruby, self_: &Self) -> RbResult<Value> {
+        Wrap(self_.series.read().dtype().clone()).try_into_value_with(rb)
     }
 
     pub fn set_sorted_flag(&self, descending: bool) -> Self {

data/ext/polars/src/series/map.rs

@@ -4,6 +4,7 @@ use super::RbSeries;
 use crate::map::series::ApplyLambdaGeneric;
 use crate::prelude::*;
 use crate::ruby::gvl::GvlExt;
+use crate::ruby::utils::TryIntoValue;
 use crate::series::construction::series_from_objects;
 use crate::{RbPolarsErr, RbResult};
 use crate::{apply_all_polars_dtypes, raise_err};
@@ -78,7 +79,7 @@ fn call_and_collect_objects<T, I>(
     skip_nulls: bool,
 ) -> RbResult<Series>
 where
-    T: IntoValue,
+    T: TryIntoValue,
     I: Iterator<Item = Option<T>>,
 {
     let mut objects = Vec::with_capacity(len);
@@ -91,7 +92,7 @@ where
                 continue;
             }
             None => rb.qnil().into_value_with(rb),
-            Some(val) => val.into_value_with(rb),
+            Some(val) => val.try_into_value_with(rb)?,
         };
         let out: Value = lambda.funcall("call", (arg,))?;
         objects.push(ObjectValue {

data/ext/polars/src/series/scatter.rs

@@ -139,23 +139,23 @@ fn scatter_impl(
             with_match_physical_numeric_polars_type!(dt, |$T| {
                 let ca: &mut ChunkedArray<$T> = mutable_s.as_mut();
                 let values: &ChunkedArray<$T> = values.as_ref().as_ref();
-                ca.scatter(idx, values)
+                ca.scatter(idx, values.iter())
             })
         }
         DataType::Boolean => {
             let ca: &mut ChunkedArray<BooleanType> = mutable_s.as_mut();
             let values = values.bool()?;
-            ca.scatter(idx, values)
+            ca.scatter(idx, values.iter())
         }
         DataType::Binary => {
             let ca: &mut ChunkedArray<BinaryType> = mutable_s.as_mut();
             let values = values.binary()?;
-            ca.scatter(idx, values)
+            ca.scatter(idx, values.iter())
         }
         DataType::String => {
             let ca: &mut ChunkedArray<StringType> = mutable_s.as_mut();
             let values = values.str()?;
-            ca.scatter(idx, values)
+            ca.scatter(idx, values.iter())
         }
         _ => Err(PolarsError::ComputeError(
             format!("not yet implemented for dtype: {logical_dtype}").into(),

data/ext/polars/src/utils.rs

@@ -16,7 +16,6 @@ macro_rules! apply_all_polars_dtypes {
     ($self:expr, $method:ident, $($args:expr),*) => {
         match $self.dtype() {
             DataType::Boolean => $self.bool().unwrap().$method($($args),*),
-            DataType::String => $self.str().unwrap().$method($($args),*),
             DataType::UInt8 => $self.u8().unwrap().$method($($args),*),
             DataType::UInt16 => $self.u16().unwrap().$method($($args),*),
             DataType::UInt32 => $self.u32().unwrap().$method($($args),*),
@@ -27,15 +26,40 @@ macro_rules! apply_all_polars_dtypes {
             DataType::Int32 => $self.i32().unwrap().$method($($args),*),
             DataType::Int64 => $self.i64().unwrap().$method($($args),*),
             DataType::Int128 => $self.i128().unwrap().$method($($args),*),
-            DataType::Float16 => todo!(),
+            DataType::Float16 => $self.cast(&DataType::Float32).unwrap().f32().unwrap().$method($($args),*),
             DataType::Float32 => $self.f32().unwrap().$method($($args),*),
             DataType::Float64 => $self.f64().unwrap().$method($($args),*),
-            DataType::Date => $self.date().unwrap().physical().$method($($args),*),
-            DataType::Datetime(_, _) => $self.datetime().unwrap().physical().$method($($args),*),
-            // TODO implement
-            // DataType::List(_) => $self.list().unwrap().$method($($args),*),
+            DataType::String => $self.str().unwrap().$method($($args),*),
+            DataType::Binary => $self.binary().unwrap().$method($($args),*),
+            DataType::Decimal(_, _) => $self.decimal().unwrap().$method($($args),*),
+
+            DataType::Date => $self.date().unwrap().$method($($args),*),
+            DataType::Datetime(_, _) => $self.datetime().unwrap().$method($($args),*),
+            DataType::Duration(_) => $self.duration().unwrap().$method($($args),*),
+            DataType::Time => $self.time().unwrap().$method($($args),*),
+
+            DataType::List(_) => $self.list().unwrap().$method($($args),*),
             DataType::Struct(_) => $self.struct_().unwrap().$method($($args),*),
-            dt => panic!("dtype {:?} not supported", dt)
+            DataType::Array(_, _) => $self.array().unwrap().$method($($args),*),
+
+            dt @ (DataType::Categorical(_, _) | DataType::Enum(_, _)) => match dt.cat_physical().unwrap() {
+                CategoricalPhysical::U8 => $self.cat8().unwrap().$method($($args),*),
+                CategoricalPhysical::U16 => $self.cat16().unwrap().$method($($args),*),
+                CategoricalPhysical::U32 => $self.cat32().unwrap().$method($($args),*),
+            },
+
+            DataType::Object(_) => {
+                $self
+                .as_any()
+                .downcast_ref::<ObjectChunked<ObjectValue>>()
+                .unwrap()
+                .$method($($args),*)
+            },
+            DataType::Extension(_, _) => $self.ext().unwrap().$method($($args),*),
+
+            DataType::Null => $self.null().unwrap().$method($($args),*),
+
+            dt @ (DataType::BinaryOffset | DataType::Unknown(_)) => panic!("dtype {:?} not supported", dt)
         }
     }
 }

data/lib/polars/array_expr.rb

@@ -377,7 +377,9 @@ module Polars
     #   # │ [1, 2]    │
     #   # └───────────┘
     def unique(maintain_order: false)
-      Utils.wrap_expr(_rbexpr.arr_unique(maintain_order))
+      eval(
+        F.element.unique(maintain_order: maintain_order), as_list: true
+      )
     end
 
     # Count the number of unique values in every sub-arrays.
@@ -403,7 +405,7 @@ module Polars
     #   # │ [2, 3, 4]     ┆ 3        │
     #   # └───────────────┴──────────┘
     def n_unique
-      Utils.wrap_expr(_rbexpr.arr_n_unique)
+      agg(F.element.n_unique)
     end
 
     # Convert an Array column into a List column with the same inner data type.
@@ -432,6 +434,13 @@ module Polars
 
     # Evaluate whether any boolean value is true for every subarray.
     #
+    # @param ignore_nulls [Boolean]
+    #   * If set to `true` (default), null values are ignored. If there
+    #     are no non-null values, the output is `false`.
+    #   * If set to `false`, [Kleene logic](https://en.wikipedia.org/wiki/Three-valued_logic) is used to deal with nulls:
+    #     if the column contains any null values and no `true` values,
+    #     the output is null.
+    #
     # @return [Expr]
     #
     # @example
@@ -461,12 +470,19 @@ module Polars
     #   # │ [null, null]   ┆ false │
     #   # │ null           ┆ null  │
     #   # └────────────────┴───────┘
-    def any
-      Utils.wrap_expr(_rbexpr.arr_any)
+    def any(ignore_nulls: true)
+      agg(F.element.any(ignore_nulls: ignore_nulls))
     end
 
     # Evaluate whether all boolean values are true for every subarray.
     #
+    # @param ignore_nulls [Boolean]
+    #   * If set to `true` (default), null values are ignored. If there
+    #     are no non-null values, the output is `true`.
+    #   * If set to `false`, [Kleene logic](https://en.wikipedia.org/wiki/Three-valued_logic) is used to deal with nulls:
+    #     if the column contains any null values and no `false` values,
+    #     the output is null.
+    #
     # @return [Expr]
     #
     # @example
@@ -496,8 +512,8 @@ module Polars
     #   # │ [null, null]   ┆ true  │
     #   # │ null           ┆ null  │
     #   # └────────────────┴───────┘
-    def all
-      Utils.wrap_expr(_rbexpr.arr_all)
+    def all(ignore_nulls: true)
+      agg(F.element.all(ignore_nulls: ignore_nulls))
     end
 
     # Sort the arrays in this column.
@@ -567,7 +583,7 @@ module Polars
     #   # │ [9, 1, 2]     ┆ [2, 1, 9]     │
     #   # └───────────────┴───────────────┘
     def reverse
-      Utils.wrap_expr(_rbexpr.arr_reverse)
+      eval(F.element.reverse)
     end
 
     # Retrieve the index of the minimal value in every sub-array.

data/lib/polars/array_name_space.rb

@@ -212,6 +212,13 @@ module Polars
 
     # Evaluate whether any boolean value is true for every subarray.
     #
+    # @param ignore_nulls [Boolean]
+    #   * If set to `true` (default), null values are ignored. If there
+    #     are no non-null values, the output is `false`.
+    #   * If set to `false`, [Kleene logic](https://en.wikipedia.org/wiki/Three-valued_logic) is used to deal with nulls:
+    #     if the column contains any null values and no `true` values,
+    #     the output is null.
+    #
     # @return [Series]
     #
     # @example
@@ -230,7 +237,7 @@ module Polars
     #   #         false
     #   #         null
     #   # ]
-    def any
+    def any(ignore_nulls: true)
       super
     end
 
@@ -378,6 +385,13 @@ module Polars
 
     # Evaluate whether all boolean values are true for every subarray.
     #
+    # @param ignore_nulls [Boolean]
+    #   * If set to `true` (default), null values are ignored. If there
+    #     are no non-null values, the output is `true`.
+    #   * If set to `false`, [Kleene logic](https://en.wikipedia.org/wiki/Three-valued_logic) is used to deal with nulls:
+    #     if the column contains any null values and no `false` values,
+    #     the output is null.
+    #
     # @return [Series]
     #
     # @example
@@ -396,7 +410,7 @@ module Polars
     #   #         true
     #   #         null
     #   # ]
-    def all
+    def all(ignore_nulls: true)
       super
     end