polars-df 0.3.1 → 0.5.0

data/ext/polars/src/{lazy/dsl.rs → expr/general.rs}

@@ -1,28 +1,13 @@
-use magnus::block::Proc;
-use magnus::{class, IntoValue, RArray, RString, Value};
-use polars::chunked_array::ops::SortOptions;
+use magnus::{block::Proc, IntoValue, RArray, Value};
 use polars::lazy::dsl;
-use polars::lazy::dsl::Operator;
 use polars::prelude::*;
 use polars::series::ops::NullBehavior;
 
-use crate::conversion::*;
-use crate::lazy::apply::*;
-use crate::lazy::utils::rb_exprs_to_exprs;
+use crate::apply::lazy::map_single;
+use crate::conversion::{parse_fill_null_strategy, Wrap};
+use crate::rb_exprs_to_exprs;
 use crate::utils::reinterpret;
-use crate::{RbResult, RbSeries};
-
-#[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 }
-    }
-}
+use crate::{RbExpr, RbResult};
 
 impl RbExpr {
     pub fn add(&self, rhs: &RbExpr) -> RbResult<Self> {
@@ -156,12 +141,13 @@ impl RbExpr {
     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 implode(&self) -> Self {
+        self.clone().inner.implode().into()
     }
 
     pub fn quantile(
@@ -230,8 +216,12 @@ impl RbExpr {
             .into()
     }
 
-    pub fn top_k(&self, k: usize, reverse: bool) -> Self {
-        self.inner.clone().top_k(k, reverse).into()
+    pub fn top_k(&self, k: usize) -> Self {
+        self.inner.clone().top_k(k).into()
+    }
+
+    pub fn bottom_k(&self, k: usize) -> Self {
+        self.inner.clone().bottom_k(k).into()
     }
 
     pub fn arg_max(&self) -> Self {
@@ -329,6 +319,10 @@ impl RbExpr {
         self.clone().inner.is_unique().into()
     }
 
+    pub fn approx_unique(&self) -> Self {
+        self.clone().inner.approx_unique().into()
+    }
+
     pub fn is_first(&self) -> Self {
         self.clone().inner.is_first().into()
     }
@@ -518,499 +512,6 @@ impl RbExpr {
         self.inner.clone().shrink_dtype().into()
     }
 
-    pub fn str_parse_date(
-        &self,
-        fmt: Option<String>,
-        strict: bool,
-        exact: bool,
-        cache: bool,
-    ) -> Self {
-        self.inner
-            .clone()
-            .str()
-            .strptime(StrpTimeOptions {
-                date_dtype: DataType::Date,
-                fmt,
-                strict,
-                exact,
-                cache,
-                tz_aware: false,
-                utc: false,
-            })
-            .into()
-    }
-
-    pub fn str_parse_datetime(
-        &self,
-        fmt: Option<String>,
-        strict: bool,
-        exact: bool,
-        cache: bool,
-        tz_aware: bool,
-        utc: bool,
-    ) -> Self {
-        let tu = match fmt {
-            Some(ref fmt) => {
-                if fmt.contains("%.9f")
-                    || fmt.contains("%9f")
-                    || fmt.contains("%f")
-                    || fmt.contains("%.f")
-                {
-                    TimeUnit::Nanoseconds
-                } else if fmt.contains("%.3f") || fmt.contains("%3f") {
-                    TimeUnit::Milliseconds
-                } else {
-                    TimeUnit::Microseconds
-                }
-            }
-            None => TimeUnit::Microseconds,
-        };
-        self.inner
-            .clone()
-            .str()
-            .strptime(StrpTimeOptions {
-                date_dtype: DataType::Datetime(tu, None),
-                fmt,
-                strict,
-                exact,
-                cache,
-                tz_aware,
-                utc,
-            })
-            .into()
-    }
-
-    pub fn str_parse_time(
-        &self,
-        fmt: Option<String>,
-        strict: bool,
-        exact: bool,
-        cache: bool,
-    ) -> Self {
-        self.inner
-            .clone()
-            .str()
-            .strptime(StrpTimeOptions {
-                date_dtype: DataType::Time,
-                fmt,
-                strict,
-                exact,
-                cache,
-                tz_aware: false,
-                utc: false,
-            })
-            .into()
-    }
-
-    pub fn str_strip(&self, matches: Option<String>) -> Self {
-        self.inner.clone().str().strip(matches).into()
-    }
-
-    pub fn str_rstrip(&self, matches: Option<String>) -> Self {
-        self.inner.clone().str().rstrip(matches).into()
-    }
-
-    pub fn str_lstrip(&self, matches: Option<String>) -> Self {
-        self.inner.clone().str().lstrip(matches).into()
-    }
-
-    pub fn str_slice(&self, start: i64, length: Option<u64>) -> Self {
-        let function = move |s: Series| {
-            let ca = s.utf8()?;
-            Ok(Some(ca.str_slice(start, length)?.into_series()))
-        };
-        self.clone()
-            .inner
-            .map(function, GetOutput::from_type(DataType::Utf8))
-            .with_fmt("str.slice")
-            .into()
-    }
-
-    pub fn str_to_uppercase(&self) -> Self {
-        self.inner.clone().str().to_uppercase().into()
-    }
-
-    pub fn str_to_lowercase(&self) -> Self {
-        self.inner.clone().str().to_lowercase().into()
-    }
-
-    pub fn str_lengths(&self) -> Self {
-        let function = |s: Series| {
-            let ca = s.utf8()?;
-            Ok(Some(ca.str_lengths().into_series()))
-        };
-        self.clone()
-            .inner
-            .map(function, GetOutput::from_type(DataType::UInt32))
-            .with_fmt("str.lengths")
-            .into()
-    }
-
-    pub fn str_n_chars(&self) -> Self {
-        let function = |s: Series| {
-            let ca = s.utf8()?;
-            Ok(Some(ca.str_n_chars().into_series()))
-        };
-        self.clone()
-            .inner
-            .map(function, GetOutput::from_type(DataType::UInt32))
-            .with_fmt("str.n_chars")
-            .into()
-    }
-
-    pub fn str_replace(&self, pat: &RbExpr, val: &RbExpr, literal: bool) -> Self {
-        self.inner
-            .clone()
-            .str()
-            .replace(pat.inner.clone(), val.inner.clone(), literal)
-            .into()
-    }
-
-    pub fn str_replace_all(&self, pat: &RbExpr, val: &RbExpr, literal: bool) -> Self {
-        self.inner
-            .clone()
-            .str()
-            .replace_all(pat.inner.clone(), val.inner.clone(), literal)
-            .into()
-    }
-
-    pub fn str_zfill(&self, alignment: usize) -> Self {
-        self.clone().inner.str().zfill(alignment).into()
-    }
-
-    pub fn str_ljust(&self, width: usize, fillchar: char) -> Self {
-        self.clone().inner.str().ljust(width, fillchar).into()
-    }
-
-    pub fn str_rjust(&self, width: usize, fillchar: char) -> Self {
-        self.clone().inner.str().rjust(width, fillchar).into()
-    }
-
-    pub fn str_contains(&self, pat: &RbExpr, literal: Option<bool>, strict: bool) -> Self {
-        match literal {
-            Some(true) => self
-                .inner
-                .clone()
-                .str()
-                .contains_literal(pat.inner.clone())
-                .into(),
-            _ => self
-                .inner
-                .clone()
-                .str()
-                .contains(pat.inner.clone(), strict)
-                .into(),
-        }
-    }
-
-    pub fn str_ends_with(&self, sub: &RbExpr) -> Self {
-        self.inner.clone().str().ends_with(sub.inner.clone()).into()
-    }
-
-    pub fn str_starts_with(&self, sub: &RbExpr) -> Self {
-        self.inner
-            .clone()
-            .str()
-            .starts_with(sub.inner.clone())
-            .into()
-    }
-
-    pub fn str_hex_encode(&self) -> Self {
-        self.clone()
-            .inner
-            .map(
-                move |s| s.utf8().map(|s| Some(s.hex_encode().into_series())),
-                GetOutput::same_type(),
-            )
-            .with_fmt("str.hex_encode")
-            .into()
-    }
-
-    pub fn str_hex_decode(&self, strict: bool) -> Self {
-        self.clone()
-            .inner
-            .map(
-                move |s| s.utf8()?.hex_decode(strict).map(|s| Some(s.into_series())),
-                GetOutput::same_type(),
-            )
-            .with_fmt("str.hex_decode")
-            .into()
-    }
-
-    pub fn str_base64_encode(&self) -> Self {
-        self.clone()
-            .inner
-            .map(
-                move |s| s.utf8().map(|s| Some(s.base64_encode().into_series())),
-                GetOutput::same_type(),
-            )
-            .with_fmt("str.base64_encode")
-            .into()
-    }
-
-    pub fn str_base64_decode(&self, strict: bool) -> Self {
-        self.clone()
-            .inner
-            .map(
-                move |s| {
-                    s.utf8()?
-                        .base64_decode(strict)
-                        .map(|s| Some(s.into_series()))
-                },
-                GetOutput::same_type(),
-            )
-            .with_fmt("str.base64_decode")
-            .into()
-    }
-
-    pub fn str_json_path_match(&self, pat: String) -> Self {
-        let function = move |s: Series| {
-            let ca = s.utf8()?;
-            match ca.json_path_match(&pat) {
-                Ok(ca) => Ok(Some(ca.into_series())),
-                Err(e) => Err(PolarsError::ComputeError(format!("{:?}", e).into())),
-            }
-        };
-        self.clone()
-            .inner
-            .map(function, GetOutput::from_type(DataType::Utf8))
-            .with_fmt("str.json_path_match")
-            .into()
-    }
-
-    pub fn str_extract(&self, pat: String, group_index: usize) -> Self {
-        self.inner.clone().str().extract(&pat, group_index).into()
-    }
-
-    pub fn str_extract_all(&self, pat: &RbExpr) -> Self {
-        self.inner
-            .clone()
-            .str()
-            .extract_all(pat.inner.clone())
-            .into()
-    }
-
-    pub fn count_match(&self, pat: String) -> Self {
-        self.inner.clone().str().count_match(&pat).into()
-    }
-
-    pub fn strftime(&self, fmt: String) -> Self {
-        self.inner.clone().dt().strftime(&fmt).into()
-    }
-
-    pub fn str_split(&self, by: String) -> Self {
-        self.inner.clone().str().split(&by).into()
-    }
-
-    pub fn str_split_inclusive(&self, by: String) -> Self {
-        self.inner.clone().str().split_inclusive(&by).into()
-    }
-
-    pub fn str_split_exact(&self, by: String, n: usize) -> Self {
-        self.inner.clone().str().split_exact(&by, n).into()
-    }
-
-    pub fn str_split_exact_inclusive(&self, by: String, n: usize) -> Self {
-        self.inner
-            .clone()
-            .str()
-            .split_exact_inclusive(&by, n)
-            .into()
-    }
-
-    pub fn str_splitn(&self, by: String, n: usize) -> Self {
-        self.inner.clone().str().splitn(&by, n).into()
-    }
-
-    pub fn arr_lengths(&self) -> Self {
-        self.inner.clone().arr().lengths().into()
-    }
-
-    pub fn arr_contains(&self, other: &RbExpr) -> Self {
-        self.inner
-            .clone()
-            .arr()
-            .contains(other.inner.clone())
-            .into()
-    }
-
-    pub fn year(&self) -> Self {
-        self.clone().inner.dt().year().into()
-    }
-
-    pub fn iso_year(&self) -> Self {
-        self.clone().inner.dt().iso_year().into()
-    }
-
-    pub fn quarter(&self) -> Self {
-        self.clone().inner.dt().quarter().into()
-    }
-
-    pub fn month(&self) -> Self {
-        self.clone().inner.dt().month().into()
-    }
-
-    pub fn week(&self) -> Self {
-        self.clone().inner.dt().week().into()
-    }
-
-    pub fn weekday(&self) -> Self {
-        self.clone().inner.dt().weekday().into()
-    }
-
-    pub fn day(&self) -> Self {
-        self.clone().inner.dt().day().into()
-    }
-
-    pub fn ordinal_day(&self) -> Self {
-        self.clone().inner.dt().ordinal_day().into()
-    }
-
-    pub fn hour(&self) -> Self {
-        self.clone().inner.dt().hour().into()
-    }
-
-    pub fn minute(&self) -> Self {
-        self.clone().inner.dt().minute().into()
-    }
-
-    pub fn second(&self) -> Self {
-        self.clone().inner.dt().second().into()
-    }
-
-    pub fn millisecond(&self) -> Self {
-        self.clone().inner.dt().millisecond().into()
-    }
-
-    pub fn microsecond(&self) -> Self {
-        self.clone().inner.dt().microsecond().into()
-    }
-
-    pub fn nanosecond(&self) -> Self {
-        self.clone().inner.dt().nanosecond().into()
-    }
-
-    pub fn duration_days(&self) -> Self {
-        self.inner
-            .clone()
-            .map(
-                |s| Ok(Some(s.duration()?.days().into_series())),
-                GetOutput::from_type(DataType::Int64),
-            )
-            .into()
-    }
-
-    pub fn duration_hours(&self) -> Self {
-        self.inner
-            .clone()
-            .map(
-                |s| Ok(Some(s.duration()?.hours().into_series())),
-                GetOutput::from_type(DataType::Int64),
-            )
-            .into()
-    }
-
-    pub fn duration_minutes(&self) -> Self {
-        self.inner
-            .clone()
-            .map(
-                |s| Ok(Some(s.duration()?.minutes().into_series())),
-                GetOutput::from_type(DataType::Int64),
-            )
-            .into()
-    }
-
-    pub fn duration_seconds(&self) -> Self {
-        self.inner
-            .clone()
-            .map(
-                |s| Ok(Some(s.duration()?.seconds().into_series())),
-                GetOutput::from_type(DataType::Int64),
-            )
-            .into()
-    }
-
-    pub fn duration_nanoseconds(&self) -> Self {
-        self.inner
-            .clone()
-            .map(
-                |s| Ok(Some(s.duration()?.nanoseconds().into_series())),
-                GetOutput::from_type(DataType::Int64),
-            )
-            .into()
-    }
-
-    pub fn duration_microseconds(&self) -> Self {
-        self.inner
-            .clone()
-            .map(
-                |s| Ok(Some(s.duration()?.microseconds().into_series())),
-                GetOutput::from_type(DataType::Int64),
-            )
-            .into()
-    }
-
-    pub fn duration_milliseconds(&self) -> Self {
-        self.inner
-            .clone()
-            .map(
-                |s| Ok(Some(s.duration()?.milliseconds().into_series())),
-                GetOutput::from_type(DataType::Int64),
-            )
-            .into()
-    }
-
-    pub fn timestamp(&self, tu: Wrap<TimeUnit>) -> Self {
-        self.inner.clone().dt().timestamp(tu.0).into()
-    }
-
-    pub fn dt_offset_by(&self, by: String) -> Self {
-        let by = Duration::parse(&by);
-        self.inner.clone().dt().offset_by(by).into()
-    }
-
-    pub fn dt_epoch_seconds(&self) -> Self {
-        self.clone()
-            .inner
-            .map(
-                |s| {
-                    s.timestamp(TimeUnit::Milliseconds)
-                        .map(|ca| Some((ca / 1000).into_series()))
-                },
-                GetOutput::from_type(DataType::Int64),
-            )
-            .into()
-    }
-
-    pub fn dt_with_time_unit(&self, tu: Wrap<TimeUnit>) -> Self {
-        self.inner.clone().dt().with_time_unit(tu.0).into()
-    }
-
-    pub fn dt_convert_time_zone(&self, tz: TimeZone) -> Self {
-        self.inner.clone().dt().convert_time_zone(tz).into()
-    }
-
-    pub fn dt_cast_time_unit(&self, tu: Wrap<TimeUnit>) -> Self {
-        self.inner.clone().dt().cast_time_unit(tu.0).into()
-    }
-
-    pub fn dt_replace_time_zone(&self, tz: Option<String>) -> Self {
-        self.inner.clone().dt().replace_time_zone(tz).into()
-    }
-
-    #[allow(deprecated)]
-    pub fn dt_tz_localize(&self, tz: String) -> Self {
-        self.inner.clone().dt().tz_localize(tz).into()
-    }
-
-    pub fn dt_truncate(&self, every: String, offset: String) -> Self {
-        self.inner.clone().dt().truncate(&every, &offset).into()
-    }
-
-    pub fn dt_round(&self, every: String, offset: String) -> Self {
-        self.inner.clone().dt().round(&every, &offset).into()
-    }
-
     pub fn map(&self, lambda: Value, output_type: Option<Wrap<DataType>>, agg_list: bool) -> Self {
         map_single(self, lambda, output_type, agg_list)
     }
@@ -1258,96 +759,6 @@ impl RbExpr {
         self.inner.clone().upper_bound().into()
     }
 
-    pub fn lst_max(&self) -> Self {
-        self.inner.clone().arr().max().into()
-    }
-
-    pub fn lst_min(&self) -> Self {
-        self.inner.clone().arr().min().into()
-    }
-
-    pub fn lst_sum(&self) -> Self {
-        self.inner.clone().arr().sum().with_fmt("arr.sum").into()
-    }
-
-    pub fn lst_mean(&self) -> Self {
-        self.inner.clone().arr().mean().with_fmt("arr.mean").into()
-    }
-
-    pub fn lst_sort(&self, reverse: bool) -> Self {
-        self.inner
-            .clone()
-            .arr()
-            .sort(SortOptions {
-                descending: reverse,
-                ..Default::default()
-            })
-            .with_fmt("arr.sort")
-            .into()
-    }
-
-    pub fn lst_reverse(&self) -> Self {
-        self.inner
-            .clone()
-            .arr()
-            .reverse()
-            .with_fmt("arr.reverse")
-            .into()
-    }
-
-    pub fn lst_unique(&self) -> Self {
-        self.inner
-            .clone()
-            .arr()
-            .unique()
-            .with_fmt("arr.unique")
-            .into()
-    }
-
-    pub fn lst_get(&self, index: &RbExpr) -> Self {
-        self.inner.clone().arr().get(index.inner.clone()).into()
-    }
-
-    pub fn lst_join(&self, separator: String) -> Self {
-        self.inner.clone().arr().join(&separator).into()
-    }
-
-    pub fn lst_arg_min(&self) -> Self {
-        self.inner.clone().arr().arg_min().into()
-    }
-
-    pub fn lst_arg_max(&self) -> Self {
-        self.inner.clone().arr().arg_max().into()
-    }
-
-    pub fn lst_diff(&self, n: usize, null_behavior: Wrap<NullBehavior>) -> RbResult<Self> {
-        Ok(self.inner.clone().arr().diff(n, null_behavior.0).into())
-    }
-
-    pub fn lst_shift(&self, periods: i64) -> Self {
-        self.inner.clone().arr().shift(periods).into()
-    }
-
-    pub fn lst_slice(&self, offset: &RbExpr, length: Option<&RbExpr>) -> Self {
-        let length = match length {
-            Some(i) => i.inner.clone(),
-            None => dsl::lit(i64::MAX),
-        };
-        self.inner
-            .clone()
-            .arr()
-            .slice(offset.inner.clone(), length)
-            .into()
-    }
-
-    pub fn lst_eval(&self, expr: &RbExpr, parallel: bool) -> Self {
-        self.inner
-            .clone()
-            .arr()
-            .eval(expr.inner.clone(), parallel)
-            .into()
-    }
-
     pub fn cumulative_eval(&self, expr: &RbExpr, min_periods: usize, parallel: bool) -> Self {
         self.inner
             .clone()
@@ -1355,42 +766,19 @@ impl RbExpr {
             .into()
     }
 
-    pub fn lst_to_struct(
-        &self,
-        width_strat: Wrap<ListToStructWidthStrategy>,
-        _name_gen: Option<Value>,
-        upper_bound: usize,
-    ) -> RbResult<Self> {
-        // TODO fix
-        let name_gen = None;
-        // let name_gen = name_gen.map(|lambda| {
-        //     Arc::new(move |idx: usize| {
-        //         let out: Value = lambda.funcall("call", (idx,)).unwrap();
-        //         out.try_convert::<String>().unwrap()
-        //     }) as NameGenerator
-        // });
-
-        Ok(self
-            .inner
-            .clone()
-            .arr()
-            .to_struct(width_strat.0, name_gen, upper_bound)
-            .into())
-    }
-
-    pub fn rank(&self, method: Wrap<RankMethod>, reverse: bool) -> Self {
+    pub fn rank(&self, method: Wrap<RankMethod>, reverse: bool, seed: Option<u64>) -> Self {
         let options = RankOptions {
             method: method.0,
             descending: reverse,
         };
-        self.inner.clone().rank(options).into()
+        self.inner.clone().rank(options, seed).into()
     }
 
-    pub fn diff(&self, n: usize, null_behavior: Wrap<NullBehavior>) -> Self {
+    pub fn diff(&self, n: i64, null_behavior: Wrap<NullBehavior>) -> Self {
         self.inner.clone().diff(n, null_behavior.0).into()
     }
 
-    pub fn pct_change(&self, n: usize) -> Self {
+    pub fn pct_change(&self, n: i64) -> Self {
         self.inner.clone().pct_change(n).into()
     }
 
@@ -1402,14 +790,6 @@ impl RbExpr {
         self.inner.clone().kurtosis(fisher, bias).into()
     }
 
-    pub fn str_concat(&self, delimiter: String) -> Self {
-        self.inner.clone().str().concat(&delimiter).into()
-    }
-
-    pub fn cat_set_ordering(&self, ordering: Wrap<CategoricalOrdering>) -> Self {
-        self.inner.clone().cat().set_ordering(ordering.0).into()
-    }
-
     pub fn reshape(&self, dims: Vec<i64>) -> Self {
         self.inner.clone().reshape(&dims).into()
     }
@@ -1535,18 +915,6 @@ impl RbExpr {
         self.inner.clone().all().into()
     }
 
-    pub fn struct_field_by_name(&self, name: String) -> Self {
-        self.inner.clone().struct_().field_by_name(&name).into()
-    }
-
-    pub fn struct_field_by_index(&self, index: i64) -> Self {
-        self.inner.clone().struct_().field_by_index(index).into()
-    }
-
-    pub fn struct_rename_fields(&self, names: Vec<String>) -> Self {
-        self.inner.clone().struct_().rename_fields(names).into()
-    }
-
     pub fn log(&self, base: f64) -> Self {
         self.inner.clone().log(base).into()
     }
@@ -1563,148 +931,3 @@ impl RbExpr {
         self.inner.clone().hash(seed, seed_1, seed_2, seed_3).into()
     }
 }
-
-pub fn col(name: String) -> RbExpr {
-    dsl::col(&name).into()
-}
-
-pub fn count() -> RbExpr {
-    dsl::count().into()
-}
-
-pub fn first() -> RbExpr {
-    dsl::first().into()
-}
-
-pub fn last() -> RbExpr {
-    dsl::last().into()
-}
-
-pub fn cols(names: Vec<String>) -> RbExpr {
-    dsl::cols(names).into()
-}
-
-pub fn dtype_cols(dtypes: Vec<DataType>) -> RbExpr {
-    dsl::dtype_cols(dtypes).into()
-}
-
-pub fn fold(acc: &RbExpr, lambda: Value, exprs: RArray) -> RbResult<RbExpr> {
-    let exprs = rb_exprs_to_exprs(exprs)?;
-
-    let func = move |a: Series, b: Series| binary_lambda(lambda, a, b);
-    Ok(polars::lazy::dsl::fold_exprs(acc.inner.clone(), func, exprs).into())
-}
-
-pub fn cumfold(acc: &RbExpr, lambda: Value, exprs: RArray, include_init: bool) -> RbResult<RbExpr> {
-    let exprs = rb_exprs_to_exprs(exprs)?;
-
-    let func = move |a: Series, b: Series| binary_lambda(lambda, a, b);
-    Ok(polars::lazy::dsl::cumfold_exprs(acc.inner.clone(), func, exprs, include_init).into())
-}
-
-// TODO improve
-pub fn lit(value: Value) -> RbResult<RbExpr> {
-    if value.is_nil() {
-        Ok(dsl::lit(Null {}).into())
-    } else if let Ok(series) = value.try_convert::<&RbSeries>() {
-        Ok(dsl::lit(series.series.borrow().clone()).into())
-    } else if let Some(v) = RString::from_value(value) {
-        Ok(dsl::lit(v.try_convert::<String>()?).into())
-    } else if value.is_kind_of(class::integer()) {
-        match value.try_convert::<i64>() {
-            Ok(val) => {
-                if val > 0 && val < i32::MAX as i64 || val < 0 && val > i32::MIN as i64 {
-                    Ok(dsl::lit(val as i32).into())
-                } else {
-                    Ok(dsl::lit(val).into())
-                }
-            }
-            _ => {
-                let val = value.try_convert::<u64>()?;
-                Ok(dsl::lit(val).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()
-}
-
-pub fn repeat(value: Value, n_times: &RbExpr) -> RbResult<RbExpr> {
-    if value.is_nil() {
-        Ok(polars::lazy::dsl::repeat(Null {}, n_times.inner.clone()).into())
-    } else {
-        todo!();
-    }
-}
-
-pub fn pearson_corr(a: &RbExpr, b: &RbExpr, ddof: u8) -> RbExpr {
-    polars::lazy::dsl::pearson_corr(a.inner.clone(), b.inner.clone(), ddof).into()
-}
-
-pub fn spearman_rank_corr(a: &RbExpr, b: &RbExpr, ddof: u8, propagate_nans: bool) -> RbExpr {
-    polars::lazy::dsl::spearman_rank_corr(a.inner.clone(), b.inner.clone(), ddof, propagate_nans)
-        .into()
-}
-
-pub fn cov(a: &RbExpr, b: &RbExpr) -> RbExpr {
-    polars::lazy::dsl::cov(a.inner.clone(), b.inner.clone()).into()
-}
-
-pub fn argsort_by(by: RArray, reverse: Vec<bool>) -> RbResult<RbExpr> {
-    let by = rb_exprs_to_exprs(by)?;
-    Ok(polars::lazy::dsl::argsort_by(by, &reverse).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()
-}
-
-pub fn concat_str(s: RArray, sep: String) -> RbResult<RbExpr> {
-    let s = rb_exprs_to_exprs(s)?;
-    Ok(dsl::concat_str(s, &sep).into())
-}
-
-pub fn concat_lst(s: RArray) -> RbResult<RbExpr> {
-    let s = rb_exprs_to_exprs(s)?;
-    Ok(dsl::concat_lst(s).into())
-}