feat!: bump polars to unreleased 2023-12-21 version

R/datatype.R

@@ -209,6 +209,8 @@ DataType_constructors = list(
       and_then(DataType$new_struct) |>
       unwrap("in pl$Struct:")
   }
+
+  # TODO: Categorical
 )
 
 #' Create Datetime DataType

src/rust/Cargo.toml

@@ -49,8 +49,8 @@ serde_json = "*"
 smartstring = "1.0.1"
 state = "0.6.0"
 thiserror = "1.0.51"
-polars-core = { git = "https://github.com/pola-rs/polars.git", rev = "b13afbecac039205dacbaca766ecca4bf441b347", default-features = false }
-polars-lazy = { git = "https://github.com/pola-rs/polars.git", rev = "b13afbecac039205dacbaca766ecca4bf441b347", default-features = false }
+polars-core = { git = "https://github.com/pola-rs/polars.git", rev = "f96d2cd5b70ee8d7412971d0d057f3f523a91bb1", default-features = false }
+polars-lazy = { git = "https://github.com/pola-rs/polars.git", rev = "f96d2cd5b70ee8d7412971d0d057f3f523a91bb1", default-features = false }
 either = "1"
 #features copied from node-polars
 
@@ -141,4 +141,4 @@ features = [
   "zip_with",
 ]
 git = "https://github.com/pola-rs/polars.git"
-rev = "b13afbecac039205dacbaca766ecca4bf441b347"
+rev = "f96d2cd5b70ee8d7412971d0d057f3f523a91bb1"

src/rust/src/conversion_r_to_s.rs

@@ -121,7 +121,7 @@ fn recursive_robjname2series_tree(x: &Robj, name: &str) -> pl::PolarsResult<Seri
                     .expect("as_character_factor() enforces same type"),
                 name,
             )
-            .cast(&pl::DataType::Categorical(None))
+            .cast(&pl::DataType::Categorical(None, Default::default()))
             .expect("as matched"),
         )),
 

src/rust/src/conversion_s_to_r.rs

@@ -113,7 +113,7 @@ pub fn pl_series_to_list(
                     .set_class(["rpolars_raw_list", "list"])
                     .expect("this class label is always valid")
             }),
-            Categorical(_) => s
+            Categorical(_, _) => s
                 .categorical()
                 .map(|ca| extendr_api::call!("factor", ca.iter_str().collect_robj()).unwrap()),
             List(_) => {

src/rust/src/lazy/dataframe.rs

@@ -183,43 +183,61 @@ impl RPolarsLazyFrame {
         self.0.clone().last().into()
     }
 
-    fn max(&self) -> Self {
-        self.0.clone().max().into()
+    fn max(&self) -> RResult<Self> {
+        let ldf = self.0.clone();
+        let out = ldf.max().map_err(polars_to_rpolars_err)?;
+        Ok(out.into())
     }
 
-    fn min(&self) -> Self {
-        self.0.clone().min().into()
+    fn min(&self) -> RResult<Self> {
+        let ldf = self.0.clone();
+        let out = ldf.min().map_err(polars_to_rpolars_err)?;
+        Ok(out.into())
     }
 
-    fn mean(&self) -> Self {
-        self.0.clone().mean().into()
+    fn mean(&self) -> RResult<Self> {
+        let ldf = self.0.clone();
+        let out = ldf.mean().map_err(polars_to_rpolars_err)?;
+        Ok(out.into())
     }
 
-    fn median(&self) -> Self {
-        self.0.clone().median().into()
+    fn median(&self) -> RResult<Self> {
+        let ldf = self.0.clone();
+        let out = ldf.median().map_err(polars_to_rpolars_err)?;
+        Ok(out.into())
     }
 
-    fn sum(&self) -> Self {
-        self.0.clone().sum().into()
+    fn sum(&self) -> RResult<Self> {
+        let ldf = self.0.clone();
+        let out = ldf.sum().map_err(polars_to_rpolars_err)?;
+        Ok(out.into())
     }
 
-    pub fn std(&self, ddof: Robj) -> Result<Self, String> {
-        Ok(self.clone().0.std(robj_to!(u8, ddof)?).into())
+    fn std(&self, ddof: Robj) -> RResult<Self> {
+        let ldf = self.0.clone();
+        let out = ldf
+            .std(robj_to!(u8, ddof)?)
+            .map_err(polars_to_rpolars_err)?;
+        Ok(out.into())
     }
 
-    pub fn var(&self, ddof: Robj) -> Result<Self, String> {
-        Ok(self.clone().0.var(robj_to!(u8, ddof)?).into())
+    fn var(&self, ddof: Robj) -> RResult<Self> {
+        let ldf = self.0.clone();
+        let out = ldf
+            .var(robj_to!(u8, ddof)?)
+            .map_err(polars_to_rpolars_err)?;
+        Ok(out.into())
     }
 
-    pub fn quantile(&self, quantile: Robj, interpolation: Robj) -> RResult<Self> {
-        Ok(self
-            .clone()
-            .0
+    fn quantile(&self, quantile: Robj, interpolation: Robj) -> RResult<Self> {
+        let ldf = self.0.clone();
+        let out = ldf
             .quantile(
                 robj_to!(PLExpr, quantile)?,
                 robj_to!(new_quantile_interpolation_option, interpolation)?,
             )
-            .into())
+            .map_err(polars_to_rpolars_err)?;
+        Ok(out.into())
     }
 
     fn shift(&self, periods: Robj) -> Result<Self, String> {