polars-df 0.21.0 → 0.22.0

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

@@ -1,4 +1,4 @@
-use magnus::{IntoValue, RArray, TryConvert, Value, class, prelude::*, typed_data::Obj};
+use magnus::{IntoValue, RArray, Ruby, TryConvert, Value, prelude::*, typed_data::Obj};
 use polars::prelude::*;
 use polars_core::frame::row::{Row, rows_to_schema_first_non_null};
 use polars_core::series::SeriesIter;
@@ -6,14 +6,14 @@ use polars_core::series::SeriesIter;
 use super::*;
 use crate::{RbDataFrame, RbPolarsErr, RbSeries, Wrap};
 
-fn get_iters(df: &DataFrame) -> Vec<SeriesIter> {
+fn get_iters(df: &DataFrame) -> Vec<SeriesIter<'_>> {
     df.get_columns()
         .iter()
         .map(|s| s.as_materialized_series().iter())
         .collect()
 }
 
-fn get_iters_skip(df: &DataFrame, skip: usize) -> Vec<std::iter::Skip<SeriesIter>> {
+fn get_iters_skip(df: &DataFrame, skip: usize) -> Vec<std::iter::Skip<SeriesIter<'_>>> {
     df.get_columns()
         .iter()
         .map(|s| s.as_materialized_series().iter().skip(skip))
@@ -25,32 +25,35 @@ pub fn apply_lambda_unknown<'a>(
     lambda: Value,
     inference_size: usize,
 ) -> RbResult<(Value, bool)> {
+    let ruby = Ruby::get_with(lambda);
     let mut null_count = 0;
     let mut iters = get_iters(df);
 
     for _ in 0..df.height() {
         let iter = iters.iter_mut().map(|it| Wrap(it.next().unwrap()));
-        let arg = (RArray::from_iter(iter),);
+        let arg = (ruby.ary_from_iter(iter),);
         let out: Value = lambda.funcall("call", arg)?;
 
         if out.is_nil() {
             null_count += 1;
             continue;
-        } else if out.is_kind_of(class::true_class()) || out.is_kind_of(class::false_class()) {
+        } else if out.is_kind_of(ruby.class_true_class())
+            || out.is_kind_of(ruby.class_false_class())
+        {
             let first_value = bool::try_convert(out).ok();
             return Ok((
-                Obj::wrap(RbSeries::new(
+                ruby.obj_wrap(RbSeries::new(
                     apply_lambda_with_bool_out_type(df, lambda, null_count, first_value)
                         .into_series(),
                 ))
                 .as_value(),
                 false,
             ));
-        } else if out.is_kind_of(class::float()) {
+        } else if out.is_kind_of(ruby.class_float()) {
             let first_value = f64::try_convert(out).ok();
 
             return Ok((
-                Obj::wrap(RbSeries::new(
+                ruby.obj_wrap(RbSeries::new(
                     apply_lambda_with_primitive_out_type::<Float64Type>(
                         df,
                         lambda,
@@ -62,10 +65,10 @@ pub fn apply_lambda_unknown<'a>(
                 .as_value(),
                 false,
             ));
-        } else if out.is_kind_of(class::integer()) {
+        } else if out.is_kind_of(ruby.class_integer()) {
             let first_value = i64::try_convert(out).ok();
             return Ok((
-                Obj::wrap(RbSeries::new(
+                ruby.obj_wrap(RbSeries::new(
                     apply_lambda_with_primitive_out_type::<Int64Type>(
                         df,
                         lambda,
@@ -77,7 +80,7 @@ pub fn apply_lambda_unknown<'a>(
                 .as_value(),
                 false,
             ));
-        // } else if out.is_kind_of(class::string()) {
+        // } else if out.is_kind_of(ruby.class_string()) {
         //     let first_value = String::try_convert(out).ok();
         //     return Ok((
         //         RbSeries::new(
@@ -92,7 +95,7 @@ pub fn apply_lambda_unknown<'a>(
             let series = rb_rbseries.series.borrow();
             let dt = series.dtype();
             return Ok((
-                Obj::wrap(RbSeries::new(
+                ruby.obj_wrap(RbSeries::new(
                     apply_lambda_with_list_out_type(df, lambda, null_count, Some(&series), dt)?
                         .into_series(),
                 ))
@@ -102,7 +105,7 @@ pub fn apply_lambda_unknown<'a>(
         } else if Wrap::<Row<'a>>::try_convert(out).is_ok() {
             let first_value = Wrap::<Row<'a>>::try_convert(out).unwrap().0;
             return Ok((
-                Obj::wrap(RbDataFrame::from(
+                ruby.obj_wrap(RbDataFrame::from(
                     apply_lambda_with_rows_output(
                         df,
                         lambda,
@@ -115,7 +118,7 @@ pub fn apply_lambda_unknown<'a>(
                 .as_value(),
                 true,
             ));
-        } else if out.is_kind_of(class::array()) {
+        } else if out.is_kind_of(ruby.class_array()) {
             return Err(RbPolarsErr::Other(
                 "A list output type is invalid. Do you mean to create polars List Series?\
 Then return a Series object."
@@ -141,7 +144,7 @@ where
     let mut iters = get_iters_skip(df, init_null_count + skip);
     ((init_null_count + skip)..df.height()).map(move |_| {
         let iter = iters.iter_mut().map(|it| Wrap(it.next().unwrap()));
-        let tpl = (RArray::from_iter(iter),);
+        let tpl = (Ruby::get_with(lambda).ary_from_iter(iter),);
         match lambda.funcall::<_, _, Value>("call", tpl) {
             Ok(val) => T::try_convert(val).ok(),
             Err(e) => panic!("ruby function failed {e}"),
@@ -237,7 +240,7 @@ pub fn apply_lambda_with_list_out_type(
         let mut iters = get_iters_skip(df, init_null_count + skip);
         let iter = ((init_null_count + skip)..df.height()).map(|_| {
             let iter = iters.iter_mut().map(|it| Wrap(it.next().unwrap()));
-            let tpl = (RArray::from_iter(iter),);
+            let tpl = (Ruby::get_with(lambda).ary_from_iter(iter),);
             match lambda.funcall::<_, _, Value>("call", tpl) {
                 Ok(val) => match val.funcall::<_, _, Value>("_s", ()) {
                     Ok(val) => Obj::<RbSeries>::try_convert(val)
@@ -281,7 +284,7 @@ pub fn apply_lambda_with_rows_output<'a>(
     let mut iters = get_iters_skip(df, init_null_count + skip);
     let mut row_iter = ((init_null_count + skip)..df.height()).map(|_| {
         let iter = iters.iter_mut().map(|it| Wrap(it.next().unwrap()));
-        let tpl = (RArray::from_iter(iter),);
+        let tpl = (Ruby::get_with(lambda).ary_from_iter(iter),);
         match lambda.funcall::<_, _, Value>("call", tpl) {
             Ok(val) => {
                 match RArray::try_convert(val).ok() {

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

@@ -1,17 +1,18 @@
-use magnus::{RArray, Value, prelude::*};
+use magnus::{Ruby, Value, prelude::*};
 use polars::prelude::*;
 
 use crate::rb_modules::*;
 use crate::{RbExpr, RbSeries, Wrap};
 
 fn to_series(v: Value, name: &str) -> PolarsResult<Series> {
+    let ruby = Ruby::get_with(v);
     let rb_rbseries = match v.funcall("_s", ()) {
         Ok(s) => s,
         // the lambda did not return a series, we try to create a new Ruby Series
         _ => {
-            let data = RArray::new();
+            let data = ruby.ary_new();
             data.push(v).unwrap();
-            let res = series().funcall::<_, _, Value>("new", (name.to_string(), data));
+            let res = pl_series().funcall::<_, _, Value>("new", (name.to_string(), data));
 
             match res {
                 Ok(ruby_s) => ruby_s.funcall::<_, _, &RbSeries>("_s", ()).unwrap(),
@@ -34,8 +35,8 @@ pub fn binary_lambda(lambda: Value, a: Series, b: Series) -> PolarsResult<Option
     let rbseries_b = RbSeries::new(b);
 
     // Wrap this RbSeries object in the Ruby side Series wrapper
-    let ruby_series_wrapper_a: Value = utils().funcall("wrap_s", (rbseries_a,)).unwrap();
-    let ruby_series_wrapper_b: Value = utils().funcall("wrap_s", (rbseries_b,)).unwrap();
+    let ruby_series_wrapper_a: Value = pl_utils().funcall("wrap_s", (rbseries_a,)).unwrap();
+    let ruby_series_wrapper_b: Value = pl_utils().funcall("wrap_s", (rbseries_b,)).unwrap();
 
     // call the lambda and get a Ruby side Series wrapper
     let result_series_wrapper: Value =

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

@@ -1,4 +1,4 @@
-use magnus::{IntoValue, TryConvert, Value, class, prelude::*, typed_data::Obj};
+use magnus::{IntoValue, Ruby, TryConvert, Value, prelude::*, typed_data::Obj};
 use polars::prelude::*;
 
 use super::*;
@@ -12,12 +12,13 @@ fn infer_and_finish<'a, A: ApplyLambda<'a>>(
     out: Value,
     null_count: usize,
 ) -> RbResult<RbSeries> {
-    if out.is_kind_of(class::true_class()) || out.is_kind_of(class::false_class()) {
+    let ruby = Ruby::get_with(lambda);
+    if out.is_kind_of(ruby.class_true_class()) || out.is_kind_of(ruby.class_false_class()) {
         let first_value = bool::try_convert(out).unwrap();
         applyer
             .apply_lambda_with_bool_out_type(lambda, null_count, Some(first_value))
             .map(|ca| ca.into_series().into())
-    } else if out.is_kind_of(class::float()) {
+    } else if out.is_kind_of(ruby.class_float()) {
         let first_value = f64::try_convert(out).unwrap();
         applyer
             .apply_lambda_with_primitive_out_type::<Float64Type>(
@@ -26,7 +27,7 @@ fn infer_and_finish<'a, A: ApplyLambda<'a>>(
                 Some(first_value),
             )
             .map(|ca| ca.into_series().into())
-    } else if out.is_kind_of(class::string()) {
+    } else if out.is_kind_of(ruby.class_string()) {
         let first_value = String::try_convert(out).unwrap();
         applyer
             .apply_lambda_with_utf8_out_type(lambda, null_count, Some(first_value.as_str()))
@@ -38,9 +39,9 @@ fn infer_and_finish<'a, A: ApplyLambda<'a>>(
         applyer
             .apply_lambda_with_list_out_type(lambda, null_count, &series, dt)
             .map(|ca| ca.into_series().into())
-    } else if out.is_kind_of(class::array()) {
+    } else if out.is_kind_of(ruby.class_array()) {
         todo!()
-    } else if out.is_kind_of(class::hash()) {
+    } else if out.is_kind_of(ruby.class_hash()) {
         let first = Wrap::<AnyValue<'_>>::try_convert(out)?;
         applyer.apply_into_struct(lambda, null_count, first.0)
     }
@@ -999,7 +1000,7 @@ impl<'a> ApplyLambda<'a> for StringChunked {
     }
 }
 
-fn iter_struct(ca: &StructChunked) -> impl Iterator<Item = AnyValue> {
+fn iter_struct(ca: &StructChunked) -> impl Iterator<Item = AnyValue<'_>> {
     (0..ca.len()).map(|i| unsafe { ca.get_any_value_unchecked(i) })
 }
 

data/ext/polars/src/on_startup.rs

@@ -2,15 +2,23 @@ use std::any::Any;
 use std::sync::Arc;
 use std::sync::OnceLock;
 
-use magnus::IntoValue;
+use magnus::{IntoValue, Ruby, Value, prelude::*};
 use polars::prelude::*;
 use polars_core::chunked_array::object::builder::ObjectChunkedBuilder;
 use polars_core::chunked_array::object::registry;
 use polars_core::chunked_array::object::registry::AnonymousObjectBuilder;
 use polars_core::prelude::AnyValue;
+use polars_error::PolarsWarning;
 
 use crate::Wrap;
 use crate::prelude::ObjectValue;
+use crate::rb_modules::pl_utils;
+
+fn warning_function(msg: &str, _warning: PolarsWarning) {
+    if let Err(e) = pl_utils().funcall::<_, _, Value>("_polars_warn", (msg.to_string(),)) {
+        eprintln!("{e}")
+    }
+}
 
 static POLARS_REGISTRY_INIT_LOCK: OnceLock<()> = OnceLock::new();
 
@@ -23,12 +31,12 @@ pub(crate) fn register_startup_deps() {
 
         let object_converter = Arc::new(|av: AnyValue| {
             let object = ObjectValue {
-                inner: Wrap(av).into_value().into(),
+                inner: Wrap(av).into_value_with(&Ruby::get().unwrap()).into(),
             };
             Box::new(object) as Box<dyn Any>
         });
         let rbobject_converter = Arc::new(|av: AnyValue| {
-            let object = Wrap(av).into_value();
+            let object = Wrap(av).into_value_with(&Ruby::get().unwrap());
             Box::new(object) as Box<dyn Any>
         });
 
@@ -40,8 +48,7 @@ pub(crate) fn register_startup_deps() {
             rbobject_converter,
             physical_dtype,
         );
-        // TODO
         // Register warning function for `polars_warn!`.
-        // polars_error::set_warning_function(warning_function);
+        polars_error::set_warning_function(warning_function);
     });
 }

data/ext/polars/src/rb_modules.rs

@@ -9,13 +9,13 @@ pub(crate) fn polars() -> RModule {
 static SERIES: Lazy<RClass> =
     Lazy::new(|ruby| ruby.get_inner(&POLARS).const_get("Series").unwrap());
 
-pub(crate) fn series() -> RClass {
+pub(crate) fn pl_series() -> RClass {
     Ruby::get().unwrap().get_inner(&SERIES)
 }
 
 static UTILS: Lazy<RModule> = Lazy::new(|ruby| ruby.get_inner(&POLARS).const_get("Utils").unwrap());
 
-pub(crate) fn utils() -> RModule {
+pub(crate) fn pl_utils() -> RModule {
     Ruby::get().unwrap().get_inner(&UTILS)
 }
 

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

@@ -1,7 +1,12 @@
 use crate::error::RbPolarsErr;
 use crate::prelude::*;
 use crate::{RbResult, RbSeries};
-use magnus::{IntoValue, Value};
+use magnus::{IntoValue, Ruby, Value};
+
+fn scalar_to_rb(scalar: RbResult<Scalar>) -> RbResult<Value> {
+    let ruby = Ruby::get().unwrap();
+    Ok(Wrap(scalar?.as_any_value()).into_value_with(&ruby))
+}
 
 impl RbSeries {
     pub fn any(&self, ignore_nulls: bool) -> RbResult<Option<bool>> {
@@ -32,40 +37,44 @@ impl RbSeries {
         self.series.borrow().arg_min()
     }
 
-    pub fn max(&self) -> RbResult<Value> {
+    pub fn max(ruby: &Ruby, rb_self: &Self) -> RbResult<Value> {
         Ok(Wrap(
-            self.series
+            rb_self
+                .series
                 .borrow()
                 .max_reduce()
                 .map_err(RbPolarsErr::from)?
                 .as_any_value(),
         )
-        .into_value())
+        .into_value_with(ruby))
     }
 
-    pub fn mean(&self) -> RbResult<Value> {
-        match self.series.borrow().dtype() {
+    pub fn mean(ruby: &Ruby, rb_self: &Self) -> RbResult<Value> {
+        match rb_self.series.borrow().dtype() {
             DataType::Boolean => Ok(Wrap(
-                self.series
+                rb_self
+                    .series
                     .borrow()
                     .cast(&DataType::UInt8)
                     .unwrap()
                     .mean_reduce()
                     .as_any_value(),
             )
-            .into_value()),
+            .into_value_with(ruby)),
             // For non-numeric output types we require mean_reduce.
-            dt if dt.is_temporal() => {
-                Ok(Wrap(self.series.borrow().mean_reduce().as_any_value()).into_value())
-            }
-            _ => Ok(self.series.borrow().mean().into_value()),
+            dt if dt.is_temporal() => Ok(Wrap(
+                rb_self.series.borrow().mean_reduce().as_any_value(),
+            )
+            .into_value_with(ruby)),
+            _ => Ok(rb_self.series.borrow().mean().into_value_with(ruby)),
         }
     }
 
-    pub fn median(&self) -> RbResult<Value> {
-        match self.series.borrow().dtype() {
+    pub fn median(ruby: &Ruby, rb_self: &Self) -> RbResult<Value> {
+        match rb_self.series.borrow().dtype() {
             DataType::Boolean => Ok(Wrap(
-                self.series
+                rb_self
+                    .series
                     .borrow()
                     .cast(&DataType::UInt8)
                     .unwrap()
@@ -73,49 +82,97 @@ impl RbSeries {
                     .map_err(RbPolarsErr::from)?
                     .as_any_value(),
             )
-            .into_value()),
+            .into_value_with(ruby)),
             // For non-numeric output types we require median_reduce.
             dt if dt.is_temporal() => Ok(Wrap(
-                self.series
+                rb_self
+                    .series
                     .borrow()
                     .median_reduce()
                     .map_err(RbPolarsErr::from)?
                     .as_any_value(),
             )
-            .into_value()),
-            _ => Ok(self.series.borrow().median().into_value()),
+            .into_value_with(ruby)),
+            _ => Ok(rb_self.series.borrow().median().into_value_with(ruby)),
         }
     }
 
-    pub fn min(&self) -> RbResult<Value> {
+    pub fn min(ruby: &Ruby, rb_self: &Self) -> RbResult<Value> {
         Ok(Wrap(
-            self.series
+            rb_self
+                .series
                 .borrow()
                 .min_reduce()
                 .map_err(RbPolarsErr::from)?
                 .as_any_value(),
         )
-        .into_value())
+        .into_value_with(ruby))
     }
 
-    pub fn quantile(&self, quantile: f64, interpolation: Wrap<QuantileMethod>) -> RbResult<Value> {
-        let bind = self
+    pub fn quantile(
+        ruby: &Ruby,
+        rb_self: &Self,
+        quantile: f64,
+        interpolation: Wrap<QuantileMethod>,
+    ) -> RbResult<Value> {
+        let bind = rb_self
             .series
             .borrow()
             .quantile_reduce(quantile, interpolation.0);
         let sc = bind.map_err(RbPolarsErr::from)?;
 
-        Ok(Wrap(sc.as_any_value()).into_value())
+        Ok(Wrap(sc.as_any_value()).into_value_with(ruby))
     }
 
-    pub fn sum(&self) -> RbResult<Value> {
+    pub fn sum(ruby: &Ruby, rb_self: &Self) -> RbResult<Value> {
         Ok(Wrap(
-            self.series
+            rb_self
+                .series
                 .borrow()
                 .sum_reduce()
                 .map_err(RbPolarsErr::from)?
                 .as_any_value(),
         )
-        .into_value())
+        .into_value_with(ruby))
+    }
+
+    pub fn first(&self) -> RbResult<Value> {
+        scalar_to_rb(Ok(self.series.borrow().first()))
+    }
+
+    pub fn last(&self) -> RbResult<Value> {
+        scalar_to_rb(Ok(self.series.borrow().last()))
+    }
+
+    pub fn approx_n_unique(&self) -> RbResult<IdxSize> {
+        Ok(self
+            .series
+            .borrow()
+            .approx_n_unique()
+            .map_err(RbPolarsErr::from)?)
+    }
+
+    pub fn bitwise_and(&self) -> RbResult<Value> {
+        scalar_to_rb(Ok(self
+            .series
+            .borrow()
+            .and_reduce()
+            .map_err(RbPolarsErr::from)?))
+    }
+
+    pub fn bitwise_or(&self) -> RbResult<Value> {
+        scalar_to_rb(Ok(self
+            .series
+            .borrow()
+            .or_reduce()
+            .map_err(RbPolarsErr::from)?))
+    }
+
+    pub fn bitwise_xor(&self) -> RbResult<Value> {
+        scalar_to_rb(Ok(self
+            .series
+            .borrow()
+            .xor_reduce()
+            .map_err(RbPolarsErr::from)?))
     }
 }

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

@@ -79,6 +79,7 @@ init_method_opt!(new_opt_i8, Int8Type, i8);
 init_method_opt!(new_opt_i16, Int16Type, i16);
 init_method_opt!(new_opt_i32, Int32Type, i32);
 init_method_opt!(new_opt_i64, Int64Type, i64);
+init_method_opt!(new_opt_i128, Int128Type, i128);
 init_method_opt!(new_opt_f32, Float32Type, f32);
 init_method_opt!(new_opt_f64, Float64Type, f64);
 

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

@@ -1,4 +1,4 @@
-use magnus::{IntoValue, RArray, Value, value::qnil};
+use magnus::{IntoValue, Ruby, Value, value::ReprValue};
 use polars_core::prelude::*;
 
 use crate::RbSeries;
@@ -11,42 +11,43 @@ impl RbSeries {
         let series = &self.series.borrow();
 
         fn to_a_recursive(series: &Series) -> Value {
+            let ruby = Ruby::get().unwrap();
             let rblist = match series.dtype() {
-                DataType::Boolean => RArray::from_iter(series.bool().unwrap()).into_value(),
-                DataType::UInt8 => RArray::from_iter(series.u8().unwrap()).into_value(),
-                DataType::UInt16 => RArray::from_iter(series.u16().unwrap()).into_value(),
-                DataType::UInt32 => RArray::from_iter(series.u32().unwrap()).into_value(),
-                DataType::UInt64 => RArray::from_iter(series.u64().unwrap()).into_value(),
-                DataType::Int8 => RArray::from_iter(series.i8().unwrap()).into_value(),
-                DataType::Int16 => RArray::from_iter(series.i16().unwrap()).into_value(),
-                DataType::Int32 => RArray::from_iter(series.i32().unwrap()).into_value(),
-                DataType::Int64 => RArray::from_iter(series.i64().unwrap()).into_value(),
-                DataType::Int128 => todo!(),
-                DataType::Float32 => RArray::from_iter(series.f32().unwrap()).into_value(),
-                DataType::Float64 => RArray::from_iter(series.f64().unwrap()).into_value(),
+                DataType::Boolean => ruby.ary_from_iter(series.bool().unwrap()).as_value(),
+                DataType::UInt8 => ruby.ary_from_iter(series.u8().unwrap()).as_value(),
+                DataType::UInt16 => ruby.ary_from_iter(series.u16().unwrap()).as_value(),
+                DataType::UInt32 => ruby.ary_from_iter(series.u32().unwrap()).as_value(),
+                DataType::UInt64 => ruby.ary_from_iter(series.u64().unwrap()).as_value(),
+                DataType::Int8 => ruby.ary_from_iter(series.i8().unwrap()).as_value(),
+                DataType::Int16 => ruby.ary_from_iter(series.i16().unwrap()).as_value(),
+                DataType::Int32 => ruby.ary_from_iter(series.i32().unwrap()).as_value(),
+                DataType::Int64 => ruby.ary_from_iter(series.i64().unwrap()).as_value(),
+                DataType::Int128 => ruby.ary_from_iter(series.i128().unwrap()).as_value(),
+                DataType::Float32 => ruby.ary_from_iter(series.f32().unwrap()).as_value(),
+                DataType::Float64 => ruby.ary_from_iter(series.f64().unwrap()).as_value(),
                 DataType::Categorical(_, _) | DataType::Enum(_, _) => {
                     with_match_categorical_physical_type!(series.dtype().cat_physical().unwrap(), |$C| {
-                        RArray::from_iter(series.cat::<$C>().unwrap().iter_str()).into_value()
+                        ruby.ary_from_iter(series.cat::<$C>().unwrap().iter_str()).as_value()
                     })
                 }
                 DataType::Object(_) => {
-                    let v = RArray::with_capacity(series.len());
+                    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(qnil()).unwrap(),
+                            None => v.push(ruby.qnil()).unwrap(),
                         };
                     }
-                    v.into_value()
+                    v.as_value()
                 }
                 DataType::List(_) => {
-                    let v = RArray::new();
+                    let v = ruby.ary_new();
                     let ca = series.list().unwrap();
                     for opt_s in ca.amortized_iter() {
                         match opt_s {
                             None => {
-                                v.push(qnil()).unwrap();
+                                v.push(ruby.qnil()).unwrap();
                             }
                             Some(s) => {
                                 let rblst = to_a_recursive(s.as_ref());
@@ -54,15 +55,15 @@ impl RbSeries {
                             }
                         }
                     }
-                    v.into_value()
+                    v.as_value()
                 }
                 DataType::Array(_, _) => {
-                    let v = RArray::new();
+                    let v = ruby.ary_new();
                     let ca = series.array().unwrap();
                     for opt_s in ca.amortized_iter() {
                         match opt_s {
                             None => {
-                                v.push(qnil()).unwrap();
+                                v.push(ruby.qnil()).unwrap();
                             }
                             Some(s) => {
                                 let rblst = to_a_recursive(s.as_ref());
@@ -70,39 +71,39 @@ impl RbSeries {
                             }
                         }
                     }
-                    v.into_value()
+                    v.as_value()
                 }
                 DataType::Date => {
                     let ca = series.date().unwrap();
-                    return Wrap(ca).into_value();
+                    return Wrap(ca).into_value_with(&ruby);
                 }
                 DataType::Time => {
                     let ca = series.time().unwrap();
-                    return Wrap(ca).into_value();
+                    return Wrap(ca).into_value_with(&ruby);
                 }
                 DataType::Datetime(_, _) => {
                     let ca = series.datetime().unwrap();
-                    return Wrap(ca).into_value();
+                    return Wrap(ca).into_value_with(&ruby);
                 }
                 DataType::Decimal(_, _) => {
                     let ca = series.decimal().unwrap();
-                    return Wrap(ca).into_value();
+                    return Wrap(ca).into_value_with(&ruby);
                 }
                 DataType::String => {
                     let ca = series.str().unwrap();
-                    return Wrap(ca).into_value();
+                    return Wrap(ca).into_value_with(&ruby);
                 }
                 DataType::Struct(_) => {
                     let ca = series.struct_().unwrap();
-                    return Wrap(ca).into_value();
+                    return Wrap(ca).into_value_with(&ruby);
                 }
                 DataType::Duration(_) => {
                     let ca = series.duration().unwrap();
-                    return Wrap(ca).into_value();
+                    return Wrap(ca).into_value_with(&ruby);
                 }
                 DataType::Binary => {
                     let ca = series.binary().unwrap();
-                    return Wrap(ca).into_value();
+                    return Wrap(ca).into_value_with(&ruby);
                 }
                 DataType::Null => {
                     let null: Option<u8> = None;
@@ -125,7 +126,10 @@ impl RbSeries {
                     }
                     impl ExactSizeIterator for NullIter {}
 
-                    RArray::from_iter(NullIter { iter, n }).into_value()
+                    Ruby::get()
+                        .unwrap()
+                        .ary_from_iter(NullIter { iter, n })
+                        .as_value()
                 }
                 DataType::Unknown(_) => {
                     panic!("to_a not implemented for unknown")
@@ -134,7 +138,7 @@ impl RbSeries {
                     unreachable!()
                 }
             };
-            rblist.into_value()
+            rblist.as_value()
         }
 
         to_a_recursive(series)