polars-df 0.1.4 → 0.2.0

data/ext/polars/src/conversion.rs

@@ -1,35 +1,64 @@
-use magnus::{class, RArray, Symbol, TryConvert, Value, QNIL};
+use magnus::{class, r_hash::ForEach, Module, RArray, RHash, Symbol, TryConvert, Value, QNIL};
 use polars::chunked_array::object::PolarsObjectSafe;
 use polars::chunked_array::ops::{FillNullLimit, FillNullStrategy};
 use polars::datatypes::AnyValue;
-use polars::frame::DataFrame;
+use polars::frame::row::Row;
+use polars::frame::NullStrategy;
+use polars::io::avro::AvroCompression;
 use polars::prelude::*;
 use polars::series::ops::NullBehavior;
 use std::fmt::{Display, Formatter};
 use std::hash::{Hash, Hasher};
 
-use crate::{RbDataFrame, RbPolarsErr, RbResult, RbSeries, RbValueError};
+use crate::{RbDataFrame, RbLazyFrame, RbPolarsErr, RbResult, RbSeries, RbValueError};
 
+pub(crate) fn slice_to_wrapped<T>(slice: &[T]) -> &[Wrap<T>] {
+    // Safety:
+    // Wrap is transparent.
+    unsafe { std::mem::transmute(slice) }
+}
+
+pub(crate) fn vec_extract_wrapped<T>(buf: Vec<Wrap<T>>) -> Vec<T> {
+    // Safety:
+    // Wrap is transparent.
+    unsafe { std::mem::transmute(buf) }
+}
+
+#[repr(transparent)]
 pub struct Wrap<T>(pub T);
 
+impl<T> Clone for Wrap<T>
+where
+    T: Clone,
+{
+    fn clone(&self) -> Self {
+        Wrap(self.0.clone())
+    }
+}
+
 impl<T> From<T> for Wrap<T> {
     fn from(t: T) -> Self {
         Wrap(t)
     }
 }
 
