From 977a6d90546e9a0842645bc35f4b8f36f110f887 Mon Sep 17 00:00:00 2001
From: feiyang <feiyangc@outlook.com>
Date: Sat, 18 Jan 2025 13:14:00 +0000
Subject: [PATCH 01/10] impl expr.list().quantile for duration floats,
 decimals, and ints

---
 .../legacy/kernels/rolling/no_nulls/mod.rs    | 18 +++++++++++++
 crates/polars-arrow/src/legacy/prelude.rs     |  2 +-
 .../src/series/implementations/decimal.rs     |  7 +++++
 .../src/series/implementations/duration.rs    |  7 +++++
 .../src/series/implementations/floats.rs      |  7 +++++
 .../src/series/implementations/mod.rs         |  7 +++++
 crates/polars-core/src/series/series_trait.rs |  6 +++++
 .../src/chunked_array/list/dispersion.rs      | 27 +++++++++++++++++++
 .../src/chunked_array/list/namespace.rs       |  5 ++++
 .../polars-plan/src/dsl/function_expr/list.rs |  8 ++++++
 crates/polars-plan/src/dsl/list.rs            |  5 ++++
 11 files changed, 98 insertions(+), 1 deletion(-)

diff --git a/crates/polars-arrow/src/legacy/kernels/rolling/no_nulls/mod.rs b/crates/polars-arrow/src/legacy/kernels/rolling/no_nulls/mod.rs
index 7abe2455e61f..6ac9e462c9f4 100644
--- a/crates/polars-arrow/src/legacy/kernels/rolling/no_nulls/mod.rs
+++ b/crates/polars-arrow/src/legacy/kernels/rolling/no_nulls/mod.rs
@@ -4,6 +4,7 @@ mod quantile;
 mod sum;
 mod variance;
 use std::fmt::Debug;
+use std::hash::{Hash, Hasher};
 
 pub use mean::*;
 pub use min_max::*;
@@ -83,6 +84,23 @@ pub enum QuantileMethod {
     Equiprobable,
 }
 
+
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[derive(Debug, Copy, Clone, PartialEq)]
+pub struct QuantileOptions {
+    pub prob: f64,
+    pub method: QuantileMethod
+}
+
+impl Eq for QuantileOptions {}
+
+impl Hash for QuantileOptions {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.prob.to_bits().hash(state);
+        self.method.hash(state);
+    }
+}
+
 #[deprecated(note = "use QuantileMethod instead")]
 pub type QuantileInterpolOptions = QuantileMethod;
 
diff --git a/crates/polars-arrow/src/legacy/prelude.rs b/crates/polars-arrow/src/legacy/prelude.rs
index 6afeb0c6c9be..4786be70581b 100644
--- a/crates/polars-arrow/src/legacy/prelude.rs
+++ b/crates/polars-arrow/src/legacy/prelude.rs
@@ -2,7 +2,7 @@ use crate::array::{BinaryArray, ListArray, Utf8Array};
 pub use crate::legacy::array::default_arrays::*;
 pub use crate::legacy::array::*;
 pub use crate::legacy::index::*;
-pub use crate::legacy::kernels::rolling::no_nulls::QuantileMethod;
+pub use crate::legacy::kernels::rolling::no_nulls::{QuantileMethod, QuantileOptions};
 pub use crate::legacy::kernels::rolling::{
     RollingFnParams, RollingQuantileParams, RollingVarParams,
 };
diff --git a/crates/polars-core/src/series/implementations/decimal.rs b/crates/polars-core/src/series/implementations/decimal.rs
index 6e477ccf6c3f..4426e82eef50 100644
--- a/crates/polars-core/src/series/implementations/decimal.rs
+++ b/crates/polars-core/src/series/implementations/decimal.rs
@@ -396,6 +396,13 @@ impl SeriesTrait for SeriesWrap<DecimalChunked> {
         self.0.mean().map(|v| v / self.scale_factor() as f64)
     }
 
+    fn quantile(&self, quantile: f64, method: QuantileMethod) -> PolarsResult<Option<f64>> {
+        polars_ensure!((0.0..=1.0).contains(&quantile),
+            ComputeError: "quantile should be between 0.0 and 1.0",
+        );
+        Ok(self.0.quantile(quantile, method).unwrap().map(|v| v as f64))
+    }
+
     fn median(&self) -> Option<f64> {
         self.0.median().map(|v| v / self.scale_factor() as f64)
     }
