polars-df 0.1.0

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

@@ -0,0 +1,123 @@
+use magnus::RArray;
+use polars::lazy::frame::{LazyFrame, LazyGroupBy};
+use std::cell::RefCell;
+
+use crate::conversion::wrap_join_type;
+use crate::lazy::utils::rb_exprs_to_exprs;
+use crate::{RbDataFrame, RbExpr, RbPolarsErr, RbResult};
+
+#[magnus::wrap(class = "Polars::RbLazyGroupBy")]
+pub struct RbLazyGroupBy {
+    lgb: RefCell<Option<LazyGroupBy>>,
+}
+
+impl RbLazyGroupBy {
+    pub fn agg(&self, aggs: RArray) -> RbResult<RbLazyFrame> {
+        let lgb = self.lgb.borrow_mut().take().unwrap();
+        let aggs = rb_exprs_to_exprs(aggs)?;
+        Ok(lgb.agg(aggs).into())
+    }
+}
+
+#[magnus::wrap(class = "Polars::RbLazyFrame")]
+#[derive(Clone)]
+pub struct RbLazyFrame {
+    pub ldf: LazyFrame,
+}
+
+impl From<LazyFrame> for RbLazyFrame {
+    fn from(ldf: LazyFrame) -> Self {
+        RbLazyFrame { ldf }
+    }
+}
+
+impl RbLazyFrame {
+    #[allow(clippy::too_many_arguments)]
+    pub fn optimization_toggle(
+        &self,
+        type_coercion: bool,
+        predicate_pushdown: bool,
+        projection_pushdown: bool,
+        simplify_expr: bool,
+        slice_pushdown: bool,
+        _cse: bool,
+        allow_streaming: bool,
+    ) -> RbLazyFrame {
+        let ldf = self.ldf.clone();
+        let ldf = ldf
+            .with_type_coercion(type_coercion)
+            .with_predicate_pushdown(predicate_pushdown)
+            .with_simplify_expr(simplify_expr)
+            .with_slice_pushdown(slice_pushdown)
+            // .with_common_subplan_elimination(cse)
+            .with_streaming(allow_streaming)
+            .with_projection_pushdown(projection_pushdown);
+        ldf.into()
+    }
+
+    pub fn collect(&self) -> RbResult<RbDataFrame> {
+        let ldf = self.ldf.clone();
+        let df = ldf.collect().map_err(RbPolarsErr::from)?;
+        Ok(df.into())
+    }
+
+    pub fn filter(&self, predicate: &RbExpr) -> RbLazyFrame {
+        let ldf = self.ldf.clone();
+        ldf.filter(predicate.inner.clone()).into()
+    }
+
+    pub fn select(&self, exprs: RArray) -> RbResult<RbLazyFrame> {
+        let ldf = self.ldf.clone();
+        let exprs = rb_exprs_to_exprs(exprs)?;
+        Ok(ldf.select(exprs).into())
+    }
+
+    pub fn groupby(&self, by: RArray, maintain_order: bool) -> RbResult<RbLazyGroupBy> {
+        let ldf = self.ldf.clone();
+        let by = rb_exprs_to_exprs(by)?;
+        let lazy_gb = if maintain_order {
+            ldf.groupby_stable(by)
+        } else {
+            ldf.groupby(by)
+        };
+        Ok(RbLazyGroupBy {
+            lgb: RefCell::new(Some(lazy_gb)),
+        })
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub fn join(
+        &self,
+        other: &RbLazyFrame,
+        left_on: RArray,
+        right_on: RArray,
+        allow_parallel: bool,
+        force_parallel: bool,
+        how: String,
+        suffix: String,
+    ) -> RbResult<Self> {
+        let how = wrap_join_type(&how)?;
+
+        let ldf = self.ldf.clone();
+        let other = other.ldf.clone();
+        let left_on = rb_exprs_to_exprs(left_on)?;
+        let right_on = rb_exprs_to_exprs(right_on)?;
+
+        Ok(ldf
+            .join_builder()
+            .with(other)
+            .left_on(left_on)
+            .right_on(right_on)
+            .allow_parallel(allow_parallel)
+            .force_parallel(force_parallel)
+            .how(how)
+            .suffix(suffix)
+            .finish()
+            .into())
+    }
+
+    pub fn with_columns(&self, exprs: RArray) -> RbResult<RbLazyFrame> {
+        let ldf = self.ldf.clone();
+        Ok(ldf.with_columns(rb_exprs_to_exprs(exprs)?).into())
+    }
+}

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

@@ -0,0 +1,298 @@
+use magnus::{RArray, RString, Value};
+use polars::chunked_array::ops::SortOptions;
+use polars::lazy::dsl;
+use polars::lazy::dsl::Operator;
+use polars::prelude::*;
+
+use crate::conversion::parse_fill_null_strategy;
+use crate::lazy::utils::rb_exprs_to_exprs;
+use crate::RbResult;
+
+#[magnus::wrap(class = "Polars::RbExpr")]
+#[derive(Clone)]
+pub struct RbExpr {
+    pub inner: dsl::Expr,
+}
+
+impl From<dsl::Expr> for RbExpr {
+    fn from(inner: dsl::Expr) -> Self {
+        RbExpr { inner }
+    }
+}
+
+impl RbExpr {
+    pub fn mul(&self, rhs: &RbExpr) -> RbResult<Self> {
+        Ok(dsl::binary_expr(self.inner.clone(), Operator::Multiply, rhs.inner.clone()).into())
+    }
+
+    pub fn to_str(&self) -> String {
+        format!("{:?}", self.inner)
+    }
+
+    pub fn eq(&self, other: &RbExpr) -> Self {
+        self.clone().inner.eq(other.inner.clone()).into()
+    }
+
+    pub fn neq(&self, other: &RbExpr) -> Self {
+        self.clone().inner.neq(other.inner.clone()).into()
+    }
+
+    pub fn gt(&self, other: &RbExpr) -> Self {
+        self.clone().inner.gt(other.inner.clone()).into()
+    }
+
+    pub fn gt_eq(&self, other: &RbExpr) -> Self {
+        self.clone().inner.gt_eq(other.inner.clone()).into()
+    }
+
+    pub fn lt_eq(&self, other: &RbExpr) -> Self {
+        self.clone().inner.lt_eq(other.inner.clone()).into()
+    }
+
+    pub fn lt(&self, other: &RbExpr) -> Self {
+        self.clone().inner.lt(other.inner.clone()).into()
+    }
+
+    pub fn alias(&self, name: String) -> Self {
+        self.clone().inner.alias(&name).into()
+    }
+
+    pub fn is_not(&self) -> Self {
+        self.clone().inner.not().into()
+    }
+
+    pub fn is_null(&self) -> Self {
+        self.clone().inner.is_null().into()
+    }
+
+    pub fn is_not_null(&self) -> Self {
+        self.clone().inner.is_not_null().into()
+    }
+
+    pub fn min(&self) -> Self {
+        self.clone().inner.min().into()
+    }
+
+    pub fn max(&self) -> Self {
+        self.clone().inner.max().into()
+    }
+
+    pub fn mean(&self) -> Self {
+        self.clone().inner.mean().into()
+    }
+
+    pub fn median(&self) -> Self {
+        self.clone().inner.median().into()
+    }
+
+    pub fn sum(&self) -> Self {
+        self.clone().inner.sum().into()
+    }
+
+    pub fn n_unique(&self) -> Self {
+        self.clone().inner.n_unique().into()
+    }
+
+    pub fn unique(&self) -> Self {
+        self.clone().inner.unique().into()
+    }
+
+    pub fn unique_stable(&self) -> Self {
+        self.clone().inner.unique_stable().into()
+    }
+
+    pub fn first(&self) -> Self {
+        self.clone().inner.first().into()
+    }
+    pub fn last(&self) -> Self {
+        self.clone().inner.last().into()
+    }
+
+    pub fn list(&self) -> Self {
+        self.clone().inner.list().into()
+    }
+
+    pub fn count(&self) -> Self {
+        self.clone().inner.count().into()
+    }
+
+    pub fn sort_with(&self, descending: bool, nulls_last: bool) -> Self {
+        self.clone()
+            .inner
+            .sort_with(SortOptions {
+                descending,
+                nulls_last,
+            })
+            .into()
+    }
+
+    pub fn sort_by(&self, by: RArray, reverse: Vec<bool>) -> RbResult<Self> {
+        let by = rb_exprs_to_exprs(by)?;
+        Ok(self.clone().inner.sort_by(by, reverse).into())
+    }
+
+    pub fn fill_null(&self, expr: &RbExpr) -> Self {
+        self.clone().inner.fill_null(expr.inner.clone()).into()
+    }
+
+    pub fn fill_null_with_strategy(
+        &self,
+        strategy: String,
+        limit: FillNullLimit,
+    ) -> RbResult<Self> {
+        let strat = parse_fill_null_strategy(&strategy, limit)?;
+        Ok(self
+            .inner
+            .clone()
+            .apply(move |s| s.fill_null(strat), GetOutput::same_type())
+            .with_fmt("fill_null_with_strategy")
+            .into())
+    }
+
+    pub fn fill_nan(&self, expr: &RbExpr) -> Self {
+        self.inner.clone().fill_nan(expr.inner.clone()).into()
+    }
+
+    pub fn drop_nulls(&self) -> Self {
+        self.inner.clone().drop_nulls().into()
+    }
+
+    pub fn drop_nans(&self) -> Self {
+        self.inner.clone().drop_nans().into()
+    }
+
+    pub fn filter(&self, predicate: &RbExpr) -> Self {
+        self.clone().inner.filter(predicate.inner.clone()).into()
+    }
+
+    pub fn reverse(&self) -> Self {
+        self.clone().inner.reverse().into()
+    }
+
+    pub fn std(&self, ddof: u8) -> Self {
+        self.clone().inner.std(ddof).into()
+    }
+
+    pub fn var(&self, ddof: u8) -> Self {
+        self.clone().inner.var(ddof).into()
+    }
+
+    pub fn tail(&self, n: Option<usize>) -> Self {
+        self.clone().inner.tail(n).into()
+    }
+
+    pub fn head(&self, n: Option<usize>) -> Self {
+        self.clone().inner.head(n).into()
+    }
+
+    pub fn over(&self, partition_by: RArray) -> RbResult<Self> {
+        let partition_by = rb_exprs_to_exprs(partition_by)?;
+        Ok(self.clone().inner.over(partition_by).into())
+    }
+
+    pub fn _and(&self, expr: &RbExpr) -> Self {
+        self.clone().inner.and(expr.inner.clone()).into()
+    }
+
+    pub fn _xor(&self, expr: &RbExpr) -> Self {
+        self.clone().inner.xor(expr.inner.clone()).into()
+    }
+
+    pub fn _or(&self, expr: &RbExpr) -> Self {
+        self.clone().inner.or(expr.inner.clone()).into()
+    }
+
+    pub fn product(&self) -> Self {
+        self.clone().inner.product().into()
+    }
+
+    pub fn str_lengths(&self) -> RbExpr {
+        let function = |s: Series| {
+            let ca = s.utf8()?;
+            Ok(ca.str_lengths().into_series())
+        };
+        self.clone()
+            .inner
+            .map(function, GetOutput::from_type(DataType::UInt32))
+            .with_fmt("str.lengths")
+            .into()
+    }
+
+    pub fn str_contains(&self, pat: String, literal: Option<bool>) -> Self {
+        match literal {
+            Some(true) => self.inner.clone().str().contains_literal(pat).into(),
+            _ => self.inner.clone().str().contains(pat).into(),
+        }
+    }
+
+    pub fn prefix(&self, prefix: String) -> RbExpr {
+        self.inner.clone().prefix(&prefix).into()
+    }
+
+    pub fn suffix(&self, suffix: String) -> RbExpr {
+        self.inner.clone().suffix(&suffix).into()
+    }
+
+    pub fn interpolate(&self) -> RbExpr {
+        self.inner.clone().interpolate().into()
+    }
+}
+
+pub fn col(name: String) -> RbExpr {
+    dsl::col(&name).into()
+}
+
+// TODO improve
+pub fn lit(value: Value) -> RbResult<RbExpr> {
+    if value.is_nil() {
+        Ok(dsl::lit(Null {}).into())
+    } else if let Some(v) = RString::from_value(value) {
+        Ok(dsl::lit(v.try_convert::<String>()?).into())
+    } else {
+        Ok(dsl::lit(value.try_convert::<f64>()?).into())
+    }
+}
+
+pub fn arange(low: &RbExpr, high: &RbExpr, step: usize) -> RbExpr {
+    polars::lazy::dsl::arange(low.inner.clone(), high.inner.clone(), step).into()
+}
+
+#[magnus::wrap(class = "Polars::RbWhen")]
+#[derive(Clone)]
+pub struct RbWhen {
+    pub inner: dsl::When,
+}
+
+impl From<dsl::When> for RbWhen {
+    fn from(inner: dsl::When) -> Self {
+        RbWhen { inner }
+    }
+}
+
+#[magnus::wrap(class = "Polars::RbWhenThen")]
+#[derive(Clone)]
+pub struct RbWhenThen {
+    pub inner: dsl::WhenThen,
+}
+
+impl From<dsl::WhenThen> for RbWhenThen {
+    fn from(inner: dsl::WhenThen) -> Self {
+        RbWhenThen { inner }
+    }
+}
+
+impl RbWhen {
+    pub fn then(&self, expr: &RbExpr) -> RbWhenThen {
+        self.inner.clone().then(expr.inner.clone()).into()
+    }
+}
+
+impl RbWhenThen {
+    pub fn overwise(&self, expr: &RbExpr) -> RbExpr {
+        self.inner.clone().otherwise(expr.inner.clone()).into()
+    }
+}
+
+pub fn when(predicate: &RbExpr) -> RbWhen {
+    dsl::when(predicate.inner.clone()).into()
+}

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

@@ -0,0 +1,3 @@
+pub mod dataframe;
+pub mod dsl;
+pub mod utils;

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

@@ -0,0 +1,13 @@
+use magnus::RArray;
+use polars::lazy::dsl::Expr;
+
+use crate::lazy::dsl::RbExpr;
+use crate::RbResult;
+
+pub fn rb_exprs_to_exprs(rb_exprs: RArray) -> RbResult<Vec<Expr>> {
+    let mut exprs = Vec::new();
+    for item in rb_exprs.each() {
+        exprs.push(item?.try_convert::<&RbExpr>()?.inner.clone());
+    }
+    Ok(exprs)
+}

data/ext/polars/src/lib.rs

@@ -0,0 +1,256 @@
+mod conversion;
+mod dataframe;
+mod error;
+mod file;
+mod lazy;
+mod series;
+
+use conversion::get_df;
+use dataframe::RbDataFrame;
+use error::{RbPolarsErr, RbValueError};
+use lazy::dataframe::{RbLazyFrame, RbLazyGroupBy};
+use lazy::dsl::{RbExpr, RbWhen, RbWhenThen};
+use magnus::{
+    define_module, function, memoize, method, prelude::*, Error, RArray, RClass, RModule,
+};
+use polars::error::PolarsResult;
+use polars::frame::DataFrame;
+use polars::functions::{diag_concat_df, hor_concat_df};
+use series::RbSeries;
+
+type RbResult<T> = Result<T, Error>;
+
+fn module() -> RModule {
+    *memoize!(RModule: define_module("Polars").unwrap())
+}
+
+fn series() -> RClass {
+    *memoize!(RClass: module().define_class("Series", Default::default()).unwrap())
+}
+
+#[magnus::init]
+fn init() -> RbResult<()> {
+    let module = module();
+    module.define_singleton_method("_concat_df", function!(concat_df, 1))?;
+    module.define_singleton_method("_diag_concat_df", function!(rb_diag_concat_df, 1))?;
+    module.define_singleton_method("_hor_concat_df", function!(rb_hor_concat_df, 1))?;
+
+    let class = module.define_class("RbDataFrame", Default::default())?;
+    class.define_singleton_method("new", function!(RbDataFrame::init, 1))?;
+    class.define_singleton_method("read_csv", function!(RbDataFrame::read_csv, 2))?;
+    class.define_singleton_method("read_parquet", function!(RbDataFrame::read_parquet, 1))?;
+    class.define_singleton_method("read_hash", function!(RbDataFrame::read_hash, 1))?;
+    class.define_singleton_method("read_json", function!(RbDataFrame::read_json, 1))?;
+    class.define_singleton_method("read_ndjson", function!(RbDataFrame::read_ndjson, 1))?;
+    class.define_method("write_json", method!(RbDataFrame::write_json, 3))?;
+    class.define_method("write_ndjson", method!(RbDataFrame::write_ndjson, 1))?;
+    class.define_method("write_csv", method!(RbDataFrame::write_csv, 10))?;
+    class.define_method("write_parquet", method!(RbDataFrame::write_parquet, 5))?;
+    class.define_method("rechunk", method!(RbDataFrame::rechunk, 0))?;
+    class.define_method("to_s", method!(RbDataFrame::to_s, 0))?;
+    class.define_method("columns", method!(RbDataFrame::columns, 0))?;
+    class.define_method("dtypes", method!(RbDataFrame::dtypes, 0))?;
+    class.define_method("shape", method!(RbDataFrame::shape, 0))?;
+    class.define_method("height", method!(RbDataFrame::height, 0))?;
+    class.define_method("width", method!(RbDataFrame::width, 0))?;
+    class.define_method("select_at_idx", method!(RbDataFrame::select_at_idx, 1))?;
+    class.define_method("column", method!(RbDataFrame::column, 1))?;
+    class.define_method("sort", method!(RbDataFrame::sort, 3))?;
+    class.define_method("head", method!(RbDataFrame::head, 1))?;
+    class.define_method("tail", method!(RbDataFrame::tail, 1))?;
+    class.define_method("frame_equal", method!(RbDataFrame::frame_equal, 2))?;
+    class.define_method("lazy", method!(RbDataFrame::lazy, 0))?;
+    class.define_method("mean", method!(RbDataFrame::mean, 0))?;
+    class.define_method("null_count", method!(RbDataFrame::null_count, 0))?;
+
+    let class = module.define_class("RbExpr", Default::default())?;
+    class.define_method("*", method!(RbExpr::mul, 1))?;
+    class.define_method("to_str", method!(RbExpr::to_str, 0))?;
+    class.define_method("eq", method!(RbExpr::eq, 1))?;
+    class.define_method("neq", method!(RbExpr::neq, 1))?;
+    class.define_method("gt", method!(RbExpr::gt, 1))?;
+    class.define_method("gt_eq", method!(RbExpr::gt_eq, 1))?;
+    class.define_method("lt_eq", method!(RbExpr::lt_eq, 1))?;
+    class.define_method("lt", method!(RbExpr::lt, 1))?;
+    class.define_method("_alias", method!(RbExpr::alias, 1))?;
+    class.define_method("is_not", method!(RbExpr::is_not, 0))?;
+    class.define_method("is_null", method!(RbExpr::is_null, 0))?;
+    class.define_method("is_not_null", method!(RbExpr::is_not_null, 0))?;
+    class.define_method("min", method!(RbExpr::min, 0))?;
+    class.define_method("max", method!(RbExpr::max, 0))?;
+    class.define_method("mean", method!(RbExpr::mean, 0))?;
+    class.define_method("median", method!(RbExpr::median, 0))?;
+    class.define_method("sum", method!(RbExpr::sum, 0))?;
+    class.define_method("n_unique", method!(RbExpr::n_unique, 0))?;
+    class.define_method("unique", method!(RbExpr::unique, 0))?;
+    class.define_method("unique_stable", method!(RbExpr::unique_stable, 0))?;
+    class.define_method("first", method!(RbExpr::first, 0))?;
+    class.define_method("last", method!(RbExpr::last, 0))?;
+    class.define_method("list", method!(RbExpr::list, 0))?;
+    class.define_method("count", method!(RbExpr::count, 0))?;
+    class.define_method("sort_with", method!(RbExpr::sort_with, 2))?;
+    class.define_method("sort_by", method!(RbExpr::sort_by, 2))?;
+    class.define_method("fill_null", method!(RbExpr::fill_null, 1))?;
+    class.define_method(
+        "fill_null_with_strategy",
+        method!(RbExpr::fill_null_with_strategy, 2),
+    )?;
+    class.define_method("fill_nan", method!(RbExpr::fill_nan, 1))?;
+    class.define_method("drop_nulls", method!(RbExpr::drop_nulls, 0))?;
+    class.define_method("drop_nans", method!(RbExpr::drop_nans, 0))?;
+    class.define_method("filter", method!(RbExpr::filter, 1))?;
+    class.define_method("reverse", method!(RbExpr::reverse, 0))?;
+    class.define_method("std", method!(RbExpr::std, 1))?;
+    class.define_method("var", method!(RbExpr::var, 1))?;
+    class.define_method("tail", method!(RbExpr::tail, 1))?;
+    class.define_method("head", method!(RbExpr::head, 1))?;
+    class.define_method("over", method!(RbExpr::over, 1))?;
+    class.define_method("_and", method!(RbExpr::_and, 1))?;
+    class.define_method("_xor", method!(RbExpr::_xor, 1))?;
+    class.define_method("_or", method!(RbExpr::_or, 1))?;
+    class.define_method("product", method!(RbExpr::product, 0))?;
+    class.define_method("str_lengths", method!(RbExpr::str_lengths, 0))?;
+    class.define_method("str_contains", method!(RbExpr::str_contains, 2))?;
+    class.define_method("prefix", method!(RbExpr::prefix, 1))?;
+    class.define_method("suffix", method!(RbExpr::suffix, 1))?;
+    class.define_method("interpolate", method!(RbExpr::interpolate, 0))?;
+
+    // maybe add to different class
+    class.define_singleton_method("col", function!(crate::lazy::dsl::col, 1))?;
+    class.define_singleton_method("lit", function!(crate::lazy::dsl::lit, 1))?;
+    class.define_singleton_method("arange", function!(crate::lazy::dsl::arange, 3))?;
+    class.define_singleton_method("when", function!(crate::lazy::dsl::when, 1))?;
+
+    let class = module.define_class("RbLazyFrame", Default::default())?;
+    class.define_method(
+        "optimization_toggle",
+        method!(RbLazyFrame::optimization_toggle, 7),
+    )?;
+    class.define_method("collect", method!(RbLazyFrame::collect, 0))?;
+    class.define_method("filter", method!(RbLazyFrame::filter, 1))?;
+    class.define_method("select", method!(RbLazyFrame::select, 1))?;
+    class.define_method("groupby", method!(RbLazyFrame::groupby, 2))?;
+    class.define_method("join", method!(RbLazyFrame::join, 7))?;
+    class.define_method("with_columns", method!(RbLazyFrame::with_columns, 1))?;
+
+    let class = module.define_class("RbLazyGroupBy", Default::default())?;
+    class.define_method("agg", method!(RbLazyGroupBy::agg, 1))?;
+
+    let class = module.define_class("RbSeries", Default::default())?;
+    class.define_singleton_method("new_opt_bool", function!(RbSeries::new_opt_bool, 3))?;
+    class.define_singleton_method("new_opt_u8", function!(RbSeries::new_opt_u8, 3))?;
+    class.define_singleton_method("new_opt_u16", function!(RbSeries::new_opt_u16, 3))?;
+    class.define_singleton_method("new_opt_u32", function!(RbSeries::new_opt_u32, 3))?;
+    class.define_singleton_method("new_opt_u64", function!(RbSeries::new_opt_u64, 3))?;
+    class.define_singleton_method("new_opt_i8", function!(RbSeries::new_opt_i8, 3))?;
+    class.define_singleton_method("new_opt_i16", function!(RbSeries::new_opt_i16, 3))?;
+    class.define_singleton_method("new_opt_i32", function!(RbSeries::new_opt_i32, 3))?;
+    class.define_singleton_method("new_opt_i64", function!(RbSeries::new_opt_i64, 3))?;
+    class.define_singleton_method("new_opt_f32", function!(RbSeries::new_opt_f32, 3))?;
+    class.define_singleton_method("new_opt_f64", function!(RbSeries::new_opt_f64, 3))?;
+    class.define_singleton_method("new_str", function!(RbSeries::new_str, 3))?;
+    class.define_method("rechunk", method!(RbSeries::rechunk, 1))?;
+    class.define_method("bitand", method!(RbSeries::bitand, 1))?;
+    class.define_method("bitor", method!(RbSeries::bitor, 1))?;
+    class.define_method("bitxor", method!(RbSeries::bitxor, 1))?;
+    class.define_method("chunk_lengths", method!(RbSeries::chunk_lengths, 0))?;
+    class.define_method("name", method!(RbSeries::name, 0))?;
+    class.define_method("rename", method!(RbSeries::rename, 1))?;
+    class.define_method("dtype", method!(RbSeries::dtype, 0))?;
+    class.define_method("inner_dtype", method!(RbSeries::inner_dtype, 0))?;
+    class.define_method("set_sorted", method!(RbSeries::set_sorted, 1))?;
+    class.define_method("mean", method!(RbSeries::mean, 0))?;
+    class.define_method("max", method!(RbSeries::max, 0))?;
+    class.define_method("min", method!(RbSeries::min, 0))?;
+    class.define_method("sum", method!(RbSeries::sum, 0))?;
+    class.define_method("n_chunks", method!(RbSeries::n_chunks, 0))?;
+    class.define_method("append", method!(RbSeries::append, 1))?;
+    class.define_method("extend", method!(RbSeries::extend, 1))?;
+    class.define_method("new_from_index", method!(RbSeries::new_from_index, 2))?;
+    class.define_method("filter", method!(RbSeries::filter, 1))?;
+    class.define_method("add", method!(RbSeries::add, 1))?;
+    class.define_method("sub", method!(RbSeries::sub, 1))?;
+    class.define_method("mul", method!(RbSeries::mul, 1))?;
+    class.define_method("div", method!(RbSeries::div, 1))?;
+    class.define_method("rem", method!(RbSeries::rem, 1))?;
+    class.define_method("sort", method!(RbSeries::sort, 1))?;
+    class.define_method("value_counts", method!(RbSeries::value_counts, 1))?;
+    class.define_method("arg_min", method!(RbSeries::arg_min, 0))?;
+    class.define_method("arg_max", method!(RbSeries::arg_max, 0))?;
+    class.define_method("take_with_series", method!(RbSeries::take_with_series, 1))?;
+    class.define_method("null_count", method!(RbSeries::null_count, 0))?;
+    class.define_method("has_validity", method!(RbSeries::has_validity, 0))?;
+    class.define_method("sample_n", method!(RbSeries::sample_n, 4))?;
+    class.define_method("sample_frac", method!(RbSeries::sample_frac, 4))?;
+    class.define_method("series_equal", method!(RbSeries::series_equal, 3))?;
+    class.define_method("eq", method!(RbSeries::eq, 1))?;
+    class.define_method("neq", method!(RbSeries::neq, 1))?;
+    class.define_method("gt", method!(RbSeries::gt, 1))?;
+    class.define_method("gt_eq", method!(RbSeries::gt_eq, 1))?;
+    class.define_method("lt", method!(RbSeries::lt, 1))?;
+    class.define_method("lt_eq", method!(RbSeries::lt_eq, 1))?;
+    class.define_method("not", method!(RbSeries::not, 0))?;
+    class.define_method("to_s", method!(RbSeries::to_s, 0))?;
+    class.define_method("len", method!(RbSeries::len, 0))?;
+    class.define_method("to_a", method!(RbSeries::to_a, 0))?;
+    class.define_method("median", method!(RbSeries::median, 0))?;
+    // rest
+    class.define_method("cumsum", method!(RbSeries::cumsum, 1))?;
+    class.define_method("cummax", method!(RbSeries::cummax, 1))?;
+    class.define_method("cummin", method!(RbSeries::cummin, 1))?;
+    class.define_method("slice", method!(RbSeries::slice, 2))?;
+
+    let class = module.define_class("RbWhen", Default::default())?;
+    class.define_method("_then", method!(RbWhen::then, 1))?;
+
+    let class = module.define_class("RbWhenThen", Default::default())?;
+    class.define_method("otherwise", method!(RbWhenThen::overwise, 1))?;
+
+    Ok(())
+}
+
+fn concat_df(seq: RArray) -> RbResult<RbDataFrame> {
+    let mut iter = seq.each();
+    let first = iter.next().unwrap()?;
+
+    let first_rdf = get_df(first)?;
+    let identity_df = first_rdf.slice(0, 0);
+
+    let mut rdfs: Vec<PolarsResult<DataFrame>> = vec![Ok(first_rdf)];
+
+    for item in iter {
+        let rdf = get_df(item?)?;
+        rdfs.push(Ok(rdf));
+    }
+
+    let identity = Ok(identity_df);
+
+    let df = rdfs
+        .into_iter()
+        .fold(identity, |acc: PolarsResult<DataFrame>, df| {
+            let mut acc = acc?;
+            acc.vstack_mut(&df?)?;
+            Ok(acc)
+        })
+        .map_err(RbPolarsErr::from)?;
+
+    Ok(df.into())
+}
+
+fn rb_diag_concat_df(seq: RArray) -> RbResult<RbDataFrame> {
+    let mut dfs = Vec::new();
+    for item in seq.each() {
+        dfs.push(get_df(item?)?);
+    }
+    let df = diag_concat_df(&dfs).map_err(RbPolarsErr::from)?;
+    Ok(df.into())
+}
+
+fn rb_hor_concat_df(seq: RArray) -> RbResult<RbDataFrame> {
+    let mut dfs = Vec::new();
+    for item in seq.each() {
+        dfs.push(get_df(item?)?);
+    }
+    let df = hor_concat_df(&dfs).map_err(RbPolarsErr::from)?;
+    Ok(df.into())
+}