-pub fn get_rbseq(obj: Value) -> RbResult<(RArray, usize)> {
+pub(crate) fn get_rbseq(obj: Value) -> RbResult<(RArray, usize)> {
     let seq: RArray = obj.try_convert()?;
     let len = seq.len();
     Ok((seq, len))
 }
 
-pub fn get_df(obj: Value) -> RbResult<DataFrame> {
+pub(crate) fn get_df(obj: Value) -> RbResult<DataFrame> {
     let rbdf = obj.funcall::<_, _, &RbDataFrame>("_df", ())?;
     Ok(rbdf.df.borrow().clone())
 }
 
-pub fn get_series(obj: Value) -> RbResult<Series> {
+pub(crate) fn get_lf(obj: Value) -> RbResult<LazyFrame> {
+    let rbdf = obj.funcall::<_, _, &RbLazyFrame>("_ldf", ())?;
+    Ok(rbdf.ldf.clone())
+}
+
+pub(crate) fn get_series(obj: Value) -> RbResult<Series> {
     let rbs = obj.funcall::<_, _, &RbSeries>("_s", ())?;
     Ok(rbs.series.borrow().clone())
 }
@@ -115,40 +144,127 @@ impl From<Wrap<AnyValue<'_>>> for Value {
 
 impl From<Wrap<DataType>> for Value {
     fn from(w: Wrap<DataType>) -> Self {
-        Symbol::from(w.0.to_string()).into()
+        let pl = crate::module();
+
+        match &w.0 {
+            DataType::Int8 => pl.const_get::<_, Value>("Int8").unwrap(),
+            DataType::Int16 => pl.const_get::<_, Value>("Int16").unwrap(),
+            DataType::Int32 => pl.const_get::<_, Value>("Int32").unwrap(),
+            DataType::Int64 => pl.const_get::<_, Value>("Int64").unwrap(),
+            DataType::UInt8 => pl.const_get::<_, Value>("UInt8").unwrap(),
+            DataType::UInt16 => pl.const_get::<_, Value>("UInt16").unwrap(),
+            DataType::UInt32 => pl.const_get::<_, Value>("UInt32").unwrap(),
+            DataType::UInt64 => pl.const_get::<_, Value>("UInt64").unwrap(),
+            DataType::Float32 => pl.const_get::<_, Value>("Float32").unwrap(),
+            DataType::Float64 => pl.const_get::<_, Value>("Float64").unwrap(),
+            DataType::Boolean => pl.const_get::<_, Value>("Boolean").unwrap(),
+            DataType::Utf8 => pl.const_get::<_, Value>("Utf8").unwrap(),
+            DataType::Binary => pl.const_get::<_, Value>("Binary").unwrap(),
+            DataType::List(inner) => {
+                let inner = Wrap(*inner.clone());
+                let list_class = pl.const_get::<_, Value>("List").unwrap();
+                list_class.funcall::<_, _, Value>("new", (inner,)).unwrap()
+            }
+            DataType::Date => pl.const_get::<_, Value>("Date").unwrap(),
+            DataType::Datetime(tu, tz) => {
+                let datetime_class = pl.const_get::<_, Value>("Datetime").unwrap();
+                datetime_class
+                    .funcall::<_, _, Value>("new", (tu.to_ascii(), tz.clone()))
+                    .unwrap()
+            }
+            DataType::Duration(tu) => {
+                let duration_class = pl.const_get::<_, Value>("Duration").unwrap();
+                duration_class
+                    .funcall::<_, _, Value>("new", (tu.to_ascii(),))
+                    .unwrap()
+            }
+            DataType::Object(_) => pl.const_get::<_, Value>("Object").unwrap(),
+            DataType::Categorical(_) => pl.const_get::<_, Value>("Categorical").unwrap(),
+            DataType::Time => pl.const_get::<_, Value>("Time").unwrap(),
+            DataType::Struct(fields) => {
+                let field_class = pl.const_get::<_, Value>("Field").unwrap();
+                let iter = fields.iter().map(|fld| {
+                    let name = fld.name().clone();
+                    let dtype = Wrap(fld.data_type().clone());
+                    field_class
+                        .funcall::<_, _, Value>("new", (name, dtype))
+                        .unwrap()
+                });
+                let fields = RArray::from_iter(iter);
+                let struct_class = pl.const_get::<_, Value>("Struct").unwrap();
+                struct_class
+                    .funcall::<_, _, Value>("new", (fields,))
+                    .unwrap()
+            }
+            DataType::Null => pl.const_get::<_, Value>("Null").unwrap(),
+            DataType::Unknown => pl.const_get::<_, Value>("Unknown").unwrap(),
+        }
     }
 }
 
 impl TryConvert for Wrap<DataType> {
     fn try_convert(ob: Value) -> RbResult<Self> {
-        let dtype = match ob.try_convert::<String>()?.as_str() {
-            "u8" => DataType::UInt8,
-            "u16" => DataType::UInt16,
-            "u32" => DataType::UInt32,
-            "u64" => DataType::UInt64,
-            "i8" => DataType::Int8,
-            "i16" => DataType::Int16,
-            "i32" => DataType::Int32,
-            "i64" => DataType::Int64,
-            "str" => DataType::Utf8,
-            "bin" => DataType::Binary,
-            "bool" => DataType::Boolean,
-            "cat" => DataType::Categorical(None),
-            "date" => DataType::Date,
-            "datetime" => DataType::Datetime(TimeUnit::Microseconds, None),
-            "f32" => DataType::Float32,
-            "time" => DataType::Time,
-            "dur" => DataType::Duration(TimeUnit::Microseconds),
-            "f64" => DataType::Float64,
-            // "obj" => DataType::Object(OBJECT_NAME),
-            "list" => DataType::List(Box::new(DataType::Boolean)),
-            "null" => DataType::Null,
-            "unk" => DataType::Unknown,
-            _ => {
-                return Err(RbValueError::new_err(format!(
-                    "{} is not a supported DataType.",
-                    ob
-                )))
+        let dtype = if ob.is_kind_of(class::class()) {
+            let name = ob.funcall::<_, _, String>("name", ())?;
+            match name.as_str() {
+                "Polars::UInt8" => DataType::UInt8,
+                "Polars::UInt16" => DataType::UInt16,
+                "Polars::UInt32" => DataType::UInt32,
+                "Polars::UInt64" => DataType::UInt64,
+                "Polars::Int8" => DataType::Int8,
+                "Polars::Int16" => DataType::Int16,
+                "Polars::Int32" => DataType::Int32,
+                "Polars::Int64" => DataType::Int64,
+                "Polars::Utf8" => DataType::Utf8,
+                "Polars::Binary" => DataType::Binary,
+                "Polars::Boolean" => DataType::Boolean,
+                "Polars::Categorical" => DataType::Categorical(None),
+                "Polars::Date" => DataType::Date,
+                "Polars::Datetime" => DataType::Datetime(TimeUnit::Microseconds, None),
+                "Polars::Time" => DataType::Time,
+                "Polars::Duration" => DataType::Duration(TimeUnit::Microseconds),
+                "Polars::Float32" => DataType::Float32,
+                "Polars::Float64" => DataType::Float64,
+                // "Polars::Object" => DataType::Object(OBJECT_NAME),
+                "Polars::List" => DataType::List(Box::new(DataType::Boolean)),
+                "Polars::Null" => DataType::Null,
+                "Polars::Unknown" => DataType::Unknown,
+                dt => {
+                    return Err(RbValueError::new_err(format!(
+                        "{dt} is not a correct polars DataType.",
+                    )))
+                }
+            }
+        } else {
+            match ob.try_convert::<String>()?.as_str() {
+                "u8" => DataType::UInt8,
+                "u16" => DataType::UInt16,
+                "u32" => DataType::UInt32,
+                "u64" => DataType::UInt64,
+                "i8" => DataType::Int8,
+                "i16" => DataType::Int16,
+                "i32" => DataType::Int32,
+                "i64" => DataType::Int64,
+                "str" => DataType::Utf8,
+                "bin" => DataType::Binary,
+                "bool" => DataType::Boolean,
+                "cat" => DataType::Categorical(None),
+                "date" => DataType::Date,
+                "datetime" => DataType::Datetime(TimeUnit::Microseconds, None),
+                "f32" => DataType::Float32,
+                "time" => DataType::Time,
+                "dur" => DataType::Duration(TimeUnit::Microseconds),
+                "f64" => DataType::Float64,
+                // "obj" => DataType::Object(OBJECT_NAME),
+                "list" => DataType::List(Box::new(DataType::Boolean)),
+                "null" => DataType::Null,
+                "unk" => DataType::Unknown,
+                _ => {
+                    return Err(RbValueError::new_err(format!(
+                        "{} is not a supported DataType.",
+                        ob
+                    )))
+                }
             }
         };
         Ok(Wrap(dtype))
@@ -171,6 +287,54 @@ impl<'s> TryConvert for Wrap<AnyValue<'s>> {
     }
 }
 
+impl TryConvert for Wrap<AsofStrategy> {
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        let parsed = match ob.try_convert::<String>()?.as_str() {
+            "backward" => AsofStrategy::Backward,
+            "forward" => AsofStrategy::Forward,
+            v => {
+                return Err(RbValueError::new_err(format!(
+                    "strategy must be one of {{'backward', 'forward'}}, got {}",
+                    v
+                )))
+            }
+        };
+        Ok(Wrap(parsed))
+    }
+}
+
+impl TryConvert for Wrap<InterpolationMethod> {
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        let parsed = match ob.try_convert::<String>()?.as_str() {
+            "linear" => InterpolationMethod::Linear,
+            "nearest" => InterpolationMethod::Nearest,
+            v => {
+                return Err(RbValueError::new_err(format!(
+                    "method must be one of {{'linear', 'nearest'}}, got {v}",
+                )))
+            }
+        };
+        Ok(Wrap(parsed))
+    }
+}
+
+impl TryConvert for Wrap<Option<AvroCompression>> {
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        let parsed = match ob.try_convert::<String>()?.as_str() {
+            "uncompressed" => None,
+            "snappy" => Some(AvroCompression::Snappy),
+            "deflate" => Some(AvroCompression::Deflate),
+            v => {
+                return Err(RbValueError::new_err(format!(
+                    "compression must be one of {{'uncompressed', 'snappy', 'deflate'}}, got {}",
+                    v
+                )))
+            }
+        };
+        Ok(Wrap(parsed))
+    }
+}
+
 impl TryConvert for Wrap<CategoricalOrdering> {
     fn try_convert(ob: Value) -> RbResult<Self> {
         let parsed = match ob.try_convert::<String>()?.as_str() {
@@ -187,6 +351,22 @@ impl TryConvert for Wrap<CategoricalOrdering> {
     }
 }
 
+impl TryConvert for Wrap<StartBy> {
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        let parsed = match ob.try_convert::<String>()?.as_str() {
+            "window" => StartBy::WindowBound,
+            "datapoint" => StartBy::DataPoint,
+            "monday" => StartBy::Monday,
+            v => {
+                return Err(RbValueError::new_err(format!(
+                    "closed must be one of {{'window', 'datapoint', 'monday'}}, got {v}",
+                )))
+            }
+        };
+        Ok(Wrap(parsed))
+    }
+}
+
 impl TryConvert for Wrap<ClosedWindow> {
     fn try_convert(ob: Value) -> RbResult<Self> {
         let parsed = match ob.try_convert::<String>()?.as_str() {
@@ -462,6 +642,32 @@ pub fn parse_parquet_compression(
     Ok(parsed)
 }
 
+impl<'s> TryConvert for Wrap<Row<'s>> {
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        let mut vals: Vec<Wrap<AnyValue<'s>>> = Vec::new();
+        for item in ob.try_convert::<RArray>()?.each() {
+            vals.push(item?.try_convert::<Wrap<AnyValue<'s>>>()?);
+        }
+        let vals: Vec<AnyValue> = unsafe { std::mem::transmute(vals) };
+        Ok(Wrap(Row(vals)))
+    }
+}
+
+impl TryConvert for Wrap<Schema> {
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        let dict = ob.try_convert::<RHash>()?;
+
+        let mut schema = Vec::new();
+        dict.foreach(|key: String, val: Wrap<DataType>| {
+            schema.push(Field::new(&key, val.0));
+            Ok(ForEach::Continue)
+        })
+        .unwrap();
+
+        Ok(Wrap(schema.into_iter().into()))
+    }
+}
+
 #[derive(Clone, Debug)]
 pub struct ObjectValue {
     pub inner: Value,
@@ -503,18 +709,31 @@ impl From<Value> for ObjectValue {
     }
 }
 
+impl TryConvert for ObjectValue {
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        Ok(ObjectValue { inner: ob })
+    }
+}
+
 impl From<&dyn PolarsObjectSafe> for &ObjectValue {
     fn from(val: &dyn PolarsObjectSafe) -> Self {
         unsafe { &*(val as *const dyn PolarsObjectSafe as *const ObjectValue) }
     }
 }
 
+// TODO remove
 impl ObjectValue {
     pub fn to_object(&self) -> Value {
         self.inner
     }
 }
 
+impl From<ObjectValue> for Value {
+    fn from(val: ObjectValue) -> Self {
+        val.inner
+    }
+}
+
 impl Default for ObjectValue {
     fn default() -> Self {
         ObjectValue { inner: *QNIL }

data/ext/polars/src/dataframe.rs

@@ -1,15 +1,22 @@
 use magnus::{r_hash::ForEach, RArray, RHash, RString, Value};
+use polars::frame::NullStrategy;
+use polars::io::avro::AvroCompression;
 use polars::io::mmap::ReaderBytes;
 use polars::io::RowCount;
+use polars::prelude::pivot::{pivot, pivot_stable};
 use polars::prelude::*;
 use std::cell::RefCell;
 use std::io::{BufWriter, Cursor};
 use std::ops::Deref;
 
+use crate::apply::dataframe::{
+    apply_lambda_unknown, apply_lambda_with_bool_out_type, apply_lambda_with_primitive_out_type,
+    apply_lambda_with_utf8_out_type,
+};
 use crate::conversion::*;
 use crate::file::{get_file_like, get_mmap_bytes_reader};
 use crate::series::{to_rbseries_collection, to_series_collection};
-use crate::{series, RbLazyFrame, RbPolarsErr, RbResult, RbSeries};
+use crate::{series, RbExpr, RbLazyFrame, RbPolarsErr, RbResult, RbSeries};
 
 #[magnus::wrap(class = "Polars::RbDataFrame")]
 pub struct RbDataFrame {
@@ -179,6 +186,48 @@ impl RbDataFrame {
         Ok(RbDataFrame::new(df))
     }
 
+    pub fn read_avro(
+        rb_f: Value,
+        columns: Option<Vec<String>>,
+        projection: Option<Vec<usize>>,
+        n_rows: Option<usize>,
+    ) -> RbResult<Self> {
+        use polars::io::avro::AvroReader;
+
+        let file = get_file_like(rb_f, false)?;
+        let df = AvroReader::new(file)
+            .with_projection(projection)
+            .with_columns(columns)
+            .with_n_rows(n_rows)
+            .finish()
+            .map_err(RbPolarsErr::from)?;
+        Ok(RbDataFrame::new(df))
+    }
+
+    pub fn write_avro(
+        &self,
+        rb_f: Value,
+        compression: Wrap<Option<AvroCompression>>,
+    ) -> RbResult<()> {
+        use polars::io::avro::AvroWriter;
+
+        if let Ok(s) = rb_f.try_convert::<String>() {
+            let f = std::fs::File::create(&s).unwrap();
+            AvroWriter::new(f)
+                .with_compression(compression.0)
+                .finish(&mut self.df.borrow_mut())
+                .map_err(RbPolarsErr::from)?;
+        } else {
+            let mut buf = get_file_like(rb_f, true)?;
+            AvroWriter::new(&mut buf)
+                .with_compression(compression.0)
+                .finish(&mut self.df.borrow_mut())
+                .map_err(RbPolarsErr::from)?;
+        }
+
+        Ok(())
+    }
+
     pub fn read_json(rb_f: Value) -> RbResult<Self> {
         // memmap the file first
         let mmap_bytes_r = get_mmap_bytes_reader(rb_f)?;
@@ -238,6 +287,14 @@ impl RbDataFrame {
         Ok(())
     }
 
+    pub fn read_hashes(
+        _dicts: Value,
+        _infer_schema_length: Option<usize>,
+        _schema_overwrite: Option<Wrap<Schema>>,
+    ) -> RbResult<Self> {
+        Err(RbPolarsErr::todo())
+    }
+
     pub fn read_hash(data: RHash) -> RbResult<Self> {
         let mut cols: Vec<Series> = Vec::new();
         data.foreach(|name: String, values: Value| {
@@ -341,7 +398,7 @@ impl RbDataFrame {
                         let obj: Option<&ObjectValue> = s.get_object(idx).map(|any| any.into());
                         obj.unwrap().to_object()
                     }
-                    _ => Wrap(s.get(idx)).into(),
+                    _ => Wrap(s.get(idx).unwrap()).into(),
                 })
                 .collect(),
         )
@@ -364,7 +421,7 @@ impl RbDataFrame {
                                         s.get_object(idx).map(|any| any.into());
                                     obj.unwrap().to_object()
                                 }
-                                _ => Wrap(s.get(idx)).into(),
+                                _ => Wrap(s.get(idx).unwrap()).into(),
                             })
                             .collect(),
                     )
@@ -517,9 +574,8 @@ impl RbDataFrame {
             .collect()
     }
 
-    pub fn n_chunks(&self) -> RbResult<usize> {
-        let n = self.df.borrow().n_chunks().map_err(RbPolarsErr::from)?;
-        Ok(n)
+    pub fn n_chunks(&self) -> usize {
+        self.df.borrow().n_chunks()
     }
 
     pub fn shape(&self) -> (usize, usize) {
@@ -751,6 +807,31 @@ impl RbDataFrame {
         Ok(RbDataFrame::new(df))
     }
 
+    pub fn pivot_expr(
+        &self,
+        values: Vec<String>,
+        index: Vec<String>,
+        columns: Vec<String>,
+        aggregate_expr: &RbExpr,
+        maintain_order: bool,
+        sort_columns: bool,
+    ) -> RbResult<Self> {
+        let fun = match maintain_order {
+            true => pivot_stable,
+            false => pivot,
+        };
+        let df = fun(
+            &self.df.borrow(),
+            values,
+            index,
+            columns,
+            aggregate_expr.inner.clone(),
+            sort_columns,
+        )
+        .map_err(RbPolarsErr::from)?;
+        Ok(RbDataFrame::new(df))
+    }
+
     pub fn partition_by(&self, groups: Vec<String>, stable: bool) -> RbResult<Vec<Self>> {
         let out = if stable {
             self.df.borrow().partition_by_stable(groups)
@@ -870,10 +951,74 @@ impl RbDataFrame {
         df.into()
     }
 
+    pub fn apply(
+        &self,
+        lambda: Value,
+        output_type: Option<Wrap<DataType>>,
+        inference_size: usize,
+    ) -> RbResult<(Value, bool)> {
+        let df = &self.df.borrow();
+
+        let output_type = output_type.map(|dt| dt.0);
+        let out = match output_type {
+            Some(DataType::Int32) => {
+                apply_lambda_with_primitive_out_type::<Int32Type>(df, lambda, 0, None).into_series()
+            }
+            Some(DataType::Int64) => {
+                apply_lambda_with_primitive_out_type::<Int64Type>(df, lambda, 0, None).into_series()
+            }
+            Some(DataType::UInt32) => {
+                apply_lambda_with_primitive_out_type::<UInt32Type>(df, lambda, 0, None)
+                    .into_series()
+            }
+            Some(DataType::UInt64) => {
+                apply_lambda_with_primitive_out_type::<UInt64Type>(df, lambda, 0, None)
+                    .into_series()
+            }
+            Some(DataType::Float32) => {
+                apply_lambda_with_primitive_out_type::<Float32Type>(df, lambda, 0, None)
+                    .into_series()
+            }
+            Some(DataType::Float64) => {
+                apply_lambda_with_primitive_out_type::<Float64Type>(df, lambda, 0, None)
+                    .into_series()
+            }
+            Some(DataType::Boolean) => {
+                apply_lambda_with_bool_out_type(df, lambda, 0, None).into_series()
+            }
+            Some(DataType::Date) => {
+                apply_lambda_with_primitive_out_type::<Int32Type>(df, lambda, 0, None)
+                    .into_date()
+                    .into_series()
+            }
+            Some(DataType::Datetime(tu, tz)) => {
+                apply_lambda_with_primitive_out_type::<Int64Type>(df, lambda, 0, None)
+                    .into_datetime(tu, tz)
+                    .into_series()
+            }
+            Some(DataType::Utf8) => {
+                apply_lambda_with_utf8_out_type(df, lambda, 0, None).into_series()
+            }
+            _ => return apply_lambda_unknown(df, lambda, inference_size),
+        };
+
+        Ok((RbSeries::from(out).into(), false))
+    }
+
     pub fn shrink_to_fit(&self) {
         self.df.borrow_mut().shrink_to_fit();
     }
 
+    pub fn hash_rows(&self, k0: u64, k1: u64, k2: u64, k3: u64) -> RbResult<RbSeries> {
+        let hb = ahash::RandomState::with_seeds(k0, k1, k2, k3);
+        let hash = self
+            .df
+            .borrow_mut()
+            .hash_rows(Some(hb))
+            .map_err(RbPolarsErr::from)?;
+        Ok(hash.into_series().into())
+    }
+
     pub fn transpose(&self, include_header: bool, names: String) -> RbResult<Self> {
         let mut df = self.df.borrow().transpose().map_err(RbPolarsErr::from)?;
         if include_header {

data/ext/polars/src/error.rs

@@ -35,3 +35,11 @@ impl RbValueError {
         Error::new(arg_error(), message)
     }
 }
+
+pub struct ComputeError {}
+
+impl ComputeError {
+    pub fn new_err(message: String) -> Error {
+        Error::runtime_error(message)
+    }
+}

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

@@ -1,7 +1,39 @@
 use magnus::Value;
-use polars::error::PolarsResult;
-use polars::series::Series;
+use polars::prelude::*;
+
+use crate::lazy::dsl::RbExpr;
+use crate::Wrap;
 
 pub fn binary_lambda(_lambda: Value, _a: Series, _b: Series) -> PolarsResult<Series> {
     todo!();
 }
+
+pub fn map_single(
+    rbexpr: &RbExpr,
+    _lambda: Value,
+    output_type: Option<Wrap<DataType>>,
+    agg_list: bool,
+) -> RbExpr {
+    let output_type = output_type.map(|wrap| wrap.0);
+
+    let output_type2 = output_type.clone();
+    let function = move |_s: Series| {
+        let _output_type = output_type2.clone().unwrap_or(DataType::Unknown);
+
+        todo!();
+    };
+
+    let output_map = GetOutput::map_field(move |fld| match output_type {
+        Some(ref dt) => Field::new(fld.name(), dt.clone()),
+        None => {
+            let mut fld = fld.clone();
+            fld.coerce(DataType::Unknown);
+            fld
+        }
+    });
+    if agg_list {
+        rbexpr.clone().inner.map_list(function, output_map).into()
+    } else {
+        rbexpr.clone().inner.map(function, output_map).into()
+    }
+}