polars-df 0.15.0 → 0.26.0

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

@@ -1,121 +1,146 @@
-use crate::error::RbPolarsErr;
+use DataType::*;
+use magnus::{IntoValue, Ruby, Value};
+use polars::prelude::*;
+
 use crate::prelude::*;
+use crate::ruby::utils::TryIntoValue;
+use crate::utils::EnterPolarsExt;
 use crate::{RbResult, RbSeries};
-use magnus::{IntoValue, Value};
+
+fn scalar_to_rb(scalar: RbResult<Scalar>, rb: &Ruby) -> RbResult<Value> {
+    Wrap(scalar?.as_any_value()).try_into_value_with(rb)
+}
 
 impl RbSeries {
-    pub fn any(&self, ignore_nulls: bool) -> RbResult<Option<bool>> {
-        let binding = self.series.borrow();
-        let s = binding.bool().map_err(RbPolarsErr::from)?;
-        Ok(if ignore_nulls {
-            Some(s.any())
-        } else {
-            s.any_kleene()
+    pub fn any(rb: &Ruby, self_: &Self, ignore_nulls: bool) -> RbResult<Option<bool>> {
+        rb.enter_polars(|| {
+            let s = self_.series.read();
+            let s = s.bool()?;
+            PolarsResult::Ok(if ignore_nulls {
+                Some(s.any())
+            } else {
+                s.any_kleene()
+            })
         })
     }
 
-    pub fn all(&self, ignore_nulls: bool) -> RbResult<Option<bool>> {
-        let binding = self.series.borrow();
-        let s = binding.bool().map_err(RbPolarsErr::from)?;
-        Ok(if ignore_nulls {
-            Some(s.all())
-        } else {
-            s.all_kleene()
+    pub fn all(rb: &Ruby, self_: &Self, ignore_nulls: bool) -> RbResult<Option<bool>> {
+        rb.enter_polars(|| {
+            let s = self_.series.read();
+            let s = s.bool()?;
+            PolarsResult::Ok(if ignore_nulls {
+                Some(s.all())
+            } else {
+                s.all_kleene()
+            })
         })
     }
 
-    pub fn arg_max(&self) -> Option<usize> {
-        self.series.borrow().arg_max()
+    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_min(&self) -> Option<usize> {
-        self.series.borrow().arg_min()
+    pub fn arg_max(rb: &Ruby, self_: &Self) -> RbResult<Option<usize>> {
+        rb.enter_polars_ok(|| self_.series.read().arg_max())
     }
 
-    pub fn max(&self) -> RbResult<Value> {
-        Ok(Wrap(
-            self.series
-                .borrow()
-                .max_reduce()
-                .map_err(RbPolarsErr::from)?
-                .as_any_value(),
-        )
-        .into_value())
-    }
-
-    pub fn mean(&self) -> RbResult<Value> {
-        match self.series.borrow().dtype() {
-            DataType::Boolean => Ok(Wrap(
-                self.series
-                    .borrow()
-                    .cast(&DataType::UInt8)
-                    .unwrap()
-                    .mean_reduce()
-                    .as_any_value(),
-            )
-            .into_value()),
+    pub fn arg_min(rb: &Ruby, self_: &Self) -> RbResult<Option<usize>> {
+        rb.enter_polars_ok(|| self_.series.read().arg_min())
+    }
+
+    pub fn min(rb: &Ruby, self_: &Self) -> RbResult<Value> {
+        scalar_to_rb(rb.enter_polars(|| self_.series.read().min_reduce()), rb)
+    }
+
+    pub fn max(rb: &Ruby, self_: &Self) -> RbResult<Value> {
+        scalar_to_rb(rb.enter_polars(|| self_.series.read().max_reduce()), rb)
+    }
+
+    pub fn mean(rb: &Ruby, self_: &Self) -> RbResult<Value> {
+        let s = self_.series.read();
+        match s.dtype() {
+            Boolean => scalar_to_rb(
+                rb.enter_polars(|| s.cast(&DataType::UInt8).unwrap().mean_reduce()),
+                rb,
+            ),
             // 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() => scalar_to_rb(rb.enter_polars(|| s.mean_reduce()), rb),
+            _ => Ok(s.mean().into_value_with(rb)),
         }
     }
 
-    pub fn median(&self) -> RbResult<Value> {
-        match self.series.borrow().dtype() {
-            DataType::Boolean => Ok(Wrap(
-                self.series
-                    .borrow()
-                    .cast(&DataType::UInt8)
-                    .unwrap()
-                    .median_reduce()
-                    .map_err(RbPolarsErr::from)?
-                    .as_any_value(),
-            )
-            .into_value()),
+    pub fn median(rb: &Ruby, self_: &Self) -> RbResult<Value> {
+        let s = self_.series.read();
+        match s.dtype() {
+            Boolean => scalar_to_rb(
+                rb.enter_polars(|| s.cast(&DataType::UInt8).unwrap().median_reduce()),
+                rb,
+            ),
             // For non-numeric output types we require median_reduce.
-            dt if dt.is_temporal() => Ok(Wrap(
-                self.series
-                    .borrow()
-                    .median_reduce()
-                    .map_err(RbPolarsErr::from)?
-                    .as_any_value(),
-            )
-            .into_value()),
-            _ => Ok(self.series.borrow().median().into_value()),
+            dt if dt.is_temporal() => scalar_to_rb(rb.enter_polars(|| s.median_reduce()), rb),
+            _ => Ok(s.median().into_value_with(rb)),
         }
     }
 
-    pub fn min(&self) -> RbResult<Value> {
-        Ok(Wrap(
-            self.series
-                .borrow()
-                .min_reduce()
-                .map_err(RbPolarsErr::from)?
-                .as_any_value(),
+    pub fn quantile(
+        rb: &Ruby,
+        self_: &Self,
+        quantile: f64,
+        interpolation: Wrap<QuantileMethod>,
+    ) -> RbResult<Value> {
+        scalar_to_rb(
+            rb.enter_polars(|| {
+                self_
+                    .series
+                    .read()
+                    .quantile_reduce(quantile, interpolation.0)
+            }),
+            rb,
         )
-        .into_value())
     }
 
-    pub fn quantile(&self, quantile: f64, interpolation: Wrap<QuantileMethod>) -> RbResult<Value> {
-        let bind = self
-            .series
-            .borrow()
-            .quantile_reduce(quantile, interpolation.0);
-        let sc = bind.map_err(RbPolarsErr::from)?;
+    pub fn sum(rb: &Ruby, self_: &Self) -> RbResult<Value> {
+        scalar_to_rb(rb.enter_polars(|| self_.series.read().sum_reduce()), rb)
+    }
 
-        Ok(Wrap(sc.as_any_value()).into_value())
+    pub fn first(rb: &Ruby, self_: &Self, ignore_nulls: bool) -> RbResult<Value> {
+        let result = if ignore_nulls {
+            rb.enter_polars_ok(|| self_.series.read().first_non_null())
+        } else {
+            rb.enter_polars_ok(|| self_.series.read().first())
+        };
+        scalar_to_rb(result, rb)
     }
 
-    pub fn sum(&self) -> RbResult<Value> {
-        Ok(Wrap(
-            self.series
-                .borrow()
-                .sum_reduce()
-                .map_err(RbPolarsErr::from)?
-                .as_any_value(),
-        )
-        .into_value())
+    pub fn last(rb: &Ruby, self_: &Self, ignore_nulls: bool) -> RbResult<Value> {
+        let result = if ignore_nulls {
+            rb.enter_polars_ok(|| self_.series.read().last_non_null())
+        } else {
+            rb.enter_polars_ok(|| self_.series.read().last())
+        };
+        scalar_to_rb(result, rb)
+    }
+
+    pub fn approx_n_unique(rb: &Ruby, self_: &Self) -> RbResult<IdxSize> {
+        rb.enter_polars(|| self_.series.read().approx_n_unique())
+    }
+
+    pub fn bitwise_and(rb: &Ruby, self_: &Self) -> RbResult<Value> {
+        scalar_to_rb(rb.enter_polars(|| self_.series.read().and_reduce()), rb)
+    }
+
+    pub fn bitwise_or(rb: &Ruby, self_: &Self) -> RbResult<Value> {
+        scalar_to_rb(rb.enter_polars(|| self_.series.read().or_reduce()), rb)
+    }
+
+    pub fn bitwise_xor(rb: &Ruby, self_: &Self) -> RbResult<Value> {
+        scalar_to_rb(rb.enter_polars(|| self_.series.read().xor_reduce()), rb)
     }
 }

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

@@ -1,34 +1,28 @@
-use crate::{RbPolarsErr, RbResult, RbSeries};
+use magnus::Ruby;
+
+use super::RbSeries;
+use crate::RbResult;
+use crate::utils::EnterPolarsExt;
 
 impl RbSeries {
-    pub fn add(&self, other: &RbSeries) -> RbResult<Self> {
-        Ok((&*self.series.borrow() + &*other.series.borrow())
-            .map(Into::into)
-            .map_err(RbPolarsErr::from)?)
+    pub fn add(rb: &Ruby, self_: &Self, other: &RbSeries) -> RbResult<Self> {
+        rb.enter_polars_series(|| &*self_.series.read() + &*other.series.read())
     }
 
-    pub fn sub(&self, other: &RbSeries) -> RbResult<Self> {
-        Ok((&*self.series.borrow() - &*other.series.borrow())
-            .map(Into::into)
-            .map_err(RbPolarsErr::from)?)
+    pub fn sub(rb: &Ruby, self_: &Self, other: &RbSeries) -> RbResult<Self> {
+        rb.enter_polars_series(|| &*self_.series.read() - &*other.series.read())
     }
 
-    pub fn mul(&self, other: &RbSeries) -> RbResult<Self> {
-        Ok((&*self.series.borrow() * &*other.series.borrow())
-            .map(Into::into)
-            .map_err(RbPolarsErr::from)?)
+    pub fn mul(rb: &Ruby, self_: &Self, other: &RbSeries) -> RbResult<Self> {
+        rb.enter_polars_series(|| &*self_.series.read() * &*other.series.read())
     }
 
-    pub fn div(&self, other: &RbSeries) -> RbResult<Self> {
-        Ok((&*self.series.borrow() / &*other.series.borrow())
-            .map(Into::into)
-            .map_err(RbPolarsErr::from)?)
+    pub fn div(rb: &Ruby, self_: &Self, other: &RbSeries) -> RbResult<Self> {
+        rb.enter_polars_series(|| &*self_.series.read() / &*other.series.read())
     }
 
-    pub fn rem(&self, other: &RbSeries) -> RbResult<Self> {
-        Ok((&*self.series.borrow() % &*other.series.borrow())
-            .map(Into::into)
-            .map_err(RbPolarsErr::from)?)
+    pub fn rem(rb: &Ruby, self_: &Self, other: &RbSeries) -> RbResult<Self> {
+        rb.enter_polars_series(|| &*self_.series.read() % &*other.series.read())
     }
 }
 
@@ -36,7 +30,7 @@ macro_rules! impl_arithmetic {
     ($name:ident, $type:ty, $operand:tt) => {
         impl RbSeries {
             pub fn $name(&self, other: $type) -> RbResult<Self> {
-                Ok(RbSeries::new(&*self.series.borrow() $operand other))
+                Ok(RbSeries::new(&*self.series.read() $operand other))
             }
         }
     };

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

@@ -1,251 +1,130 @@
-use crate::error::RbPolarsErr;
+use magnus::Ruby;
+
 use crate::prelude::*;
+use crate::utils::EnterPolarsExt;
 use crate::{RbResult, RbSeries};
 
 impl RbSeries {
-    pub fn eq(&self, rhs: &RbSeries) -> RbResult<Self> {
-        let s = self
-            .series
-            .borrow()
-            .equal(&*rhs.series.borrow())
-            .map_err(RbPolarsErr::from)?;
-        Ok(Self::new(s.into_series()))
+    pub fn eq(rb: &Ruby, self_: &Self, rhs: &RbSeries) -> RbResult<Self> {
+        rb.enter_polars_series(|| self_.series.read().equal(&*rhs.series.read()))
     }
 
-    pub fn neq(&self, rhs: &RbSeries) -> RbResult<Self> {
-        let s = self
-            .series
-            .borrow()
-            .not_equal(&*rhs.series.borrow())
-            .map_err(RbPolarsErr::from)?;
-        Ok(Self::new(s.into_series()))
+    pub fn neq(rb: &Ruby, self_: &Self, rhs: &RbSeries) -> RbResult<Self> {
+        rb.enter_polars_series(|| self_.series.read().not_equal(&*rhs.series.read()))
     }
 
-    pub fn gt(&self, rhs: &RbSeries) -> RbResult<Self> {
-        let s = self
-            .series
-            .borrow()
-            .gt(&*rhs.series.borrow())
-            .map_err(RbPolarsErr::from)?;
-        Ok(Self::new(s.into_series()))
+    pub fn gt(rb: &Ruby, self_: &Self, rhs: &RbSeries) -> RbResult<Self> {
+        rb.enter_polars_series(|| self_.series.read().gt(&*rhs.series.read()))
     }
 
-    pub fn gt_eq(&self, rhs: &RbSeries) -> RbResult<Self> {
-        let s = self
-            .series
-            .borrow()
-            .gt_eq(&*rhs.series.borrow())
-            .map_err(RbPolarsErr::from)?;
-        Ok(Self::new(s.into_series()))
+    pub fn gt_eq(rb: &Ruby, self_: &Self, rhs: &RbSeries) -> RbResult<Self> {
+        rb.enter_polars_series(|| self_.series.read().gt_eq(&*rhs.series.read()))
     }
 
-    pub fn lt(&self, rhs: &RbSeries) -> RbResult<Self> {
-        let s = self
-            .series
-            .borrow()
-            .lt(&*rhs.series.borrow())
-            .map_err(RbPolarsErr::from)?;
-        Ok(Self::new(s.into_series()))
+    pub fn lt(rb: &Ruby, self_: &Self, rhs: &RbSeries) -> RbResult<Self> {
+        rb.enter_polars_series(|| self_.series.read().lt(&*rhs.series.read()))
     }
 
-    pub fn lt_eq(&self, rhs: &RbSeries) -> RbResult<Self> {
-        let s = self
-            .series
-            .borrow()
-            .lt_eq(&*rhs.series.borrow())
-            .map_err(RbPolarsErr::from)?;
-        Ok(Self::new(s.into_series()))
+    pub fn lt_eq(rb: &Ruby, self_: &Self, rhs: &RbSeries) -> RbResult<Self> {
+        rb.enter_polars_series(|| self_.series.read().lt_eq(&*rhs.series.read()))
     }
 }
 
-macro_rules! impl_eq_num {
-    ($name:ident, $type:ty) => {
-        impl RbSeries {
-            pub fn $name(&self, rhs: $type) -> RbResult<Self> {
-                let s = self.series.borrow().equal(rhs).map_err(RbPolarsErr::from)?;
-                Ok(RbSeries::new(s.into_series()))
-            }
-        }
-    };
-}
-
-impl_eq_num!(eq_u8, u8);
-impl_eq_num!(eq_u16, u16);
-impl_eq_num!(eq_u32, u32);
-impl_eq_num!(eq_u64, u64);
-impl_eq_num!(eq_i8, i8);
-impl_eq_num!(eq_i16, i16);
-impl_eq_num!(eq_i32, i32);
-impl_eq_num!(eq_i64, i64);
-impl_eq_num!(eq_f32, f32);
-impl_eq_num!(eq_f64, f64);
-
-macro_rules! impl_neq_num {
-    ($name:ident, $type:ty) => {
-        impl RbSeries {
-            pub fn $name(&self, rhs: $type) -> RbResult<Self> {
-                let s = self
-                    .series
-                    .borrow()
-                    .not_equal(rhs)
-                    .map_err(RbPolarsErr::from)?;
-                Ok(RbSeries::new(s.into_series()))
-            }
-        }
-    };
-}
-
-impl_neq_num!(neq_u8, u8);
-impl_neq_num!(neq_u16, u16);
-impl_neq_num!(neq_u32, u32);
-impl_neq_num!(neq_u64, u64);
-impl_neq_num!(neq_i8, i8);
-impl_neq_num!(neq_i16, i16);
-impl_neq_num!(neq_i32, i32);
-impl_neq_num!(neq_i64, i64);
-impl_neq_num!(neq_f32, f32);
-impl_neq_num!(neq_f64, f64);
-
-macro_rules! impl_gt_num {
-    ($name:ident, $type:ty) => {
-        impl RbSeries {
-            pub fn $name(&self, rhs: $type) -> RbResult<Self> {
-                let s = self.series.borrow().gt(rhs).map_err(RbPolarsErr::from)?;
-                Ok(RbSeries::new(s.into_series()))
-            }
-        }
-    };
-}
-
-impl_gt_num!(gt_u8, u8);
-impl_gt_num!(gt_u16, u16);
-impl_gt_num!(gt_u32, u32);
-impl_gt_num!(gt_u64, u64);
-impl_gt_num!(gt_i8, i8);
-impl_gt_num!(gt_i16, i16);
-impl_gt_num!(gt_i32, i32);
-impl_gt_num!(gt_i64, i64);
-impl_gt_num!(gt_f32, f32);
-impl_gt_num!(gt_f64, f64);
-
-macro_rules! impl_gt_eq_num {
-    ($name:ident, $type:ty) => {
+macro_rules! impl_op {
+    ($op:ident, $name:ident, $type:ty) => {
         impl RbSeries {
-            pub fn $name(&self, rhs: $type) -> RbResult<Self> {
-                let s = self.series.borrow().gt_eq(rhs).map_err(RbPolarsErr::from)?;
-                Ok(RbSeries::new(s.into_series()))
+            pub fn $name(rb: &Ruby, self_: &Self, rhs: $type) -> RbResult<Self> {
+                rb.enter_polars_series(|| self_.series.read().$op(rhs))
             }
         }
     };
 }
 
-impl_gt_eq_num!(gt_eq_u8, u8);
-impl_gt_eq_num!(gt_eq_u16, u16);
-impl_gt_eq_num!(gt_eq_u32, u32);
-impl_gt_eq_num!(gt_eq_u64, u64);
-impl_gt_eq_num!(gt_eq_i8, i8);
-impl_gt_eq_num!(gt_eq_i16, i16);
-impl_gt_eq_num!(gt_eq_i32, i32);
-impl_gt_eq_num!(gt_eq_i64, i64);
-impl_gt_eq_num!(gt_eq_f32, f32);
-impl_gt_eq_num!(gt_eq_f64, f64);
-
-macro_rules! impl_lt_num {
-    ($name:ident, $type:ty) => {
+impl_op!(equal, eq_u8, u8);
+impl_op!(equal, eq_u16, u16);
+impl_op!(equal, eq_u32, u32);
+impl_op!(equal, eq_u64, u64);
+impl_op!(equal, eq_i8, i8);
+impl_op!(equal, eq_i16, i16);
+impl_op!(equal, eq_i32, i32);
+impl_op!(equal, eq_i64, i64);
+impl_op!(equal, eq_i128, i128);
+impl_op!(equal, eq_f32, f32);
+impl_op!(equal, eq_f64, f64);
+
+impl_op!(not_equal, neq_u8, u8);
+impl_op!(not_equal, neq_u16, u16);
+impl_op!(not_equal, neq_u32, u32);
+impl_op!(not_equal, neq_u64, u64);
+impl_op!(not_equal, neq_i8, i8);
+impl_op!(not_equal, neq_i16, i16);
+impl_op!(not_equal, neq_i32, i32);
+impl_op!(not_equal, neq_i64, i64);
+impl_op!(not_equal, neq_i128, i128);
+impl_op!(not_equal, neq_f32, f32);
+impl_op!(not_equal, neq_f64, f64);
+
+impl_op!(gt, gt_u8, u8);
+impl_op!(gt, gt_u16, u16);
+impl_op!(gt, gt_u32, u32);
+impl_op!(gt, gt_u64, u64);
+impl_op!(gt, gt_i8, i8);
+impl_op!(gt, gt_i16, i16);
+impl_op!(gt, gt_i32, i32);
+impl_op!(gt, gt_i64, i64);
+impl_op!(gt, gt_i128, i128);
+impl_op!(gt, gt_f32, f32);
+impl_op!(gt, gt_f64, f64);
+
+impl_op!(gt_eq, gt_eq_u8, u8);
+impl_op!(gt_eq, gt_eq_u16, u16);
+impl_op!(gt_eq, gt_eq_u32, u32);
+impl_op!(gt_eq, gt_eq_u64, u64);
+impl_op!(gt_eq, gt_eq_i8, i8);
+impl_op!(gt_eq, gt_eq_i16, i16);
+impl_op!(gt_eq, gt_eq_i32, i32);
+impl_op!(gt_eq, gt_eq_i64, i64);
+impl_op!(gt_eq, gt_eq_i128, i128);
+impl_op!(gt_eq, gt_eq_f32, f32);
+impl_op!(gt_eq, gt_eq_f64, f64);
+
+impl_op!(lt, lt_u8, u8);
+impl_op!(lt, lt_u16, u16);
+impl_op!(lt, lt_u32, u32);
+impl_op!(lt, lt_u64, u64);
+impl_op!(lt, lt_i8, i8);
+impl_op!(lt, lt_i16, i16);
+impl_op!(lt, lt_i32, i32);
+impl_op!(lt, lt_i64, i64);
+impl_op!(lt, lt_i128, i128);
+impl_op!(lt, lt_f32, f32);
+impl_op!(lt, lt_f64, f64);
+
+impl_op!(lt_eq, lt_eq_u8, u8);
+impl_op!(lt_eq, lt_eq_u16, u16);
+impl_op!(lt_eq, lt_eq_u32, u32);
+impl_op!(lt_eq, lt_eq_u64, u64);
+impl_op!(lt_eq, lt_eq_i8, i8);
+impl_op!(lt_eq, lt_eq_i16, i16);
+impl_op!(lt_eq, lt_eq_i32, i32);
+impl_op!(lt_eq, lt_eq_i64, i64);
+impl_op!(lt_eq, lt_eq_i128, i128);
+impl_op!(lt_eq, lt_eq_f32, f32);
+impl_op!(lt_eq, lt_eq_f64, f64);
+
+macro_rules! impl_str {
+    ($name:ident, $method:ident) => {
         impl RbSeries {
-            pub fn $name(&self, rhs: $type) -> RbResult<RbSeries> {
-                let s = self.series.borrow().lt(rhs).map_err(RbPolarsErr::from)?;
-                Ok(RbSeries::new(s.into_series()))
+            pub fn $name(rb: &Ruby, self_: &Self, rhs: String) -> RbResult<Self> {
+                rb.enter_polars_series(|| self_.series.read().$method(rhs.as_str()))
             }
         }
     };
 }
 
-impl_lt_num!(lt_u8, u8);
-impl_lt_num!(lt_u16, u16);
-impl_lt_num!(lt_u32, u32);
-impl_lt_num!(lt_u64, u64);
-impl_lt_num!(lt_i8, i8);
-impl_lt_num!(lt_i16, i16);
-impl_lt_num!(lt_i32, i32);
-impl_lt_num!(lt_i64, i64);
-impl_lt_num!(lt_f32, f32);
-impl_lt_num!(lt_f64, f64);
-
-macro_rules! impl_lt_eq_num {
-    ($name:ident, $type:ty) => {
-        impl RbSeries {
-            pub fn $name(&self, rhs: $type) -> RbResult<Self> {
-                let s = self.series.borrow().lt_eq(rhs).map_err(RbPolarsErr::from)?;
-                Ok(RbSeries::new(s.into_series()))
-            }
-        }
-    };
-}
-
-impl_lt_eq_num!(lt_eq_u8, u8);
-impl_lt_eq_num!(lt_eq_u16, u16);
-impl_lt_eq_num!(lt_eq_u32, u32);
-impl_lt_eq_num!(lt_eq_u64, u64);
-impl_lt_eq_num!(lt_eq_i8, i8);
-impl_lt_eq_num!(lt_eq_i16, i16);
-impl_lt_eq_num!(lt_eq_i32, i32);
-impl_lt_eq_num!(lt_eq_i64, i64);
-impl_lt_eq_num!(lt_eq_f32, f32);
-impl_lt_eq_num!(lt_eq_f64, f64);
-
-impl RbSeries {
-    pub fn eq_str(&self, rhs: String) -> RbResult<Self> {
-        let s = self
-            .series
-            .borrow()
-            .equal(rhs.as_str())
-            .map_err(RbPolarsErr::from)?;
-        Ok(RbSeries::new(s.into_series()))
-    }
-
-    pub fn neq_str(&self, rhs: String) -> RbResult<Self> {
-        let s = self
-            .series
-            .borrow()
-            .not_equal(rhs.as_str())
-            .map_err(RbPolarsErr::from)?;
-        Ok(RbSeries::new(s.into_series()))
-    }
-
-    pub fn gt_str(&self, rhs: String) -> RbResult<Self> {
-        let s = self
-            .series
-            .borrow()
-            .gt(rhs.as_str())
-            .map_err(RbPolarsErr::from)?;
-        Ok(RbSeries::new(s.into_series()))
-    }
-
-    pub fn gt_eq_str(&self, rhs: String) -> RbResult<Self> {
-        let s = self
-            .series
-            .borrow()
-            .gt_eq(rhs.as_str())
-            .map_err(RbPolarsErr::from)?;
-        Ok(RbSeries::new(s.into_series()))
-    }
-
-    pub fn lt_str(&self, rhs: String) -> RbResult<Self> {
-        let s = self
-            .series
-            .borrow()
-            .lt(rhs.as_str())
-            .map_err(RbPolarsErr::from)?;
-        Ok(RbSeries::new(s.into_series()))
-    }
-
-    pub fn lt_eq_str(&self, rhs: String) -> RbResult<Self> {
-        let s = self
-            .series
-            .borrow()
-            .lt_eq(rhs.as_str())
-            .map_err(RbPolarsErr::from)?;
-        Ok(RbSeries::new(s.into_series()))
-    }
-}
+impl_str!(eq_str, equal);
+impl_str!(neq_str, not_equal);
+impl_str!(gt_str, gt);
+impl_str!(gt_eq_str, gt_eq);
+impl_str!(lt_str, lt);
+impl_str!(lt_eq_str, lt_eq);