diff --git a/crates/polars-core/src/series/implementations/duration.rs b/crates/polars-core/src/series/implementations/duration.rs
index 51426f1b94e6..3f3912b4ba60 100644
--- a/crates/polars-core/src/series/implementations/duration.rs
+++ b/crates/polars-core/src/series/implementations/duration.rs
@@ -307,6 +307,13 @@ impl SeriesTrait for SeriesWrap<DurationChunked> {
         self.0.median()
     }
 
+    fn quantile(&self, quantile: f64, method: QuantileMethod) -> PolarsResult<Option<f64>> {
+        polars_ensure!((0.0..=1.0).contains(&quantile),
+            ComputeError: "quantile should be between 0.0 and 1.0",
+        );
+        Ok(self.0.quantile(quantile, method).unwrap().map(|v| v as f64))
+    }
+
     fn std(&self, ddof: u8) -> Option<f64> {
         self.0.std(ddof)
     }
diff --git a/crates/polars-core/src/series/implementations/floats.rs b/crates/polars-core/src/series/implementations/floats.rs
index 9ccbb1d8d958..645723785113 100644
--- a/crates/polars-core/src/series/implementations/floats.rs
+++ b/crates/polars-core/src/series/implementations/floats.rs
@@ -206,6 +206,13 @@ macro_rules! impl_dyn_series {
                 self.0.median().map(|v| v as f64)
             }
 
+            fn quantile(&self, quantile: f64, method: QuantileMethod) -> PolarsResult<Option<f64>> {
+                polars_ensure!((0.0..=1.0).contains(&quantile),
+                    ComputeError: "quantile should be between 0.0 and 1.0",
+                );
+                Ok(self.0.quantile(quantile, method).unwrap().map(|v| v as f64))
+            }
+
             fn std(&self, ddof: u8) -> Option<f64> {
                 self.0.std(ddof)
             }
diff --git a/crates/polars-core/src/series/implementations/mod.rs b/crates/polars-core/src/series/implementations/mod.rs
index 9df0e7695127..48c488d0b7f7 100644
--- a/crates/polars-core/src/series/implementations/mod.rs
+++ b/crates/polars-core/src/series/implementations/mod.rs
@@ -276,6 +276,13 @@ macro_rules! impl_dyn_series {
                 self.0.median()
             }
 
+            fn quantile(&self, quantile: f64, method: QuantileMethod) -> PolarsResult<Option<f64>> {
+                polars_ensure!((0.0..=1.0).contains(&quantile),
+                    ComputeError: "quantile should be between 0.0 and 1.0",
+                );
+                Ok(self.0.quantile(quantile, method).unwrap().map(|v| v as f64))
+            }
+
             fn std(&self, ddof: u8) -> Option<f64> {
                 self.0.std(ddof)
             }
diff --git a/crates/polars-core/src/series/series_trait.rs b/crates/polars-core/src/series/series_trait.rs
index c1b8d3f97764..9c2a319be2a5 100644
--- a/crates/polars-core/src/series/series_trait.rs
+++ b/crates/polars-core/src/series/series_trait.rs
@@ -359,6 +359,12 @@ pub trait SeriesTrait:
         None
     }
 
+    /// Returns the quantile value in the array
+    /// Returns a result<option> because the array is nullable and quantile can OOB.
+    fn quantile(&self, quantile: f64, method: QuantileMethod) -> PolarsResult<Option<f64>> {
+        Ok(None)
+    }
+
     /// Create a new Series filled with values from the given index.
     ///
     /// # Example
diff --git a/crates/polars-ops/src/chunked_array/list/dispersion.rs b/crates/polars-ops/src/chunked_array/list/dispersion.rs
index a4521c71c9d0..015cc5aaed21 100644
--- a/crates/polars-ops/src/chunked_array/list/dispersion.rs
+++ b/crates/polars-ops/src/chunked_array/list/dispersion.rs
@@ -24,6 +24,33 @@ pub(super) fn median_with_nulls(ca: &ListChunked) -> Series {
     }
 }
 
+pub(super) fn quantile_with_nulls(ca: &ListChunked, quantile: f64, method: QuantileMethod) -> Series {
+    match ca.inner_dtype() {
+        DataType::Float32 => {
+            let out: Float32Chunked = ca
+                .apply_amortized_generic(|s| s.and_then(|s| s.as_ref()
+                .quantile(quantile, method).unwrap_or(Some(f64::NAN)).map(|v| v as f32)))
+                .with_name(ca.name().clone());
+            out.into_series()
+        },
+        #[cfg(feature = "dtype-duration")]
+        DataType::Duration(tu) => {
+            let out: Int64Chunked = ca
+                .apply_amortized_generic(|s| s.and_then(|s| s.as_ref()
+                .quantile(quantile, method).unwrap_or(Some(f64::NAN)).map(|v| v as i64)))
+                .with_name(ca.name().clone());
+            out.into_duration(*tu).into_series()
+        },
+        _ => {
+            let out: Float64Chunked = ca
+                .apply_amortized_generic(|s| s.and_then(|s| s.as_ref()
+                .quantile(quantile, method).unwrap_or(Some(f64::NAN))))
+                .with_name(ca.name().clone());
+            out.into_series()
+        },
+    }
+}
+
 pub(super) fn std_with_nulls(ca: &ListChunked, ddof: u8) -> Series {
     match ca.inner_dtype() {
         DataType::Float32 => {
diff --git a/crates/polars-ops/src/chunked_array/list/namespace.rs b/crates/polars-ops/src/chunked_array/list/namespace.rs
index 5c21a7e65ac3..bafbd37f7487 100644
--- a/crates/polars-ops/src/chunked_array/list/namespace.rs
+++ b/crates/polars-ops/src/chunked_array/list/namespace.rs
@@ -223,6 +223,11 @@ pub trait ListNameSpaceImpl: AsList {
         dispersion::median_with_nulls(ca)
     }
 
+    fn lst_quantile(&self, quantile: f64, method: QuantileMethod) -> Series {
+        let ca = self.as_list();
+        dispersion::quantile_with_nulls(ca, quantile, method)
+    }
+
     fn lst_std(&self, ddof: u8) -> Series {
         let ca = self.as_list();
         dispersion::std_with_nulls(ca, ddof)
diff --git a/crates/polars-plan/src/dsl/function_expr/list.rs b/crates/polars-plan/src/dsl/function_expr/list.rs
index e6b1468f4f82..1618916b1709 100644
--- a/crates/polars-plan/src/dsl/function_expr/list.rs
+++ b/crates/polars-plan/src/dsl/function_expr/list.rs
@@ -34,6 +34,7 @@ pub enum ListFunction {
     Min,
     Mean,
     Median,
+    Quantile(QuantileOptions),
     Std(u8),
     Var(u8),
     ArgMin,
@@ -85,6 +86,7 @@ impl ListFunction {
             Max => mapper.map_to_list_and_array_inner_dtype(),
             Mean => mapper.with_dtype(DataType::Float64),
             Median => mapper.map_to_float_dtype(),
+            Quantile(_) => mapper.map_to_float_dtype(),
             Std(_) => mapper.map_to_float_dtype(), // Need to also have this sometimes marked as float32 or duration..
             Var(_) => mapper.map_to_float_dtype(),
             ArgMin => mapper.with_dtype(IDX_DTYPE),
@@ -152,6 +154,7 @@ impl Display for ListFunction {
             Max => "max",
             Mean => "mean",
             Median => "median",
+            Quantile(_) => "quantile",
             Std(_) => "std",
             Var(_) => "var",
             ArgMin => "arg_min",
@@ -222,6 +225,7 @@ impl From<ListFunction> for SpecialEq<Arc<dyn ColumnsUdf>> {
             Min => map!(min),
             Mean => map!(mean),
             Median => map!(median),
+            Quantile(options) => map!(quantile, options.prob, options.method),
             Std(ddof) => map!(std, ddof),
             Var(ddof) => map!(var, ddof),
             ArgMin => map!(arg_min),
@@ -571,6 +575,10 @@ pub(super) fn median(s: &Column) -> PolarsResult<Column> {
     Ok(s.list()?.lst_median().into())
 }
 
+pub(super) fn quantile(s: &Column, quantile: f64, method: QuantileMethod) -> PolarsResult<Column> {
+    Ok(s.list()?.lst_quantile(quantile, method).into())
+}
+
 pub(super) fn std(s: &Column, ddof: u8) -> PolarsResult<Column> {
     Ok(s.list()?.lst_std(ddof).into())
 }
diff --git a/crates/polars-plan/src/dsl/list.rs b/crates/polars-plan/src/dsl/list.rs
index d5c2622b5afb..2ea9c7fd0404 100644
--- a/crates/polars-plan/src/dsl/list.rs
+++ b/crates/polars-plan/src/dsl/list.rs
@@ -112,6 +112,11 @@ impl ListNameSpace {
             .map_private(FunctionExpr::ListExpr(ListFunction::Median))
     }
 
+    pub fn quantile(self, prob: f64, method: QuantileMethod) -> Expr {
+        self.0
+            .map_private(FunctionExpr::ListExpr(ListFunction::Quantile(QuantileOptions{prob, method})))
+    }
+
     pub fn std(self, ddof: u8) -> Expr {
         self.0
             .map_private(FunctionExpr::ListExpr(ListFunction::Std(ddof)))

From 021b0d9a024b9a8041e9d5a02c698253d8c41aec Mon Sep 17 00:00:00 2001
From: feiyang <feiyangc@outlook.com>
Date: Sat, 18 Jan 2025 13:30:35 +0000
Subject: [PATCH 02/10] add wrapper on py side

---
 crates/polars-python/src/expr/list.rs | 9 +++++++++
 py-polars/polars/_typing.py           | 3 +++
 py-polars/polars/expr/list.py         | 5 +++++
 3 files changed, 17 insertions(+)

diff --git a/crates/polars-python/src/expr/list.rs b/crates/polars-python/src/expr/list.rs
index b8f10fc60c3e..fb7acd006958 100644
--- a/crates/polars-python/src/expr/list.rs
+++ b/crates/polars-python/src/expr/list.rs
@@ -89,6 +89,15 @@ impl PyExpr {
             .into()
     }
 
+    fn list_quantile(&self, quantile: PyExpr, method: Wrap<QuantileMethod>) -> Self {
+        self.inner
+            .clone()
+            .list()
+            .quantile(quantile.inner, method.0)
+            .with_fmt("list.quantile")
+            .into()
+    }
+
     fn list_std(&self, ddof: u8) -> Self {
         self.inner
             .clone()
diff --git a/py-polars/polars/_typing.py b/py-polars/polars/_typing.py
index b362e2116502..c67da8259f0f 100644
--- a/py-polars/polars/_typing.py
+++ b/py-polars/polars/_typing.py
@@ -165,6 +165,9 @@ def __arrow_c_stream__(self, requested_schema: object | None = None) -> object:
 RollingInterpolationMethod: TypeAlias = Literal[
     "nearest", "higher", "lower", "midpoint", "linear"
 ]  # QuantileInterpolOptions
+QuantileMethod: TypeAlias = Literal[
+    "lower", "higher", "nearest", "linear", "midpoint", "equiprobable",
+]
 ListToStructWidthStrategy: TypeAlias = Literal["first_non_null", "max_width"]
 
 # The following have no equivalent on the Rust side
diff --git a/py-polars/polars/expr/list.py b/py-polars/polars/expr/list.py
index de98cf5869ce..499b198563dd 100644
--- a/py-polars/polars/expr/list.py
+++ b/py-polars/polars/expr/list.py
@@ -19,6 +19,7 @@
         IntoExpr,
         IntoExprColumn,
         ListToStructWidthStrategy,
+        QuantileMethod,
         NullBehavior,
     )
 
@@ -294,6 +295,10 @@ def median(self) -> Expr:
         """
         return wrap_expr(self._pyexpr.list_median())
 
+    def quantile(self, quantile: float, method: QuantileMethod) -> Expr:
+        """Compute the specified quantile value of the lists in the array."""
+        return wrap_expr(self._pyexpr.list_quantile(quantile, method))
+
     def std(self, ddof: int = 1) -> Expr:
         """
         Compute the std value of the lists in the array.

From 2e5f7c18519f1758e8d85e9366f8b0571b32369e Mon Sep 17 00:00:00 2001
From: feiyang <feiyangc@outlook.com>
Date: Sat, 18 Jan 2025 14:07:30 +0000
Subject: [PATCH 03/10] conform to linter

---
 crates/polars-core/src/series/series_trait.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/polars-core/src/series/series_trait.rs b/crates/polars-core/src/series/series_trait.rs
index 9c2a319be2a5..d2c5aad6f5ff 100644
--- a/crates/polars-core/src/series/series_trait.rs
+++ b/crates/polars-core/src/series/series_trait.rs
@@ -361,7 +361,7 @@ pub trait SeriesTrait:
 
     /// Returns the quantile value in the array
     /// Returns a result<option> because the array is nullable and quantile can OOB.
-    fn quantile(&self, quantile: f64, method: QuantileMethod) -> PolarsResult<Option<f64>> {
+    fn quantile(&self, _quantile: f64, _method: QuantileMethod) -> PolarsResult<Option<f64>> {
         Ok(None)
     }
 

From 74267008b6397d968a638a2f97c666bed92c2739 Mon Sep 17 00:00:00 2001
From: feiyang <feiyangc@outlook.com>
Date: Sat, 18 Jan 2025 14:29:02 +0000
Subject: [PATCH 04/10] rustdoc ruff

---
 crates/polars-core/src/series/implementations/decimal.rs  | 2 +-
 crates/polars-core/src/series/implementations/duration.rs | 2 +-
 crates/polars-core/src/series/series_trait.rs             | 2 +-
 py-polars/polars/expr/list.py                             | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/crates/polars-core/src/series/implementations/decimal.rs b/crates/polars-core/src/series/implementations/decimal.rs
index 4426e82eef50..53589ea01a0d 100644
--- a/crates/polars-core/src/series/implementations/decimal.rs
+++ b/crates/polars-core/src/series/implementations/decimal.rs
@@ -400,7 +400,7 @@ impl SeriesTrait for SeriesWrap<DecimalChunked> {
         polars_ensure!((0.0..=1.0).contains(&quantile),
             ComputeError: "quantile should be between 0.0 and 1.0",
         );
-        Ok(self.0.quantile(quantile, method).unwrap().map(|v| v as f64))
+        Ok(self.0.quantile(quantile, method).unwrap())
     }
 
     fn median(&self) -> Option<f64> {
diff --git a/crates/polars-core/src/series/implementations/duration.rs b/crates/polars-core/src/series/implementations/duration.rs
index 3f3912b4ba60..296f58d828aa 100644
--- a/crates/polars-core/src/series/implementations/duration.rs
+++ b/crates/polars-core/src/series/implementations/duration.rs
@@ -311,7 +311,7 @@ impl SeriesTrait for SeriesWrap<DurationChunked> {
         polars_ensure!((0.0..=1.0).contains(&quantile),
             ComputeError: "quantile should be between 0.0 and 1.0",
         );
-        Ok(self.0.quantile(quantile, method).unwrap().map(|v| v as f64))
+        Ok(self.0.quantile(quantile, method).unwrap())
     }
 
     fn std(&self, ddof: u8) -> Option<f64> {
diff --git a/crates/polars-core/src/series/series_trait.rs b/crates/polars-core/src/series/series_trait.rs
index d2c5aad6f5ff..3ca36f244ce1 100644
--- a/crates/polars-core/src/series/series_trait.rs
+++ b/crates/polars-core/src/series/series_trait.rs
@@ -360,7 +360,7 @@ pub trait SeriesTrait:
     }
 
     /// Returns the quantile value in the array
-    /// Returns a result<option> because the array is nullable and quantile can OOB.
+    /// Returns a result of option because the array is nullable and quantile can OOB.
     fn quantile(&self, _quantile: f64, _method: QuantileMethod) -> PolarsResult<Option<f64>> {
         Ok(None)
     }
diff --git a/py-polars/polars/expr/list.py b/py-polars/polars/expr/list.py
index 499b198563dd..11b4d645ef2c 100644
--- a/py-polars/polars/expr/list.py
+++ b/py-polars/polars/expr/list.py
@@ -19,8 +19,8 @@
         IntoExpr,
         IntoExprColumn,
         ListToStructWidthStrategy,
-        QuantileMethod,
         NullBehavior,
+        QuantileMethod,
     )
 
 

From 2520d35b3651642bc3380e2d1d99477f894c9d13 Mon Sep 17 00:00:00 2001
From: feiyang <feiyangc@outlook.com>
Date: Sat, 18 Jan 2025 14:37:53 +0000
Subject: [PATCH 05/10] type fixes

---
 crates/polars-python/src/expr/list.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/polars-python/src/expr/list.rs b/crates/polars-python/src/expr/list.rs
index fb7acd006958..d1dcac74227e 100644
--- a/crates/polars-python/src/expr/list.rs
+++ b/crates/polars-python/src/expr/list.rs
@@ -89,11 +89,11 @@ impl PyExpr {
             .into()
     }
 
-    fn list_quantile(&self, quantile: PyExpr, method: Wrap<QuantileMethod>) -> Self {
+    fn list_quantile(&self, quantile: f64, method: Wrap<QuantileMethod>) -> Self {
         self.inner
             .clone()
             .list()
-            .quantile(quantile.inner, method.0)
+            .quantile(quantile, method.0)
             .with_fmt("list.quantile")
             .into()
     }

From dbcf705e4c7ad65bd12efa0dc483a9bfd3dc0b94 Mon Sep 17 00:00:00 2001
From: feiyang <feiyangc@outlook.com>
Date: Sat, 18 Jan 2025 14:45:53 +0000
Subject: [PATCH 06/10] add doctest

---
 py-polars/polars/expr/list.py | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)

diff --git a/py-polars/polars/expr/list.py b/py-polars/polars/expr/list.py
index 11b4d645ef2c..5d5d35a945fc 100644
--- a/py-polars/polars/expr/list.py
+++ b/py-polars/polars/expr/list.py
@@ -296,7 +296,24 @@ def median(self) -> Expr:
         return wrap_expr(self._pyexpr.list_median())
 
     def quantile(self, quantile: float, method: QuantileMethod) -> Expr:
-        """Compute the specified quantile value of the lists in the array."""
+        """
+        Compute the specified quantile value of the lists in the array.
+
+        Examples
+        --------
+        >>> df = pl.DataFrame({"values": [[-1, 0, 1], [1, 10]]})
+        >>> expr = pl.col("values").list.quantile(0.1, "linear").alias("10percent")
+        >>> df.with_columns(expr)
+        shape: (2, 2)
+        ┌────────────┬───────────┐
+        │ values     ┆ 10percent │
+        │ ---        ┆ ---       │
+        │ list[i64]  ┆ f64       │
+        ╞════════════╪═══════════╡
+        │ [-1, 0, 1] ┆ -0.8      │
+        │ [1, 10]    ┆ 1.9       │
+        └────────────┴───────────┘
+        """
         return wrap_expr(self._pyexpr.list_quantile(quantile, method))
 
     def std(self, ddof: int = 1) -> Expr:

From 1eb42c8661c29563b5678f23b28f8e68ec963b43 Mon Sep 17 00:00:00 2001
From: feiyang <feiyangc@outlook.com>
Date: Sat, 18 Jan 2025 14:54:01 +0000
Subject: [PATCH 07/10] add list quantile test

---
 py-polars/tests/unit/datatypes/test_list.py | 54 +++++++++++++++++++++
 1 file changed, 54 insertions(+)

diff --git a/py-polars/tests/unit/datatypes/test_list.py b/py-polars/tests/unit/datatypes/test_list.py
index 53c401ec110e..d46e4ef07a41 100644
--- a/py-polars/tests/unit/datatypes/test_list.py
+++ b/py-polars/tests/unit/datatypes/test_list.py
@@ -752,6 +752,60 @@ def test_list_median(data_dispersion: pl.DataFrame) -> None:
     assert_frame_equal(result, expected)
 
 
+def test_list_quantile(data_dispersion: pl.DataFrame) -> None:
+    df = data_dispersion
+
+    result = df.select(
+        pl.col("int").list.quantile(0.3, "linear").name.suffix("_median"),
+        pl.col("float").list.quantile(0.3, "linear").name.suffix("_median"),
+        pl.col("duration").list.quantile(0.3, "linear").name.suffix("_median"),
+    )
+
+    expected = pl.DataFrame(
+        [
+            pl.Series("int_median", [2.2], dtype=pl.Float64),
+            pl.Series("float_median", [2.2], dtype=pl.Float64),
+            pl.Series(
+                "duration_median",
+                [timedelta(microseconds=2200)],
+                dtype=pl.Duration(time_unit="us"),
+            ),
+        ]
+    )
+
+    assert_frame_equal(result, expected)
+
+def test_list_quantile_extremities(data_dispersion: pl.DataFrame) -> None:
+    df = data_dispersion
+    assert_frame_equal(
+        df.select(
+            pl.col(col).list.quantile(0.0, "linear") for col in ["int", "float", "duration"]
+        ),
+        df.select(
+            pl.col(col).list.min() for col in ["int", "float", "duration"]
+        ),
+        check_dtypes=False
+    )
+    assert_frame_equal(
+        df.select(
+            pl.col(col).list.quantile(1.0, "linear") for col in ["int", "float", "duration"]
+        ),
+        df.select(
+            pl.col(col).list.max() for col in ["int", "float", "duration"]
+        ),
+        check_dtypes=False
+    )
+    assert_frame_equal(
+        df.select(
+            pl.col(col).list.quantile(0.5, "linear") for col in ["int", "float", "duration"]
+        ),
+        df.select(
+            pl.col(col).list.median() for col in ["int", "float", "duration"]
+        ),
+        check_dtypes=False
+    )
+
+
 def test_list_gather_null_struct_14927() -> None:
     df = pl.DataFrame(
         [

From 39037d896d81bf3714a7d823f07493e05065d94e Mon Sep 17 00:00:00 2001
From: feiyang <feiyangc@outlook.com>
Date: Sat, 18 Jan 2025 14:59:13 +0000
Subject: [PATCH 08/10] ruff

---
 py-polars/tests/unit/datatypes/test_list.py | 28 ++++++++++-----------
 1 file changed, 13 insertions(+), 15 deletions(-)

diff --git a/py-polars/tests/unit/datatypes/test_list.py b/py-polars/tests/unit/datatypes/test_list.py
index d46e4ef07a41..12f39b2e14b3 100644
--- a/py-polars/tests/unit/datatypes/test_list.py
+++ b/py-polars/tests/unit/datatypes/test_list.py
@@ -775,34 +775,32 @@ def test_list_quantile(data_dispersion: pl.DataFrame) -> None:
 
     assert_frame_equal(result, expected)
 
+
 def test_list_quantile_extremities(data_dispersion: pl.DataFrame) -> None:
     df = data_dispersion
     assert_frame_equal(
         df.select(
-            pl.col(col).list.quantile(0.0, "linear") for col in ["int", "float", "duration"]
-        ),
-        df.select(
-            pl.col(col).list.min() for col in ["int", "float", "duration"]
+            pl.col(col).list.quantile(0.0, "linear")
+            for col in ["int", "float", "duration"]
         ),
-        check_dtypes=False
+        df.select(pl.col(col).list.min() for col in ["int", "float", "duration"]),
+        check_dtypes=False,
     )
     assert_frame_equal(
         df.select(
-            pl.col(col).list.quantile(1.0, "linear") for col in ["int", "float", "duration"]
+            pl.col(col).list.quantile(1.0, "linear")
+            for col in ["int", "float", "duration"]
         ),
-        df.select(
-            pl.col(col).list.max() for col in ["int", "float", "duration"]
-        ),
-        check_dtypes=False
+        df.select(pl.col(col).list.max() for col in ["int", "float", "duration"]),
+        check_dtypes=False,
     )
     assert_frame_equal(
         df.select(
-            pl.col(col).list.quantile(0.5, "linear") for col in ["int", "float", "duration"]
-        ),
-        df.select(
-            pl.col(col).list.median() for col in ["int", "float", "duration"]
+            pl.col(col).list.quantile(0.5, "linear")
+            for col in ["int", "float", "duration"]
         ),
-        check_dtypes=False
+        df.select(pl.col(col).list.median() for col in ["int", "float", "duration"]),
+        check_dtypes=False,
     )
 
 

From 9f4484561b375e893a6b52af420c54d1060445cc Mon Sep 17 00:00:00 2001
From: feiyang <feiyangc@outlook.com>
Date: Sat, 18 Jan 2025 14:59:38 +0000
Subject: [PATCH 09/10] ruff

---
 py-polars/polars/_typing.py | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/py-polars/polars/_typing.py b/py-polars/polars/_typing.py
index c67da8259f0f..5bd2abfa99f7 100644
--- a/py-polars/polars/_typing.py
+++ b/py-polars/polars/_typing.py
@@ -166,7 +166,12 @@ def __arrow_c_stream__(self, requested_schema: object | None = None) -> object:
     "nearest", "higher", "lower", "midpoint", "linear"
 ]  # QuantileInterpolOptions
 QuantileMethod: TypeAlias = Literal[
-    "lower", "higher", "nearest", "linear", "midpoint", "equiprobable",
+    "lower",
+    "higher",
+    "nearest",
+    "linear",
+    "midpoint",
+    "equiprobable",
 ]
 ListToStructWidthStrategy: TypeAlias = Literal["first_non_null", "max_width"]
 

From 481b8923e17606449f15a7f5c0a9f1a624e6d251 Mon Sep 17 00:00:00 2001
From: feiyang <feiyangc@outlook.com>
Date: Sat, 18 Jan 2025 15:03:47 +0000
Subject: [PATCH 10/10] cargo fmt all

---
 .../legacy/kernels/rolling/no_nulls/mod.rs    |  3 +-
 .../src/chunked_array/list/dispersion.rs      | 35 +++++++++++++++----
 crates/polars-plan/src/dsl/list.rs            |  4 ++-
 3 files changed, 32 insertions(+), 10 deletions(-)

diff --git a/crates/polars-arrow/src/legacy/kernels/rolling/no_nulls/mod.rs b/crates/polars-arrow/src/legacy/kernels/rolling/no_nulls/mod.rs
index 6ac9e462c9f4..b5ff7f7c144f 100644
--- a/crates/polars-arrow/src/legacy/kernels/rolling/no_nulls/mod.rs
+++ b/crates/polars-arrow/src/legacy/kernels/rolling/no_nulls/mod.rs
@@ -84,12 +84,11 @@ pub enum QuantileMethod {
     Equiprobable,
 }
 
-
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[derive(Debug, Copy, Clone, PartialEq)]
 pub struct QuantileOptions {
     pub prob: f64,
-    pub method: QuantileMethod
+    pub method: QuantileMethod,
 }
 
 impl Eq for QuantileOptions {}
diff --git a/crates/polars-ops/src/chunked_array/list/dispersion.rs b/crates/polars-ops/src/chunked_array/list/dispersion.rs
index 015cc5aaed21..99be35eb58ab 100644
--- a/crates/polars-ops/src/chunked_array/list/dispersion.rs
+++ b/crates/polars-ops/src/chunked_array/list/dispersion.rs
@@ -24,27 +24,48 @@ pub(super) fn median_with_nulls(ca: &ListChunked) -> Series {
     }
 }
 
-pub(super) fn quantile_with_nulls(ca: &ListChunked, quantile: f64, method: QuantileMethod) -> Series {
+pub(super) fn quantile_with_nulls(
+    ca: &ListChunked,
+    quantile: f64,
+    method: QuantileMethod,
+) -> Series {
     match ca.inner_dtype() {
         DataType::Float32 => {
             let out: Float32Chunked = ca
-                .apply_amortized_generic(|s| s.and_then(|s| s.as_ref()
-                .quantile(quantile, method).unwrap_or(Some(f64::NAN)).map(|v| v as f32)))
+                .apply_amortized_generic(|s| {
+                    s.and_then(|s| {
+                        s.as_ref()
+                            .quantile(quantile, method)
+                            .unwrap_or(Some(f64::NAN))
+                            .map(|v| v as f32)
+                    })
+                })
                 .with_name(ca.name().clone());
             out.into_series()
         },
         #[cfg(feature = "dtype-duration")]
         DataType::Duration(tu) => {
             let out: Int64Chunked = ca
-                .apply_amortized_generic(|s| s.and_then(|s| s.as_ref()
-                .quantile(quantile, method).unwrap_or(Some(f64::NAN)).map(|v| v as i64)))
+                .apply_amortized_generic(|s| {
+                    s.and_then(|s| {
+                        s.as_ref()
+                            .quantile(quantile, method)
+                            .unwrap_or(Some(f64::NAN))
+                            .map(|v| v as i64)
+                    })
+                })
                 .with_name(ca.name().clone());
             out.into_duration(*tu).into_series()
         },
         _ => {
             let out: Float64Chunked = ca
-                .apply_amortized_generic(|s| s.and_then(|s| s.as_ref()
-                .quantile(quantile, method).unwrap_or(Some(f64::NAN))))
+                .apply_amortized_generic(|s| {
+                    s.and_then(|s| {
+                        s.as_ref()
+                            .quantile(quantile, method)
+                            .unwrap_or(Some(f64::NAN))
+                    })
+                })
                 .with_name(ca.name().clone());
             out.into_series()
         },
diff --git a/crates/polars-plan/src/dsl/list.rs b/crates/polars-plan/src/dsl/list.rs
index 2ea9c7fd0404..8fb4d2b39e84 100644
--- a/crates/polars-plan/src/dsl/list.rs
+++ b/crates/polars-plan/src/dsl/list.rs
@@ -114,7 +114,9 @@ impl ListNameSpace {
 
     pub fn quantile(self, prob: f64, method: QuantileMethod) -> Expr {
         self.0
-            .map_private(FunctionExpr::ListExpr(ListFunction::Quantile(QuantileOptions{prob, method})))
+            .map_private(FunctionExpr::ListExpr(ListFunction::Quantile(
+                QuantileOptions { prob, method },
+            )))
     }
 
     pub fn std(self, ddof: u8) -> Expr {