polars-df 0.10.0-aarch64-linux → 0.12.0-aarch64-linux

data/lib/polars/expr.rb

@@ -82,8 +82,8 @@ module Polars
     #
     # @return [Expr]
     def **(power)
-      exponent = Utils.expr_to_lit_or_expr(power)
-      _from_rbexpr(_rbexpr.pow(exponent._rbexpr))
+      exponent = Utils.parse_into_expression(power)
+      _from_rbexpr(_rbexpr.pow(exponent))
     end
 
     # Greater than or equal.
@@ -811,8 +811,8 @@ module Polars
     #   # │ 10  ┆ 4    │
     #   # └─────┴──────┘
     def append(other, upcast: true)
-      other = Utils.expr_to_lit_or_expr(other)
-      _from_rbexpr(_rbexpr.append(other._rbexpr, upcast))
+      other = Utils.parse_into_expression(other)
+      _from_rbexpr(_rbexpr.append(other, upcast))
     end
 
     # Create a single chunk of memory for this Series.
@@ -1165,8 +1165,8 @@ module Polars
     #   # │ 44  │
     #   # └─────┘
     def dot(other)
-      other = Utils.expr_to_lit_or_expr(other, str_to_lit: false)
-      _from_rbexpr(_rbexpr.dot(other._rbexpr))
+      other = Utils.parse_into_expression(other, str_as_lit: false)
+      _from_rbexpr(_rbexpr.dot(other))
     end
 
     # Compute the most occurring value(s).
@@ -1252,12 +1252,12 @@ module Polars
     #   df = Polars::DataFrame.new(
     #     {
     #       "group" => [
-    #           "one",
-    #           "one",
-    #           "one",
-    #           "two",
-    #           "two",
-    #           "two"
+    #         "one",
+    #         "one",
+    #         "one",
+    #         "two",
+    #         "two",
+    #         "two"
     #       ],
     #       "value" => [1, 98, 2, 3, 99, 4]
     #     }
@@ -1346,7 +1346,7 @@ module Polars
     #   # │ 2     ┆ 98       │
     #   # └───────┴──────────┘
     def top_k(k: 5)
-      k = Utils.parse_as_expression(k)
+      k = Utils.parse_into_expression(k)
       _from_rbexpr(_rbexpr.top_k(k))
     end
 
@@ -1385,7 +1385,7 @@ module Polars
     #   # │ 2     ┆ 98       │
     #   # └───────┴──────────┘
     def bottom_k(k: 5)
-      k = Utils.parse_as_expression(k)
+      k = Utils.parse_into_expression(k)
       _from_rbexpr(_rbexpr.bottom_k(k))
     end
 
@@ -1498,8 +1498,8 @@ module Polars
     #   # │ 0    ┆ 2     ┆ 4   │
     #   # └──────┴───────┴─────┘
     def search_sorted(element, side: "any")
-      element = Utils.expr_to_lit_or_expr(element, str_to_lit: false)
-      _from_rbexpr(_rbexpr.search_sorted(element._rbexpr, side))
+      element = Utils.parse_into_expression(element, str_as_lit: false)
+      _from_rbexpr(_rbexpr.search_sorted(element, side))
     end
 
     # Sort this column by the ordering of another column, or multiple other columns.
@@ -1545,13 +1545,14 @@ module Polars
     #   # │ two   │
     #   # └───────┘
     def sort_by(by, *more_by, reverse: false, nulls_last: false, multithreaded: true, maintain_order: false)
-      by = Utils.parse_as_list_of_expressions(by, *more_by)
-      if !reverse.is_a?(::Array)
-        reverse = [reverse]
-      elsif by.length != reverse.length
-        raise ArgumentError, "the length of `reverse` (#{reverse.length}) does not match the length of `by` (#{by.length})"
-      end
-      _from_rbexpr(_rbexpr.sort_by(by, reverse, nulls_last, multithreaded, maintain_order))
+      by = Utils.parse_into_list_of_expressions(by, *more_by)
+      reverse = Utils.extend_bool(reverse, by.length, "reverse", "by")
+      nulls_last = Utils.extend_bool(nulls_last, by.length, "nulls_last", "by")
+      _from_rbexpr(
+        _rbexpr.sort_by(
+          by, reverse, nulls_last, multithreaded, maintain_order
+        )
+      )
     end
 
     # Take values by index.
@@ -1588,14 +1589,51 @@ module Polars
     #   # └───────┴───────────┘
     def gather(indices)
       if indices.is_a?(::Array)
-        indices_lit = Polars.lit(Series.new("", indices, dtype: :u32))
+        indices_lit = Polars.lit(Series.new("", indices, dtype: :u32))._rbexpr
       else
-        indices_lit = Utils.expr_to_lit_or_expr(indices, str_to_lit: false)
+        indices_lit = Utils.parse_into_expression(indices, str_as_lit: false)
       end
-      _from_rbexpr(_rbexpr.gather(indices_lit._rbexpr))
+      _from_rbexpr(_rbexpr.gather(indices_lit))
     end
     alias_method :take, :gather
 
+    # Return a single value by index.
+    #
+    # @param index [Object]
+    #   An expression that leads to a UInt32 index.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "group" => [
+    #         "one",
+    #         "one",
+    #         "one",
+    #         "two",
+    #         "two",
+    #         "two"
+    #       ],
+    #       "value" => [1, 98, 2, 3, 99, 4]
+    #     }
+    #   )
+    #   df.group_by("group", maintain_order: true).agg(Polars.col("value").get(1))
+    #   # =>
+    #   # shape: (2, 2)
+    #   # ┌───────┬───────┐
+    #   # │ group ┆ value │
+    #   # │ ---   ┆ ---   │
+    #   # │ str   ┆ i64   │
+    #   # ╞═══════╪═══════╡
+    #   # │ one   ┆ 98    │
+    #   # │ two   ┆ 99    │
+    #   # └───────┴───────┘
+    def get(index)
+      index_lit = Utils.parse_into_expression(index)
+      _from_rbexpr(_rbexpr.get(index_lit))
+    end
+
     # Shift the values by a given period.
     #
     # @param n [Integer]
@@ -1622,9 +1660,9 @@ module Polars
     #   # └──────┘
     def shift(n = 1, fill_value: nil)
       if !fill_value.nil?
-        fill_value = Utils.parse_as_expression(fill_value, str_as_lit: true)
+        fill_value = Utils.parse_into_expression(fill_value, str_as_lit: true)
       end
-      n = Utils.parse_as_expression(n)
+      n = Utils.parse_into_expression(n)
       _from_rbexpr(_rbexpr.shift(n, fill_value))
     end
 
@@ -1727,8 +1765,8 @@ module Polars
       end
 
       if !value.nil?
-        value = Utils.expr_to_lit_or_expr(value, str_to_lit: true)
-        _from_rbexpr(_rbexpr.fill_null(value._rbexpr))
+        value = Utils.parse_into_expression(value, str_as_lit: true)
+        _from_rbexpr(_rbexpr.fill_null(value))
       else
         _from_rbexpr(_rbexpr.fill_null_with_strategy(strategy, limit))
       end
@@ -1758,8 +1796,8 @@ module Polars
     #   # │ zero ┆ 6.0  │
     #   # └──────┴──────┘
     def fill_nan(fill_value)
-      fill_value = Utils.expr_to_lit_or_expr(fill_value, str_to_lit: true)
-      _from_rbexpr(_rbexpr.fill_nan(fill_value._rbexpr))
+      fill_value = Utils.parse_into_expression(fill_value, str_as_lit: true)
+      _from_rbexpr(_rbexpr.fill_nan(fill_value))
     end
 
     # Fill missing values with the latest seen values.
@@ -2275,7 +2313,7 @@ module Polars
     #   # │ 4      │
     #   # └────────┘
     def over(expr)
-      rbexprs = Utils.selection_to_rbexpr_list(expr)
+      rbexprs = Utils.parse_into_list_of_expressions(expr)
       _from_rbexpr(_rbexpr.over(rbexprs))
     end
 
@@ -2470,8 +2508,8 @@ module Polars
     #   # │ 1.5 │
     #   # └─────┘
     def quantile(quantile, interpolation: "nearest")
-      quantile = Utils.expr_to_lit_or_expr(quantile, str_to_lit: false)
-      _from_rbexpr(_rbexpr.quantile(quantile._rbexpr, interpolation))
+      quantile = Utils.parse_into_expression(quantile, str_as_lit: false)
+      _from_rbexpr(_rbexpr.quantile(quantile, interpolation))
     end
 
     # Bin continuous values into discrete categories.
@@ -2515,17 +2553,17 @@ module Polars
     #   ).unnest("cut")
     #   # =>
     #   # shape: (5, 3)
-    #   # ┌─────┬──────┬────────────┐
-    #   # │ foo ┆ brk  ┆ foo_bin    │
-    #   # │ --- ┆ ---  ┆ ---        │
-    #   # │ i64 ┆ f64  ┆ cat        │
-    #   # ╞═════╪══════╪════════════╡
-    #   # │ -2  ┆ -1.0 ┆ (-inf, -1] │
-    #   # │ -1  ┆ -1.0 ┆ (-inf, -1] │
-    #   # │ 0   ┆ 1.0  ┆ (-1, 1]    │
-    #   # │ 1   ┆ 1.0  ┆ (-1, 1]    │
-    #   # │ 2   ┆ inf  ┆ (1, inf]   │
-    #   # └─────┴──────┴────────────┘
+    #   # ┌─────┬────────────┬────────────┐
+    #   # │ foo ┆ breakpoint ┆ category   │
+    #   # │ --- ┆ ---        ┆ ---        │
+    #   # │ i64 ┆ f64        ┆ cat        │
+    #   # ╞═════╪════════════╪════════════╡
+    #   # │ -2  ┆ -1.0       ┆ (-inf, -1] │
+    #   # │ -1  ┆ -1.0       ┆ (-inf, -1] │
+    #   # │ 0   ┆ 1.0        ┆ (-1, 1]    │
+    #   # │ 1   ┆ 1.0        ┆ (-1, 1]    │
+    #   # │ 2   ┆ inf        ┆ (1, inf]   │
+    #   # └─────┴────────────┴────────────┘
     def cut(breaks, labels: nil, left_closed: false, include_breaks: false)
       _from_rbexpr(_rbexpr.cut(breaks, labels, left_closed, include_breaks))
     end
@@ -2596,17 +2634,17 @@ module Polars
     #   ).unnest("qcut")
     #   # =>
     #   # shape: (5, 3)
-    #   # ┌─────┬──────┬────────────┐
-    #   # │ foo ┆ brk  ┆ foo_bin    │
-    #   # │ --- ┆ ---  ┆ ---        │
-    #   # │ i64 ┆ f64  ┆ cat        │
-    #   # ╞═════╪══════╪════════════╡
-    #   # │ -2  ┆ -1.0 ┆ (-inf, -1] │
-    #   # │ -1  ┆ -1.0 ┆ (-inf, -1] │
-    #   # │ 0   ┆ 1.0  ┆ (-1, 1]    │
-    #   # │ 1   ┆ 1.0  ┆ (-1, 1]    │
-    #   # │ 2   ┆ inf  ┆ (1, inf]   │
-    #   # └─────┴──────┴────────────┘
+    #   # ┌─────┬────────────┬────────────┐
+    #   # │ foo ┆ breakpoint ┆ category   │
+    #   # │ --- ┆ ---        ┆ ---        │
+    #   # │ i64 ┆ f64        ┆ cat        │
+    #   # ╞═════╪════════════╪════════════╡
+    #   # │ -2  ┆ -1.0       ┆ (-inf, -1] │
+    #   # │ -1  ┆ -1.0       ┆ (-inf, -1] │
+    #   # │ 0   ┆ 1.0        ┆ (-1, 1]    │
+    #   # │ 1   ┆ 1.0        ┆ (-1, 1]    │
+    #   # │ 2   ┆ inf        ┆ (1, inf]   │
+    #   # └─────┴────────────┴────────────┘
     def qcut(quantiles, labels: nil, left_closed: false, allow_duplicates: false, include_breaks: false)
       if quantiles.is_a?(Integer)
         rbexpr = _rbexpr.qcut_uniform(
@@ -2630,18 +2668,18 @@ module Polars
     #   df.select(Polars.col("s").rle).unnest("s")
     #   # =>
     #   # shape: (6, 2)
-    #   # ┌─────────┬────────┐
-    #   # │ lengths ┆ values │
-    #   # │ ---     ┆ ---    │
-    #   # │ i32     ┆ i64    │
-    #   # ╞═════════╪════════╡
-    #   # │ 2       ┆ 1      │
-    #   # │ 1       ┆ 2      │
-    #   # │ 1       ┆ 1      │
-    #   # │ 1       ┆ null   │
-    #   # │ 1       ┆ 1      │
-    #   # │ 2       ┆ 3      │
-    #   # └─────────┴────────┘
+    #   # ┌─────┬───────┐
+    #   # │ len ┆ value │
+    #   # │ --- ┆ ---   │
+    #   # │ u32 ┆ i64   │
+    #   # ╞═════╪═══════╡
+    #   # │ 2   ┆ 1     │
+    #   # │ 1   ┆ 2     │
+    #   # │ 1   ┆ 1     │
+    #   # │ 1   ┆ null  │
+    #   # │ 1   ┆ 1     │
+    #   # │ 2   ┆ 3     │
+    #   # └─────┴───────┘
     def rle
       _from_rbexpr(_rbexpr.rle)
     end
@@ -2764,6 +2802,9 @@ module Polars
     #   Dtype of the output Series.
     # @param agg_list [Boolean]
     #   Aggregate list.
+    # @param is_elementwise [Boolean]
+    #   If set to true this can run in the streaming engine, but may yield
+    #   incorrect results in group-by. Ensure you know what you are doing!
     #
     # @return [Expr]
     #
@@ -2784,12 +2825,21 @@ module Polars
     #   # ╞══════╪════════╡
     #   # │ 1    ┆ 0      │
     #   # └──────┴────────┘
-    # def map(return_dtype: nil, agg_list: false, &f)
+    # def map_batches(return_dtype: nil, agg_list: false, is_elementwise: false, &f)
     #   if !return_dtype.nil?
     #     return_dtype = Utils.rb_type_to_dtype(return_dtype)
     #   end
-    #   _from_rbexpr(_rbexpr.map(f, return_dtype, agg_list))
+    #   _from_rbexpr(
+    #     _rbexpr.map_batches(
+    #       # TODO _map_batches_wrapper
+    #       f,
+    #       return_dtype,
+    #       agg_list,
+    #       is_elementwise
+    #     )
+    #   )
     # end
+    # alias_method :map, :map_batches
 
     # Apply a custom/user-defined function (UDF) in a GroupBy or Projection context.
     #
@@ -2831,7 +2881,7 @@ module Polars
     #
     # @example In a selection context, the function is applied by row.
     #   df.with_column(
-    #     Polars.col("a").apply { |x| x * 2 }.alias("a_times_2")
+    #     Polars.col("a").map_elements { |x| x * 2 }.alias("a_times_2")
     #   )
     #   # =>
     #   # shape: (4, 3)
@@ -2851,7 +2901,7 @@ module Polars
     #     .group_by("b", maintain_order: true)
     #     .agg(
     #       [
-    #         Polars.col("a").apply { |x| x.sum }
+    #         Polars.col("a").map_elements { |x| x.sum }
     #       ]
     #     )
     #     .collect
@@ -2866,12 +2916,23 @@ module Polars
     #   # │ b   ┆ 2   │
     #   # │ c   ┆ 4   │
     #   # └─────┴─────┘
-    # def apply(return_dtype: nil, &f)
-    #   wrap_f = lambda do |x|
-    #     x.apply(return_dtype: return_dtype, &f)
+    # def map_elements(
+    #   return_dtype: nil,
+    #   skip_nulls: true,
+    #   pass_name: false,
+    #   strategy: "thread_local",
+    #   &f
+    # )
+    #   if pass_name
+    #     raise Todo
+    #   else
+    #     wrap_f = lambda do |x|
+    #       x.map_elements(return_dtype: return_dtype, skip_nulls: skip_nulls, &f)
+    #     end
     #   end
-    #   map(agg_list: true, return_dtype: return_dtype, &wrap_f)
+    #   map_batches(agg_list: true, return_dtype: return_dtype, &wrap_f)
     # end
+    # alias_method :apply, :map_elements
 
     # Explode a list or utf8 Series. This means that every item is expanded to a new
     # row.
@@ -3081,7 +3142,7 @@ module Polars
     #   # │ null ┆ null ┆ null   ┆ true           │
     #   # └──────┴──────┴────────┴────────────────┘
     def eq_missing(other)
-      other = Utils.parse_as_expression(other, str_as_lit: true)
+      other = Utils.parse_into_expression(other, str_as_lit: true)
       _from_rbexpr(_rbexpr.eq_missing(other))
     end
 
@@ -3285,7 +3346,7 @@ module Polars
     #   # │ null ┆ null ┆ null   ┆ false          │
     #   # └──────┴──────┴────────┴────────────────┘
     def ne_missing(other)
-      other = Utils.parse_as_expression(other, str_as_lit: true)
+      other = Utils.parse_into_expression(other, str_as_lit: true)
       _from_rbexpr(_rbexpr.neq_missing(other))
     end
 
@@ -3588,14 +3649,14 @@ module Polars
     def is_in(other)
       if other.is_a?(::Array)
         if other.length == 0
-          other = Polars.lit(nil)
+          other = Polars.lit(nil)._rbexpr
         else
-          other = Polars.lit(Series.new(other))
+          other = Polars.lit(Series.new(other))._rbexpr
         end
       else
-        other = Utils.expr_to_lit_or_expr(other, str_to_lit: false)
+        other = Utils.parse_into_expression(other, str_as_lit: false)
       end
-      _from_rbexpr(_rbexpr.is_in(other._rbexpr))
+      _from_rbexpr(_rbexpr.is_in(other))
     end
     alias_method :in?, :is_in
 
@@ -3630,15 +3691,15 @@ module Polars
     #   # │ ["z", "z", "z"] │
     #   # └─────────────────┘
     def repeat_by(by)
-      by = Utils.expr_to_lit_or_expr(by, str_to_lit: false)
-      _from_rbexpr(_rbexpr.repeat_by(by._rbexpr))
+      by = Utils.parse_into_expression(by, str_as_lit: false)
+      _from_rbexpr(_rbexpr.repeat_by(by))
     end
 
     # Check if this expression is between start and end.
     #
-    # @param start [Object]
+    # @param lower_bound [Object]
     #   Lower bound as primitive type or datetime.
-    # @param _end [Object]
+    # @param upper_bound [Object]
     #   Upper bound as primitive type or datetime.
     # @param closed ["both", "left", "right", "none"]
     #   Define which sides of the interval are closed (inclusive).
@@ -3700,22 +3761,13 @@ module Polars
     #   # │ d   ┆ false      │
     #   # │ e   ┆ false      │
     #   # └─────┴────────────┘
-    def is_between(start, _end, closed: "both")
-      start = Utils.expr_to_lit_or_expr(start, str_to_lit: false)
-      _end = Utils.expr_to_lit_or_expr(_end, str_to_lit: false)
-
-      case closed
-      when "none"
-        (self > start) & (self < _end)
-      when "both"
-        (self >= start) & (self <= _end)
-      when "right"
-        (self > start) & (self <= _end)
-      when "left"
-        (self >= start) & (self < _end)
-      else
-        raise ArgumentError, "closed must be one of 'left', 'right', 'both', or 'none'"
-      end
+    def is_between(lower_bound, upper_bound, closed: "both")
+      lower_bound = Utils.parse_into_expression(lower_bound)
+      upper_bound = Utils.parse_into_expression(upper_bound)
+
+      _from_rbexpr(
+        _rbexpr.is_between(lower_bound, upper_bound, closed)
+      )
     end
 
     # Hash the elements in the selection.
@@ -3857,6 +3909,1002 @@ module Polars
       _from_rbexpr(_rbexpr.interpolate(method))
     end
 
+    # Apply a rolling min based on another column.
+    #
+    # @param by [String]
+    #   This column must be of dtype Datetime or Date.
+    # @param window_size [String]
+    #   The length of the window. Can be a dynamic temporal
+    #   size indicated by a timedelta or the following string language:
+    #
+    #   - 1ns   (1 nanosecond)
+    #   - 1us   (1 microsecond)
+    #   - 1ms   (1 millisecond)
+    #   - 1s    (1 second)
+    #   - 1m    (1 minute)
+    #   - 1h    (1 hour)
+    #   - 1d    (1 calendar day)
+    #   - 1w    (1 calendar week)
+    #   - 1mo   (1 calendar month)
+    #   - 1q    (1 calendar quarter)
+    #   - 1y    (1 calendar year)
+    #
+    #   By "calendar day", we mean the corresponding time on the next day
+    #   (which may not be 24 hours, due to daylight savings). Similarly for
+    #   "calendar week", "calendar month", "calendar quarter", and
+    #   "calendar year".
+    # @param min_periods [Integer]
+    #   The number of values in the window that should be non-null before computing
+    #   a result.
+    # @param closed ['left', 'right', 'both', 'none']
+    #   Define which sides of the temporal interval are closed (inclusive),
+    #   defaults to `'right'`.
+    # @param warn_if_unsorted [Boolean]
+    #   Warn if data is not known to be sorted by `by` column.
+    #
+    # @return [Expr]
+    #
+    # @note
+    #   If you want to compute multiple aggregation statistics over the same dynamic
+    #   window, consider using `rolling` - this method can cache the window size
+    #   computation.
+    #
+    # @example Create a DataFrame with a datetime column and a row number column
+    #   start = DateTime.new(2001, 1, 1)
+    #   stop = DateTime.new(2001, 1, 2)
+    #   df_temporal = Polars::DataFrame.new(
+    #     {"date" => Polars.datetime_range(start, stop, "1h", eager: true)}
+    #   ).with_row_index
+    #   # =>
+    #   # shape: (25, 2)
+    #   # ┌───────┬─────────────────────┐
+    #   # │ index ┆ date                │
+    #   # │ ---   ┆ ---                 │
+    #   # │ u32   ┆ datetime[ns]        │
+    #   # ╞═══════╪═════════════════════╡
+    #   # │ 0     ┆ 2001-01-01 00:00:00 │
+    #   # │ 1     ┆ 2001-01-01 01:00:00 │
+    #   # │ 2     ┆ 2001-01-01 02:00:00 │
+    #   # │ 3     ┆ 2001-01-01 03:00:00 │
+    #   # │ 4     ┆ 2001-01-01 04:00:00 │
+    #   # │ …     ┆ …                   │
+    #   # │ 20    ┆ 2001-01-01 20:00:00 │
+    #   # │ 21    ┆ 2001-01-01 21:00:00 │
+    #   # │ 22    ┆ 2001-01-01 22:00:00 │
+    #   # │ 23    ┆ 2001-01-01 23:00:00 │
+    #   # │ 24    ┆ 2001-01-02 00:00:00 │
+    #   # └───────┴─────────────────────┘
+    #
+    # @example Compute the rolling min with the temporal windows closed on the right (default)
+    #   df_temporal.with_columns(
+    #     rolling_row_min: Polars.col("index").rolling_min_by("date", "2h")
+    #   )
+    #   # =>
+    #   # shape: (25, 3)
+    #   # ┌───────┬─────────────────────┬─────────────────┐
+    #   # │ index ┆ date                ┆ rolling_row_min │
+    #   # │ ---   ┆ ---                 ┆ ---             │
+    #   # │ u32   ┆ datetime[ns]        ┆ u32             │
+    #   # ╞═══════╪═════════════════════╪═════════════════╡
+    #   # │ 0     ┆ 2001-01-01 00:00:00 ┆ 0               │
+    #   # │ 1     ┆ 2001-01-01 01:00:00 ┆ 0               │
+    #   # │ 2     ┆ 2001-01-01 02:00:00 ┆ 1               │
+    #   # │ 3     ┆ 2001-01-01 03:00:00 ┆ 2               │
+    #   # │ 4     ┆ 2001-01-01 04:00:00 ┆ 3               │
+    #   # │ …     ┆ …                   ┆ …               │
+    #   # │ 20    ┆ 2001-01-01 20:00:00 ┆ 19              │
+    #   # │ 21    ┆ 2001-01-01 21:00:00 ┆ 20              │
+    #   # │ 22    ┆ 2001-01-01 22:00:00 ┆ 21              │
+    #   # │ 23    ┆ 2001-01-01 23:00:00 ┆ 22              │
+    #   # │ 24    ┆ 2001-01-02 00:00:00 ┆ 23              │
+    #   # └───────┴─────────────────────┴─────────────────┘
+    def rolling_min_by(
+      by,
+      window_size,
+      min_periods: 1,
+      closed: "right",
+      warn_if_unsorted: nil
+    )
+      window_size = _prepare_rolling_by_window_args(window_size)
+      by = Utils.parse_into_expression(by)
+      _from_rbexpr(
+        _rbexpr.rolling_min_by(by, window_size, min_periods, closed)
+      )
+    end
+
+    # Apply a rolling max based on another column.
+    #
+    # @param by [String]
+    #   This column must be of dtype Datetime or Date.
+    # @param window_size [String]
+    #   The length of the window. Can be a dynamic temporal
+    #   size indicated by a timedelta or the following string language:
+    #
+    #   - 1ns   (1 nanosecond)
+    #   - 1us   (1 microsecond)
+    #   - 1ms   (1 millisecond)
+    #   - 1s    (1 second)
+    #   - 1m    (1 minute)
+    #   - 1h    (1 hour)
+    #   - 1d    (1 calendar day)
+    #   - 1w    (1 calendar week)
+    #   - 1mo   (1 calendar month)
+    #   - 1q    (1 calendar quarter)
+    #   - 1y    (1 calendar year)
+    #
+    #   By "calendar day", we mean the corresponding time on the next day
+    #   (which may not be 24 hours, due to daylight savings). Similarly for
+    #   "calendar week", "calendar month", "calendar quarter", and
+    #   "calendar year".
+    # @param min_periods [Integer]
+    #   The number of values in the window that should be non-null before computing
+    #   a result.
+    # @param closed ['left', 'right', 'both', 'none']
+    #   Define which sides of the temporal interval are closed (inclusive),
+    #   defaults to `'right'`.
+    # @param warn_if_unsorted [Boolean]
+    #   Warn if data is not known to be sorted by `by` column.
+    #
+    # @return [Expr]
+    #
+    # @note
+    #   If you want to compute multiple aggregation statistics over the same dynamic
+    #   window, consider using `rolling` - this method can cache the window size
+    #   computation.
+    #
+    # @example Create a DataFrame with a datetime column and a row number column
+    #   start = DateTime.new(2001, 1, 1)
+    #   stop = DateTime.new(2001, 1, 2)
+    #   df_temporal = Polars::DataFrame.new(
+    #       {"date" => Polars.datetime_range(start, stop, "1h", eager: true)}
+    #   ).with_row_index
+    #   # =>
+    #   # shape: (25, 2)
+    #   # ┌───────┬─────────────────────┐
+    #   # │ index ┆ date                │
+    #   # │ ---   ┆ ---                 │
+    #   # │ u32   ┆ datetime[ns]        │
+    #   # ╞═══════╪═════════════════════╡
+    #   # │ 0     ┆ 2001-01-01 00:00:00 │
+    #   # │ 1     ┆ 2001-01-01 01:00:00 │
+    #   # │ 2     ┆ 2001-01-01 02:00:00 │
+    #   # │ 3     ┆ 2001-01-01 03:00:00 │
+    #   # │ 4     ┆ 2001-01-01 04:00:00 │
+    #   # │ …     ┆ …                   │
+    #   # │ 20    ┆ 2001-01-01 20:00:00 │
+    #   # │ 21    ┆ 2001-01-01 21:00:00 │
+    #   # │ 22    ┆ 2001-01-01 22:00:00 │
+    #   # │ 23    ┆ 2001-01-01 23:00:00 │
+    #   # │ 24    ┆ 2001-01-02 00:00:00 │
+    #   # └───────┴─────────────────────┘
+    #
+    # @example Compute the rolling max with the temporal windows closed on the right (default)
+    #   df_temporal.with_columns(
+    #     rolling_row_max: Polars.col("index").rolling_max_by("date", "2h")
+    #   )
+    #   # =>
+    #   # shape: (25, 3)
+    #   # ┌───────┬─────────────────────┬─────────────────┐
+    #   # │ index ┆ date                ┆ rolling_row_max │
+    #   # │ ---   ┆ ---                 ┆ ---             │
+    #   # │ u32   ┆ datetime[ns]        ┆ u32             │
+    #   # ╞═══════╪═════════════════════╪═════════════════╡
+    #   # │ 0     ┆ 2001-01-01 00:00:00 ┆ 0               │
+    #   # │ 1     ┆ 2001-01-01 01:00:00 ┆ 1               │
+    #   # │ 2     ┆ 2001-01-01 02:00:00 ┆ 2               │
+    #   # │ 3     ┆ 2001-01-01 03:00:00 ┆ 3               │
+    #   # │ 4     ┆ 2001-01-01 04:00:00 ┆ 4               │
+    #   # │ …     ┆ …                   ┆ …               │
+    #   # │ 20    ┆ 2001-01-01 20:00:00 ┆ 20              │
+    #   # │ 21    ┆ 2001-01-01 21:00:00 ┆ 21              │
+    #   # │ 22    ┆ 2001-01-01 22:00:00 ┆ 22              │
+    #   # │ 23    ┆ 2001-01-01 23:00:00 ┆ 23              │
+    #   # │ 24    ┆ 2001-01-02 00:00:00 ┆ 24              │
+    #   # └───────┴─────────────────────┴─────────────────┘
+    #
+    # @example Compute the rolling max with the closure of windows on both sides
+    #   df_temporal.with_columns(
+    #     rolling_row_max: Polars.col("index").rolling_max_by(
+    #       "date", "2h", closed: "both"
+    #     )
+    #   )
+    #   # =>
+    #   # shape: (25, 3)
+    #   # ┌───────┬─────────────────────┬─────────────────┐
+    #   # │ index ┆ date                ┆ rolling_row_max │
+    #   # │ ---   ┆ ---                 ┆ ---             │
+    #   # │ u32   ┆ datetime[ns]        ┆ u32             │
+    #   # ╞═══════╪═════════════════════╪═════════════════╡
+    #   # │ 0     ┆ 2001-01-01 00:00:00 ┆ 0               │
+    #   # │ 1     ┆ 2001-01-01 01:00:00 ┆ 1               │
+    #   # │ 2     ┆ 2001-01-01 02:00:00 ┆ 2               │
+    #   # │ 3     ┆ 2001-01-01 03:00:00 ┆ 3               │
+    #   # │ 4     ┆ 2001-01-01 04:00:00 ┆ 4               │
+    #   # │ …     ┆ …                   ┆ …               │
+    #   # │ 20    ┆ 2001-01-01 20:00:00 ┆ 20              │
+    #   # │ 21    ┆ 2001-01-01 21:00:00 ┆ 21              │
+    #   # │ 22    ┆ 2001-01-01 22:00:00 ┆ 22              │
+    #   # │ 23    ┆ 2001-01-01 23:00:00 ┆ 23              │
+    #   # │ 24    ┆ 2001-01-02 00:00:00 ┆ 24              │
+    #   # └───────┴─────────────────────┴─────────────────┘
+    def rolling_max_by(
+      by,
+      window_size,
+      min_periods: 1,
+      closed: "right",
+      warn_if_unsorted: nil
+    )
+      window_size = _prepare_rolling_by_window_args(window_size)
+      by = Utils.parse_into_expression(by)
+      _from_rbexpr(
+        _rbexpr.rolling_max_by(by, window_size, min_periods, closed)
+      )
+    end
+
+    # Apply a rolling mean based on another column.
+    #
+    # @param by [String]
+    #   This column must be of dtype Datetime or Date.
+    # @param window_size [String]
+    #   The length of the window. Can be a dynamic temporal
+    #   size indicated by a timedelta or the following string language:
+    #
+    #   - 1ns   (1 nanosecond)
+    #   - 1us   (1 microsecond)
+    #   - 1ms   (1 millisecond)
+    #   - 1s    (1 second)
+    #   - 1m    (1 minute)
+    #   - 1h    (1 hour)
+    #   - 1d    (1 calendar day)
+    #   - 1w    (1 calendar week)
+    #   - 1mo   (1 calendar month)
+    #   - 1q    (1 calendar quarter)
+    #   - 1y    (1 calendar year)
+    #
+    #   By "calendar day", we mean the corresponding time on the next day
+    #   (which may not be 24 hours, due to daylight savings). Similarly for
+    #   "calendar week", "calendar month", "calendar quarter", and
+    #   "calendar year".
+    # @param min_periods [Integer]
+    #   The number of values in the window that should be non-null before computing
+    #   a result.
+    # @param closed ['left', 'right', 'both', 'none']
+    #   Define which sides of the temporal interval are closed (inclusive),
+    #   defaults to `'right'`.
+    # @param warn_if_unsorted [Boolean]
+    #   Warn if data is not known to be sorted by `by` column.
+    #
+    # @return [Expr]
+    #
+    # @note
+    #   If you want to compute multiple aggregation statistics over the same dynamic
+    #   window, consider using `rolling` - this method can cache the window size
+    #   computation.
+    #
+    # @example Create a DataFrame with a datetime column and a row number column
+    #   start = DateTime.new(2001, 1, 1)
+    #   stop = DateTime.new(2001, 1, 2)
+    #   df_temporal = Polars::DataFrame.new(
+    #       {"date" => Polars.datetime_range(start, stop, "1h", eager: true)}
+    #   ).with_row_index
+    #   # =>
+    #   # shape: (25, 2)
+    #   # ┌───────┬─────────────────────┐
+    #   # │ index ┆ date                │
+    #   # │ ---   ┆ ---                 │
+    #   # │ u32   ┆ datetime[ns]        │
+    #   # ╞═══════╪═════════════════════╡
+    #   # │ 0     ┆ 2001-01-01 00:00:00 │
+    #   # │ 1     ┆ 2001-01-01 01:00:00 │
+    #   # │ 2     ┆ 2001-01-01 02:00:00 │
+    #   # │ 3     ┆ 2001-01-01 03:00:00 │
+    #   # │ 4     ┆ 2001-01-01 04:00:00 │
+    #   # │ …     ┆ …                   │
+    #   # │ 20    ┆ 2001-01-01 20:00:00 │
+    #   # │ 21    ┆ 2001-01-01 21:00:00 │
+    #   # │ 22    ┆ 2001-01-01 22:00:00 │
+    #   # │ 23    ┆ 2001-01-01 23:00:00 │
+    #   # │ 24    ┆ 2001-01-02 00:00:00 │
+    #   # └───────┴─────────────────────┘
+    #
+    # @example Compute the rolling mean with the temporal windows closed on the right (default)
+    #   df_temporal.with_columns(
+    #     rolling_row_mean: Polars.col("index").rolling_mean_by(
+    #       "date", "2h"
+    #     )
+    #   )
+    #   # =>
+    #   # shape: (25, 3)
+    #   # ┌───────┬─────────────────────┬──────────────────┐
+    #   # │ index ┆ date                ┆ rolling_row_mean │
+    #   # │ ---   ┆ ---                 ┆ ---              │
+    #   # │ u32   ┆ datetime[ns]        ┆ f64              │
+    #   # ╞═══════╪═════════════════════╪══════════════════╡
+    #   # │ 0     ┆ 2001-01-01 00:00:00 ┆ 0.0              │
+    #   # │ 1     ┆ 2001-01-01 01:00:00 ┆ 0.5              │
+    #   # │ 2     ┆ 2001-01-01 02:00:00 ┆ 1.5              │
+    #   # │ 3     ┆ 2001-01-01 03:00:00 ┆ 2.5              │
+    #   # │ 4     ┆ 2001-01-01 04:00:00 ┆ 3.5              │
+    #   # │ …     ┆ …                   ┆ …                │
+    #   # │ 20    ┆ 2001-01-01 20:00:00 ┆ 19.5             │
+    #   # │ 21    ┆ 2001-01-01 21:00:00 ┆ 20.5             │
+    #   # │ 22    ┆ 2001-01-01 22:00:00 ┆ 21.5             │
+    #   # │ 23    ┆ 2001-01-01 23:00:00 ┆ 22.5             │
+    #   # │ 24    ┆ 2001-01-02 00:00:00 ┆ 23.5             │
+    #   # └───────┴─────────────────────┴──────────────────┘
+    #
+    # @example Compute the rolling mean with the closure of windows on both sides
+    #   df_temporal.with_columns(
+    #     rolling_row_mean: Polars.col("index").rolling_mean_by(
+    #       "date", "2h", closed: "both"
+    #     )
+    #   )
+    #   # =>
+    #   # shape: (25, 3)
+    #   # ┌───────┬─────────────────────┬──────────────────┐
+    #   # │ index ┆ date                ┆ rolling_row_mean │
+    #   # │ ---   ┆ ---                 ┆ ---              │
+    #   # │ u32   ┆ datetime[ns]        ┆ f64              │
+    #   # ╞═══════╪═════════════════════╪══════════════════╡
+    #   # │ 0     ┆ 2001-01-01 00:00:00 ┆ 0.0              │
+    #   # │ 1     ┆ 2001-01-01 01:00:00 ┆ 0.5              │
+    #   # │ 2     ┆ 2001-01-01 02:00:00 ┆ 1.0              │
+    #   # │ 3     ┆ 2001-01-01 03:00:00 ┆ 2.0              │
+    #   # │ 4     ┆ 2001-01-01 04:00:00 ┆ 3.0              │
+    #   # │ …     ┆ …                   ┆ …                │
+    #   # │ 20    ┆ 2001-01-01 20:00:00 ┆ 19.0             │
+    #   # │ 21    ┆ 2001-01-01 21:00:00 ┆ 20.0             │
+    #   # │ 22    ┆ 2001-01-01 22:00:00 ┆ 21.0             │
+    #   # │ 23    ┆ 2001-01-01 23:00:00 ┆ 22.0             │
+    #   # │ 24    ┆ 2001-01-02 00:00:00 ┆ 23.0             │
+    #   # └───────┴─────────────────────┴──────────────────┘
+    def rolling_mean_by(
+      by,
+      window_size,
+      min_periods: 1,
+      closed: "right",
+      warn_if_unsorted: nil
+    )
+      window_size = _prepare_rolling_by_window_args(window_size)
+      by = Utils.parse_into_expression(by)
+      _from_rbexpr(
+        _rbexpr.rolling_mean_by(
+          by,
+          window_size,
+          min_periods,
+          closed
+        )
+      )
+    end
+
+    # Apply a rolling sum based on another column.
+    #
+    # @param by [String]
+    #   This column must of dtype `{Date, Datetime}`
+    # @param window_size [String]
+    #   The length of the window. Can be a dynamic temporal
+    #   size indicated by a timedelta or the following string language:
+    #
+    #   - 1ns   (1 nanosecond)
+    #   - 1us   (1 microsecond)
+    #   - 1ms   (1 millisecond)
+    #   - 1s    (1 second)
+    #   - 1m    (1 minute)
+    #   - 1h    (1 hour)
+    #   - 1d    (1 calendar day)
+    #   - 1w    (1 calendar week)
+    #   - 1mo   (1 calendar month)
+    #   - 1q    (1 calendar quarter)
+    #   - 1y    (1 calendar year)
+    #
+    #   By "calendar day", we mean the corresponding time on the next day
+    #   (which may not be 24 hours, due to daylight savings). Similarly for
+    #   "calendar week", "calendar month", "calendar quarter", and
+    #   "calendar year".
+    # @param min_periods [Integer]
+    #   The number of values in the window that should be non-null before computing
+    #   a result.
+    # @param closed ['left', 'right', 'both', 'none']
+    #   Define which sides of the temporal interval are closed (inclusive),
+    #   defaults to `'right'`.
+    # @param warn_if_unsorted [Boolean]
+    #   Warn if data is not known to be sorted by `by` column.
+    #
+    # @return [Expr]
+    #
+    # @note
+    #   If you want to compute multiple aggregation statistics over the same dynamic
+    #   window, consider using `rolling` - this method can cache the window size
+    #   computation.
+    #
+    # @example Create a DataFrame with a datetime column and a row number column
+    #   start = DateTime.new(2001, 1, 1)
+    #   stop = DateTime.new(2001, 1, 2)
+    #   df_temporal = Polars::DataFrame.new(
+    #       {"date" => Polars.datetime_range(start, stop, "1h", eager: true)}
+    #   ).with_row_index
+    #   # =>
+    #   # shape: (25, 2)
+    #   # ┌───────┬─────────────────────┐
+    #   # │ index ┆ date                │
+    #   # │ ---   ┆ ---                 │
+    #   # │ u32   ┆ datetime[ns]        │
+    #   # ╞═══════╪═════════════════════╡
+    #   # │ 0     ┆ 2001-01-01 00:00:00 │
+    #   # │ 1     ┆ 2001-01-01 01:00:00 │
+    #   # │ 2     ┆ 2001-01-01 02:00:00 │
+    #   # │ 3     ┆ 2001-01-01 03:00:00 │
+    #   # │ 4     ┆ 2001-01-01 04:00:00 │
+    #   # │ …     ┆ …                   │
+    #   # │ 20    ┆ 2001-01-01 20:00:00 │
+    #   # │ 21    ┆ 2001-01-01 21:00:00 │
+    #   # │ 22    ┆ 2001-01-01 22:00:00 │
+    #   # │ 23    ┆ 2001-01-01 23:00:00 │
+    #   # │ 24    ┆ 2001-01-02 00:00:00 │
+    #   # └───────┴─────────────────────┘
+    #
+    # @example Compute the rolling sum with the temporal windows closed on the right (default)
+    #   df_temporal.with_columns(
+    #     rolling_row_sum: Polars.col("index").rolling_sum_by("date", "2h")
+    #   )
+    #   # =>
+    #   # shape: (25, 3)
+    #   # ┌───────┬─────────────────────┬─────────────────┐
+    #   # │ index ┆ date                ┆ rolling_row_sum │
+    #   # │ ---   ┆ ---                 ┆ ---             │
+    #   # │ u32   ┆ datetime[ns]        ┆ u32             │
+    #   # ╞═══════╪═════════════════════╪═════════════════╡
+    #   # │ 0     ┆ 2001-01-01 00:00:00 ┆ 0               │
+    #   # │ 1     ┆ 2001-01-01 01:00:00 ┆ 1               │
+    #   # │ 2     ┆ 2001-01-01 02:00:00 ┆ 3               │
+    #   # │ 3     ┆ 2001-01-01 03:00:00 ┆ 5               │
+    #   # │ 4     ┆ 2001-01-01 04:00:00 ┆ 7               │
+    #   # │ …     ┆ …                   ┆ …               │
+    #   # │ 20    ┆ 2001-01-01 20:00:00 ┆ 39              │
+    #   # │ 21    ┆ 2001-01-01 21:00:00 ┆ 41              │
+    #   # │ 22    ┆ 2001-01-01 22:00:00 ┆ 43              │
+    #   # │ 23    ┆ 2001-01-01 23:00:00 ┆ 45              │
+    #   # │ 24    ┆ 2001-01-02 00:00:00 ┆ 47              │
+    #   # └───────┴─────────────────────┴─────────────────┘
+    #
+    # @example Compute the rolling sum with the closure of windows on both sides
+    #   df_temporal.with_columns(
+    #     rolling_row_sum: Polars.col("index").rolling_sum_by(
+    #       "date", "2h", closed: "both"
+    #     )
+    #   )
+    #   # =>
+    #   # shape: (25, 3)
+    #   # ┌───────┬─────────────────────┬─────────────────┐
+    #   # │ index ┆ date                ┆ rolling_row_sum │
+    #   # │ ---   ┆ ---                 ┆ ---             │
+    #   # │ u32   ┆ datetime[ns]        ┆ u32             │
+    #   # ╞═══════╪═════════════════════╪═════════════════╡
+    #   # │ 0     ┆ 2001-01-01 00:00:00 ┆ 0               │
+    #   # │ 1     ┆ 2001-01-01 01:00:00 ┆ 1               │
+    #   # │ 2     ┆ 2001-01-01 02:00:00 ┆ 3               │
+    #   # │ 3     ┆ 2001-01-01 03:00:00 ┆ 6               │
+    #   # │ 4     ┆ 2001-01-01 04:00:00 ┆ 9               │
+    #   # │ …     ┆ …                   ┆ …               │
+    #   # │ 20    ┆ 2001-01-01 20:00:00 ┆ 57              │
+    #   # │ 21    ┆ 2001-01-01 21:00:00 ┆ 60              │
+    #   # │ 22    ┆ 2001-01-01 22:00:00 ┆ 63              │
+    #   # │ 23    ┆ 2001-01-01 23:00:00 ┆ 66              │
+    #   # │ 24    ┆ 2001-01-02 00:00:00 ┆ 69              │
+    #   # └───────┴─────────────────────┴─────────────────┘
+    def rolling_sum_by(
+      by,
+      window_size,
+      min_periods: 1,
+      closed: "right",
+      warn_if_unsorted: nil
+    )
+      window_size = _prepare_rolling_by_window_args(window_size)
+      by = Utils.parse_into_expression(by)
+      _from_rbexpr(
+        _rbexpr.rolling_sum_by(by, window_size, min_periods, closed)
+      )
+    end
+
+    # Compute a rolling standard deviation based on another column.
+    #
+    # @param by [String]
+    #   This column must be of dtype Datetime or Date.
+    # @param window_size [String]
+    #   The length of the window. Can be a dynamic temporal
+    #   size indicated by a timedelta or the following string language:
+    #
+    #   - 1ns   (1 nanosecond)
+    #   - 1us   (1 microsecond)
+    #   - 1ms   (1 millisecond)
+    #   - 1s    (1 second)
+    #   - 1m    (1 minute)
+    #   - 1h    (1 hour)
+    #   - 1d    (1 calendar day)
+    #   - 1w    (1 calendar week)
+    #   - 1mo   (1 calendar month)
+    #   - 1q    (1 calendar quarter)
+    #   - 1y    (1 calendar year)
+    #
+    #   By "calendar day", we mean the corresponding time on the next day
+    #   (which may not be 24 hours, due to daylight savings). Similarly for
+    #   "calendar week", "calendar month", "calendar quarter", and
+    #   "calendar year".
+    # @param min_periods [Integer]
+    #   The number of values in the window that should be non-null before computing
+    #   a result.
+    # @param closed ['left', 'right', 'both', 'none']
+    #   Define which sides of the temporal interval are closed (inclusive),
+    #   defaults to `'right'`.
+    # @param ddof [Integer]
+    #   "Delta Degrees of Freedom": The divisor for a length N window is N - ddof
+    # @param warn_if_unsorted [Boolean]
+    #   Warn if data is not known to be sorted by `by` column.
+    #
+    # @return [Expr]
+    #
+    # @note
+    #   If you want to compute multiple aggregation statistics over the same dynamic
+    #   window, consider using `rolling` - this method can cache the window size
+    #   computation.
+    #
+    # @example Create a DataFrame with a datetime column and a row number column
+    #   start = DateTime.new(2001, 1, 1)
+    #   stop = DateTime.new(2001, 1, 2)
+    #   df_temporal = Polars::DataFrame.new(
+    #       {"date" => Polars.datetime_range(start, stop, "1h", eager: true)}
+    #   ).with_row_index
+    #   # =>
+    #   # shape: (25, 2)
+    #   # ┌───────┬─────────────────────┐
+    #   # │ index ┆ date                │
+    #   # │ ---   ┆ ---                 │
+    #   # │ u32   ┆ datetime[ns]        │
+    #   # ╞═══════╪═════════════════════╡
+    #   # │ 0     ┆ 2001-01-01 00:00:00 │
+    #   # │ 1     ┆ 2001-01-01 01:00:00 │
+    #   # │ 2     ┆ 2001-01-01 02:00:00 │
+    #   # │ 3     ┆ 2001-01-01 03:00:00 │
+    #   # │ 4     ┆ 2001-01-01 04:00:00 │
+    #   # │ …     ┆ …                   │
+    #   # │ 20    ┆ 2001-01-01 20:00:00 │
+    #   # │ 21    ┆ 2001-01-01 21:00:00 │
+    #   # │ 22    ┆ 2001-01-01 22:00:00 │
+    #   # │ 23    ┆ 2001-01-01 23:00:00 │
+    #   # │ 24    ┆ 2001-01-02 00:00:00 │
+    #   # └───────┴─────────────────────┘
+    #
+    # @example Compute the rolling std with the temporal windows closed on the right (default)
+    #   df_temporal.with_columns(
+    #     rolling_row_std: Polars.col("index").rolling_std_by("date", "2h")
+    #   )
+    #   # =>
+    #   # shape: (25, 3)
+    #   # ┌───────┬─────────────────────┬─────────────────┐
+    #   # │ index ┆ date                ┆ rolling_row_std │
+    #   # │ ---   ┆ ---                 ┆ ---             │
+    #   # │ u32   ┆ datetime[ns]        ┆ f64             │
+    #   # ╞═══════╪═════════════════════╪═════════════════╡
+    #   # │ 0     ┆ 2001-01-01 00:00:00 ┆ null            │
+    #   # │ 1     ┆ 2001-01-01 01:00:00 ┆ 0.707107        │
+    #   # │ 2     ┆ 2001-01-01 02:00:00 ┆ 0.707107        │
+    #   # │ 3     ┆ 2001-01-01 03:00:00 ┆ 0.707107        │
+    #   # │ 4     ┆ 2001-01-01 04:00:00 ┆ 0.707107        │
+    #   # │ …     ┆ …                   ┆ …               │
+    #   # │ 20    ┆ 2001-01-01 20:00:00 ┆ 0.707107        │
+    #   # │ 21    ┆ 2001-01-01 21:00:00 ┆ 0.707107        │
+    #   # │ 22    ┆ 2001-01-01 22:00:00 ┆ 0.707107        │
+    #   # │ 23    ┆ 2001-01-01 23:00:00 ┆ 0.707107        │
+    #   # │ 24    ┆ 2001-01-02 00:00:00 ┆ 0.707107        │
+    #   # └───────┴─────────────────────┴─────────────────┘
+    #
+    # @example Compute the rolling std with the closure of windows on both sides
+    #   df_temporal.with_columns(
+    #     rolling_row_std: Polars.col("index").rolling_std_by(
+    #       "date", "2h", closed: "both"
+    #     )
+    #   )
+    #   # =>
+    #   # shape: (25, 3)
+    #   # ┌───────┬─────────────────────┬─────────────────┐
+    #   # │ index ┆ date                ┆ rolling_row_std │
+    #   # │ ---   ┆ ---                 ┆ ---             │
+    #   # │ u32   ┆ datetime[ns]        ┆ f64             │
+    #   # ╞═══════╪═════════════════════╪═════════════════╡
+    #   # │ 0     ┆ 2001-01-01 00:00:00 ┆ null            │
+    #   # │ 1     ┆ 2001-01-01 01:00:00 ┆ 0.707107        │
+    #   # │ 2     ┆ 2001-01-01 02:00:00 ┆ 1.0             │
+    #   # │ 3     ┆ 2001-01-01 03:00:00 ┆ 1.0             │
+    #   # │ 4     ┆ 2001-01-01 04:00:00 ┆ 1.0             │
+    #   # │ …     ┆ …                   ┆ …               │
+    #   # │ 20    ┆ 2001-01-01 20:00:00 ┆ 1.0             │
+    #   # │ 21    ┆ 2001-01-01 21:00:00 ┆ 1.0             │
+    #   # │ 22    ┆ 2001-01-01 22:00:00 ┆ 1.0             │
+    #   # │ 23    ┆ 2001-01-01 23:00:00 ┆ 1.0             │
+    #   # │ 24    ┆ 2001-01-02 00:00:00 ┆ 1.0             │
+    #   # └───────┴─────────────────────┴─────────────────┘
+    def rolling_std_by(
+      by,
+      window_size,
+      min_periods: 1,
+      closed: "right",
+      ddof: 1,
+      warn_if_unsorted: nil
+    )
+      window_size = _prepare_rolling_by_window_args(window_size)
+      by = Utils.parse_into_expression(by)
+      _from_rbexpr(
+        _rbexpr.rolling_std_by(
+          by,
+          window_size,
+          min_periods,
+          closed,
+          ddof
+        )
+      )
+    end
+
+    # Compute a rolling variance based on another column.
+    #
+    # @param by [String]
+    #   This column must be of dtype Datetime or Date.
+    # @param window_size [String]
+    #   The length of the window. Can be a dynamic temporal
+    #   size indicated by a timedelta or the following string language:
+    #
+    #   - 1ns   (1 nanosecond)
+    #   - 1us   (1 microsecond)
+    #   - 1ms   (1 millisecond)
+    #   - 1s    (1 second)
+    #   - 1m    (1 minute)
+    #   - 1h    (1 hour)
+    #   - 1d    (1 calendar day)
+    #   - 1w    (1 calendar week)
+    #   - 1mo   (1 calendar month)
+    #   - 1q    (1 calendar quarter)
+    #   - 1y    (1 calendar year)
+    #
+    #   By "calendar day", we mean the corresponding time on the next day
+    #   (which may not be 24 hours, due to daylight savings). Similarly for
+    #   "calendar week", "calendar month", "calendar quarter", and
+    #   "calendar year".
+    # @param min_periods [Integer]
+    #   The number of values in the window that should be non-null before computing
+    #   a result.
+    # @param closed ['left', 'right', 'both', 'none']
+    #   Define which sides of the temporal interval are closed (inclusive),
+    #   defaults to `'right'`.
+    # @param ddof [Integer]
+    #   "Delta Degrees of Freedom": The divisor for a length N window is N - ddof
+    # @param warn_if_unsorted [Boolean]
+    #   Warn if data is not known to be sorted by `by` column.
+    #
+    # @return [Expr]
+    #
+    # @note
+    #   If you want to compute multiple aggregation statistics over the same dynamic
+    #   window, consider using `rolling` - this method can cache the window size
+    #   computation.
+    #
+    # @example Create a DataFrame with a datetime column and a row number column
+    #   start = DateTime.new(2001, 1, 1)
+    #   stop = DateTime.new(2001, 1, 2)
+    #   df_temporal = Polars::DataFrame.new(
+    #       {"date" => Polars.datetime_range(start, stop, "1h", eager: true)}
+    #   ).with_row_index
+    #   # =>
+    #   # shape: (25, 2)
+    #   # ┌───────┬─────────────────────┐
+    #   # │ index ┆ date                │
+    #   # │ ---   ┆ ---                 │
+    #   # │ u32   ┆ datetime[ns]        │
+    #   # ╞═══════╪═════════════════════╡
+    #   # │ 0     ┆ 2001-01-01 00:00:00 │
+    #   # │ 1     ┆ 2001-01-01 01:00:00 │
+    #   # │ 2     ┆ 2001-01-01 02:00:00 │
+    #   # │ 3     ┆ 2001-01-01 03:00:00 │
+    #   # │ 4     ┆ 2001-01-01 04:00:00 │
+    #   # │ …     ┆ …                   │
+    #   # │ 20    ┆ 2001-01-01 20:00:00 │
+    #   # │ 21    ┆ 2001-01-01 21:00:00 │
+    #   # │ 22    ┆ 2001-01-01 22:00:00 │
+    #   # │ 23    ┆ 2001-01-01 23:00:00 │
+    #   # │ 24    ┆ 2001-01-02 00:00:00 │
+    #   # └───────┴─────────────────────┘
+    #
+    # @example Compute the rolling var with the temporal windows closed on the right (default)
+    #   df_temporal.with_columns(
+    #     rolling_row_var: Polars.col("index").rolling_var_by("date", "2h")
+    #   )
+    #   # =>
+    #   # shape: (25, 3)
+    #   # ┌───────┬─────────────────────┬─────────────────┐
+    #   # │ index ┆ date                ┆ rolling_row_var │
+    #   # │ ---   ┆ ---                 ┆ ---             │
+    #   # │ u32   ┆ datetime[ns]        ┆ f64             │
+    #   # ╞═══════╪═════════════════════╪═════════════════╡
+    #   # │ 0     ┆ 2001-01-01 00:00:00 ┆ null            │
+    #   # │ 1     ┆ 2001-01-01 01:00:00 ┆ 0.5             │
+    #   # │ 2     ┆ 2001-01-01 02:00:00 ┆ 0.5             │
+    #   # │ 3     ┆ 2001-01-01 03:00:00 ┆ 0.5             │
+    #   # │ 4     ┆ 2001-01-01 04:00:00 ┆ 0.5             │
+    #   # │ …     ┆ …                   ┆ …               │
+    #   # │ 20    ┆ 2001-01-01 20:00:00 ┆ 0.5             │
+    #   # │ 21    ┆ 2001-01-01 21:00:00 ┆ 0.5             │
+    #   # │ 22    ┆ 2001-01-01 22:00:00 ┆ 0.5             │
+    #   # │ 23    ┆ 2001-01-01 23:00:00 ┆ 0.5             │
+    #   # │ 24    ┆ 2001-01-02 00:00:00 ┆ 0.5             │
+    #   # └───────┴─────────────────────┴─────────────────┘
+    #
+    # @example Compute the rolling var with the closure of windows on both sides
+    #   df_temporal.with_columns(
+    #     rolling_row_var: Polars.col("index").rolling_var_by(
+    #       "date", "2h", closed: "both"
+    #     )
+    #   )
+    #   # =>
+    #   # shape: (25, 3)
+    #   # ┌───────┬─────────────────────┬─────────────────┐
+    #   # │ index ┆ date                ┆ rolling_row_var │
+    #   # │ ---   ┆ ---                 ┆ ---             │
+    #   # │ u32   ┆ datetime[ns]        ┆ f64             │
+    #   # ╞═══════╪═════════════════════╪═════════════════╡
+    #   # │ 0     ┆ 2001-01-01 00:00:00 ┆ null            │
+    #   # │ 1     ┆ 2001-01-01 01:00:00 ┆ 0.5             │
+    #   # │ 2     ┆ 2001-01-01 02:00:00 ┆ 1.0             │
+    #   # │ 3     ┆ 2001-01-01 03:00:00 ┆ 1.0             │
+    #   # │ 4     ┆ 2001-01-01 04:00:00 ┆ 1.0             │
+    #   # │ …     ┆ …                   ┆ …               │
+    #   # │ 20    ┆ 2001-01-01 20:00:00 ┆ 1.0             │
+    #   # │ 21    ┆ 2001-01-01 21:00:00 ┆ 1.0             │
+    #   # │ 22    ┆ 2001-01-01 22:00:00 ┆ 1.0             │
+    #   # │ 23    ┆ 2001-01-01 23:00:00 ┆ 1.0             │
+    #   # │ 24    ┆ 2001-01-02 00:00:00 ┆ 1.0             │
+    #   # └───────┴─────────────────────┴─────────────────┘
+    def rolling_var_by(
+      by,
+      window_size,
+      min_periods: 1,
+      closed: "right",
+      ddof: 1,
+      warn_if_unsorted: nil
+    )
+      window_size = _prepare_rolling_by_window_args(window_size)
+      by = Utils.parse_into_expression(by)
+      _from_rbexpr(
+        _rbexpr.rolling_var_by(
+          by,
+          window_size,
+          min_periods,
+          closed,
+          ddof
+        )
+      )
+    end
+
+    # Compute a rolling median based on another column.
+    #
+    # @param by [String]
+    #     This column must be of dtype Datetime or Date.
+    # @param window_size [String]
+    #   The length of the window. Can be a dynamic temporal
+    #   size indicated by a timedelta or the following string language:
+    #
+    #   - 1ns   (1 nanosecond)
+    #   - 1us   (1 microsecond)
+    #   - 1ms   (1 millisecond)
+    #   - 1s    (1 second)
+    #   - 1m    (1 minute)
+    #   - 1h    (1 hour)
+    #   - 1d    (1 calendar day)
+    #   - 1w    (1 calendar week)
+    #   - 1mo   (1 calendar month)
+    #   - 1q    (1 calendar quarter)
+    #   - 1y    (1 calendar year)
+    #
+    #   By "calendar day", we mean the corresponding time on the next day
+    #   (which may not be 24 hours, due to daylight savings). Similarly for
+    #   "calendar week", "calendar month", "calendar quarter", and
+    #   "calendar year".
+    # @param min_periods [Integer]
+    #   The number of values in the window that should be non-null before computing
+    #   a result.
+    # @param closed ['left', 'right', 'both', 'none']
+    #   Define which sides of the temporal interval are closed (inclusive),
+    #   defaults to `'right'`.
+    # @param warn_if_unsorted [Boolean]
+    #   Warn if data is not known to be sorted by `by` column.
+    #
+    # @return [Expr]
+    #
+    # @note
+    #   If you want to compute multiple aggregation statistics over the same dynamic
+    #   window, consider using `rolling` - this method can cache the window size
+    #   computation.
+    #
+    # @example Create a DataFrame with a datetime column and a row number column
+    #   start = DateTime.new(2001, 1, 1)
+    #   stop = DateTime.new(2001, 1, 2)
+    #   df_temporal = Polars::DataFrame.new(
+    #     {"date" => Polars.datetime_range(start, stop, "1h", eager: true)}
+    #   ).with_row_index
+    #   # =>
+    #   # shape: (25, 2)
+    #   # ┌───────┬─────────────────────┐
+    #   # │ index ┆ date                │
+    #   # │ ---   ┆ ---                 │
+    #   # │ u32   ┆ datetime[ns]        │
+    #   # ╞═══════╪═════════════════════╡
+    #   # │ 0     ┆ 2001-01-01 00:00:00 │
+    #   # │ 1     ┆ 2001-01-01 01:00:00 │
+    #   # │ 2     ┆ 2001-01-01 02:00:00 │
+    #   # │ 3     ┆ 2001-01-01 03:00:00 │
+    #   # │ 4     ┆ 2001-01-01 04:00:00 │
+    #   # │ …     ┆ …                   │
+    #   # │ 20    ┆ 2001-01-01 20:00:00 │
+    #   # │ 21    ┆ 2001-01-01 21:00:00 │
+    #   # │ 22    ┆ 2001-01-01 22:00:00 │
+    #   # │ 23    ┆ 2001-01-01 23:00:00 │
+    #   # │ 24    ┆ 2001-01-02 00:00:00 │
+    #   # └───────┴─────────────────────┘
+    #
+    # @example Compute the rolling median with the temporal windows closed on the right:
+    #   df_temporal.with_columns(
+    #     rolling_row_median: Polars.col("index").rolling_median_by(
+    #       "date", "2h"
+    #     )
+    #   )
+    #   # =>
+    #   # shape: (25, 3)
+    #   # ┌───────┬─────────────────────┬────────────────────┐
+    #   # │ index ┆ date                ┆ rolling_row_median │
+    #   # │ ---   ┆ ---                 ┆ ---                │
+    #   # │ u32   ┆ datetime[ns]        ┆ f64                │
+    #   # ╞═══════╪═════════════════════╪════════════════════╡
+    #   # │ 0     ┆ 2001-01-01 00:00:00 ┆ 0.0                │
+    #   # │ 1     ┆ 2001-01-01 01:00:00 ┆ 0.5                │
+    #   # │ 2     ┆ 2001-01-01 02:00:00 ┆ 1.5                │
+    #   # │ 3     ┆ 2001-01-01 03:00:00 ┆ 2.5                │
+    #   # │ 4     ┆ 2001-01-01 04:00:00 ┆ 3.5                │
+    #   # │ …     ┆ …                   ┆ …                  │
+    #   # │ 20    ┆ 2001-01-01 20:00:00 ┆ 19.5               │
+    #   # │ 21    ┆ 2001-01-01 21:00:00 ┆ 20.5               │
+    #   # │ 22    ┆ 2001-01-01 22:00:00 ┆ 21.5               │
+    #   # │ 23    ┆ 2001-01-01 23:00:00 ┆ 22.5               │
+    #   # │ 24    ┆ 2001-01-02 00:00:00 ┆ 23.5               │
+    #   # └───────┴─────────────────────┴────────────────────┘
+    def rolling_median_by(
+      by,
+      window_size,
+      min_periods: 1,
+      closed: "right",
+      warn_if_unsorted: nil
+    )
+      window_size = _prepare_rolling_by_window_args(window_size)
+      by = Utils.parse_into_expression(by)
+      _from_rbexpr(
+        _rbexpr.rolling_median_by(by, window_size, min_periods, closed)
+      )
+    end
+
+    # Compute a rolling quantile based on another column.
+    #
+    # @param by [String]
+    #   This column must be of dtype Datetime or Date.
+    # @param quantile [Float]
+    #   Quantile between 0.0 and 1.0.
+    # @param interpolation ['nearest', 'higher', 'lower', 'midpoint', 'linear']
+    #   Interpolation method.
+    # @param window_size  [String]
+    #   The length of the window. Can be a dynamic
+    #   temporal size indicated by a timedelta or the following string language:
+    #
+    #   - 1ns   (1 nanosecond)
+    #   - 1us   (1 microsecond)
+    #   - 1ms   (1 millisecond)
+    #   - 1s    (1 second)
+    #   - 1m    (1 minute)
+    #   - 1h    (1 hour)
+    #   - 1d    (1 calendar day)
+    #   - 1w    (1 calendar week)
+    #   - 1mo   (1 calendar month)
+    #   - 1q    (1 calendar quarter)
+    #   - 1y    (1 calendar year)
+    #
+    #   By "calendar day", we mean the corresponding time on the next day
+    #   (which may not be 24 hours, due to daylight savings). Similarly for
+    #   "calendar week", "calendar month", "calendar quarter", and
+    #   "calendar year".
+    # @param min_periods [Integer]
+    #   The number of values in the window that should be non-null before computing
+    #   a result.
+    # @param closed ['left', 'right', 'both', 'none']
+    #   Define which sides of the temporal interval are closed (inclusive),
+    #   defaults to `'right'`.
+    # @param warn_if_unsorted [Boolean]
+    #   Warn if data is not known to be sorted by `by` column.
+    #
+    # @return [Expr]
+    #
+    # @note
+    #   If you want to compute multiple aggregation statistics over the same dynamic
+    #   window, consider using `rolling` - this method can cache the window size
+    #   computation.
+    #
+    # @example Create a DataFrame with a datetime column and a row number column
+    #   start = DateTime.new(2001, 1, 1)
+    #   stop = DateTime.new(2001, 1, 2)
+    #   df_temporal = Polars::DataFrame.new(
+    #       {"date" => Polars.datetime_range(start, stop, "1h", eager: true)}
+    #   ).with_row_index
+    #   # =>
+    #   # shape: (25, 2)
+    #   # ┌───────┬─────────────────────┐
+    #   # │ index ┆ date                │
+    #   # │ ---   ┆ ---                 │
+    #   # │ u32   ┆ datetime[ns]        │
+    #   # ╞═══════╪═════════════════════╡
+    #   # │ 0     ┆ 2001-01-01 00:00:00 │
+    #   # │ 1     ┆ 2001-01-01 01:00:00 │
+    #   # │ 2     ┆ 2001-01-01 02:00:00 │
+    #   # │ 3     ┆ 2001-01-01 03:00:00 │
+    #   # │ 4     ┆ 2001-01-01 04:00:00 │
+    #   # │ …     ┆ …                   │
+    #   # │ 20    ┆ 2001-01-01 20:00:00 │
+    #   # │ 21    ┆ 2001-01-01 21:00:00 │
+    #   # │ 22    ┆ 2001-01-01 22:00:00 │
+    #   # │ 23    ┆ 2001-01-01 23:00:00 │
+    #   # │ 24    ┆ 2001-01-02 00:00:00 │
+    #   # └───────┴─────────────────────┘
+    #
+    # @example Compute the rolling quantile with the temporal windows closed on the right:
+    #   df_temporal.with_columns(
+    #     rolling_row_quantile: Polars.col("index").rolling_quantile_by(
+    #       "date", "2h", quantile: 0.3
+    #     )
+    #   )
+    #   # =>
+    #   # shape: (25, 3)
+    #   # ┌───────┬─────────────────────┬──────────────────────┐
+    #   # │ index ┆ date                ┆ rolling_row_quantile │
+    #   # │ ---   ┆ ---                 ┆ ---                  │
+    #   # │ u32   ┆ datetime[ns]        ┆ f64                  │
+    #   # ╞═══════╪═════════════════════╪══════════════════════╡
+    #   # │ 0     ┆ 2001-01-01 00:00:00 ┆ 0.0                  │
+    #   # │ 1     ┆ 2001-01-01 01:00:00 ┆ 0.0                  │
+    #   # │ 2     ┆ 2001-01-01 02:00:00 ┆ 1.0                  │
+    #   # │ 3     ┆ 2001-01-01 03:00:00 ┆ 2.0                  │
+    #   # │ 4     ┆ 2001-01-01 04:00:00 ┆ 3.0                  │
+    #   # │ …     ┆ …                   ┆ …                    │
+    #   # │ 20    ┆ 2001-01-01 20:00:00 ┆ 19.0                 │
+    #   # │ 21    ┆ 2001-01-01 21:00:00 ┆ 20.0                 │
+    #   # │ 22    ┆ 2001-01-01 22:00:00 ┆ 21.0                 │
+    #   # │ 23    ┆ 2001-01-01 23:00:00 ┆ 22.0                 │
+    #   # │ 24    ┆ 2001-01-02 00:00:00 ┆ 23.0                 │
+    #   # └───────┴─────────────────────┴──────────────────────┘
+    def rolling_quantile_by(
+      by,
+      window_size,
+      quantile:,
+      interpolation: "nearest",
+      min_periods: 1,
+      closed: "right",
+      warn_if_unsorted: nil
+    )
+      window_size = _prepare_rolling_by_window_args(window_size)
+      by = Utils.parse_into_expression(by)
+      _from_rbexpr(
+        _rbexpr.rolling_quantile_by(
+          by,
+          quantile,
+          interpolation,
+          window_size,
+          min_periods,
+          closed,
+        )
+      )
+    end
+
     # Apply a rolling min (moving min) over the values in this array.
     #
     # A window of length `window_size` will traverse the array. The values that fill
@@ -3889,12 +4937,6 @@ module Polars
     #   a result. If None, it will be set equal to window size.
     # @param center [Boolean]
     #   Set the labels at the center of the window
-    # @param by [String]
-    #   If the `window_size` is temporal for instance `"5h"` or `"3s`, you must
-    #   set the column that will be used to determine the windows. This column must
-    #   be of dtype `{Date, Datetime}`
-    # @param closed ["left", "right", "both", "none"]
-    #   Define whether the temporal window interval is closed or not.
     #
     # @note
     #   This functionality is experimental and may change without it being considered a
@@ -3932,16 +4974,11 @@ module Polars
       window_size,
       weights: nil,
       min_periods: nil,
-      center: false,
-      by: nil,
-      closed: nil
+      center: false
     )
-      window_size, min_periods = _prepare_rolling_window_args(
-        window_size, min_periods
-      )
       _from_rbexpr(
         _rbexpr.rolling_min(
-          window_size, weights, min_periods, center, by, closed
+          window_size, weights, min_periods, center
         )
       )
     end
@@ -3978,12 +5015,6 @@ module Polars
     #   a result. If None, it will be set equal to window size.
     # @param center [Boolean]
     #   Set the labels at the center of the window
-    # @param by [String]
-    #   If the `window_size` is temporal for instance `"5h"` or `"3s`, you must
-    #   set the column that will be used to determine the windows. This column must
-    #   be of dtype `{Date, Datetime}`
-    # @param closed ["left", "right", "both", "none"]
-    #   Define whether the temporal window interval is closed or not.
     #
     # @note
     #   This functionality is experimental and may change without it being considered a
@@ -4021,16 +5052,11 @@ module Polars
       window_size,
       weights: nil,
       min_periods: nil,
-      center: false,
-      by: nil,
-      closed: nil
+      center: false
     )
-      window_size, min_periods = _prepare_rolling_window_args(
-        window_size, min_periods
-      )
       _from_rbexpr(
         _rbexpr.rolling_max(
-          window_size, weights, min_periods, center, by, closed
+          window_size, weights, min_periods, center
         )
       )
     end
@@ -4067,12 +5093,6 @@ module Polars
     #   a result. If None, it will be set equal to window size.
     # @param center [Boolean]
     #   Set the labels at the center of the window
-    # @param by [String]
-    #   If the `window_size` is temporal for instance `"5h"` or `"3s`, you must
-    #   set the column that will be used to determine the windows. This column must
-    #   be of dtype `{Date, Datetime}`
-    # @param closed ["left", "right", "both", "none"]
-    #   Define whether the temporal window interval is closed or not.
     #
     # @note
     #   This functionality is experimental and may change without it being considered a
@@ -4110,16 +5130,11 @@ module Polars
       window_size,
       weights: nil,
       min_periods: nil,
-      center: false,
-      by: nil,
-      closed: nil
+      center: false
     )
-      window_size, min_periods = _prepare_rolling_window_args(
-        window_size, min_periods
-      )
       _from_rbexpr(
         _rbexpr.rolling_mean(
-          window_size, weights, min_periods, center, by, closed
+          window_size, weights, min_periods, center
         )
       )
     end
@@ -4156,12 +5171,6 @@ module Polars
     #   a result. If None, it will be set equal to window size.
     # @param center [Boolean]
     #   Set the labels at the center of the window
-    # @param by [String]
-    #   If the `window_size` is temporal for instance `"5h"` or `"3s`, you must
-    #   set the column that will be used to determine the windows. This column must
-    #   be of dtype `{Date, Datetime}`
-    # @param closed ["left", "right", "both", "none"]
-    #   Define whether the temporal window interval is closed or not.
     #
     # @note
     #   This functionality is experimental and may change without it being considered a
@@ -4199,16 +5208,11 @@ module Polars
       window_size,
       weights: nil,
       min_periods: nil,
-      center: false,
-      by: nil,
-      closed: nil
+      center: false
     )
-      window_size, min_periods = _prepare_rolling_window_args(
-        window_size, min_periods
-      )
       _from_rbexpr(
         _rbexpr.rolling_sum(
-          window_size, weights, min_periods, center, by, closed
+          window_size, weights, min_periods, center
         )
       )
     end
@@ -4245,12 +5249,6 @@ module Polars
     #   a result. If None, it will be set equal to window size.
     # @param center [Boolean]
     #   Set the labels at the center of the window
-    # @param by [String]
-    #   If the `window_size` is temporal for instance `"5h"` or `"3s`, you must
-    #   set the column that will be used to determine the windows. This column must
-    #   be of dtype `{Date, Datetime}`
-    # @param closed ["left", "right", "both", "none"]
-    #   Define whether the temporal window interval is closed or not.
     #
     # @note
     #   This functionality is experimental and may change without it being considered a
@@ -4289,17 +5287,11 @@ module Polars
       weights: nil,
       min_periods: nil,
       center: false,
-      by: nil,
-      closed: nil,
-      ddof: 1,
-      warn_if_unsorted: true
+      ddof: 1
     )
-      window_size, min_periods = _prepare_rolling_window_args(
-        window_size, min_periods
-      )
       _from_rbexpr(
         _rbexpr.rolling_std(
-          window_size, weights, min_periods, center, by, closed, ddof, warn_if_unsorted
+          window_size, weights, min_periods, center, ddof
         )
       )
     end
@@ -4336,12 +5328,6 @@ module Polars
     #   a result. If None, it will be set equal to window size.
     # @param center [Boolean]
     #   Set the labels at the center of the window
-    # @param by [String]
-    #   If the `window_size` is temporal for instance `"5h"` or `"3s`, you must
-    #   set the column that will be used to determine the windows. This column must
-    #   be of dtype `{Date, Datetime}`
-    # @param closed ["left", "right", "both", "none"]
-    #   Define whether the temporal window interval is closed or not.
     #
     # @note
     #   This functionality is experimental and may change without it being considered a
@@ -4380,17 +5366,11 @@ module Polars
       weights: nil,
       min_periods: nil,
       center: false,
-      by: nil,
-      closed: nil,
-      ddof: 1,
-      warn_if_unsorted: true
+      ddof: 1
     )
-      window_size, min_periods = _prepare_rolling_window_args(
-        window_size, min_periods
-      )
       _from_rbexpr(
         _rbexpr.rolling_var(
-          window_size, weights, min_periods, center, by, closed, ddof, warn_if_unsorted
+          window_size, weights, min_periods, center, ddof
         )
       )
     end
@@ -4423,12 +5403,6 @@ module Polars
     #   a result. If None, it will be set equal to window size.
     # @param center [Boolean]
     #   Set the labels at the center of the window
-    # @param by [String]
-    #   If the `window_size` is temporal for instance `"5h"` or `"3s`, you must
-    #   set the column that will be used to determine the windows. This column must
-    #   be of dtype `{Date, Datetime}`
-    # @param closed ["left", "right", "both", "none"]
-    #   Define whether the temporal window interval is closed or not.
     #
     # @note
     #   This functionality is experimental and may change without it being considered a
@@ -4466,17 +5440,11 @@ module Polars
       window_size,
       weights: nil,
       min_periods: nil,
-      center: false,
-      by: nil,
-      closed: nil,
-      warn_if_unsorted: true
+      center: false
     )
-      window_size, min_periods = _prepare_rolling_window_args(
-        window_size, min_periods
-      )
       _from_rbexpr(
         _rbexpr.rolling_median(
-          window_size, weights, min_periods, center, by, closed, warn_if_unsorted
+          window_size, weights, min_periods, center
         )
       )
     end
@@ -4513,12 +5481,6 @@ module Polars
     #   a result. If None, it will be set equal to window size.
     # @param center [Boolean]
     #   Set the labels at the center of the window
-    # @param by [String]
-    #   If the `window_size` is temporal for instance `"5h"` or `"3s`, you must
-    #   set the column that will be used to determine the windows. This column must
-    #   be of dtype `{Date, Datetime}`
-    # @param closed ["left", "right", "both", "none"]
-    #   Define whether the temporal window interval is closed or not.
     #
     # @note
     #   This functionality is experimental and may change without it being considered a
@@ -4558,17 +5520,11 @@ module Polars
       window_size: 2,
       weights: nil,
       min_periods: nil,
-      center: false,
-      by: nil,
-      closed: nil,
-      warn_if_unsorted: true
+      center: false
     )
-      window_size, min_periods = _prepare_rolling_window_args(
-        window_size, min_periods
-      )
       _from_rbexpr(
         _rbexpr.rolling_quantile(
-          quantile, interpolation, window_size, weights, min_periods, center, by, closed, warn_if_unsorted
+          quantile, interpolation, window_size, weights, min_periods, center
         )
       )
     end
@@ -4837,7 +5793,7 @@ module Polars
     #   # │ 12   ┆ 0.0        │
     #   # └──────┴────────────┘
     def pct_change(n: 1)
-      n = Utils.parse_as_expression(n)
+      n = Utils.parse_into_expression(n)
       _from_rbexpr(_rbexpr.pct_change(n))
     end
 
@@ -4929,12 +5885,12 @@ module Polars
     #   # │ null ┆ null        │
     #   # │ 50   ┆ 10          │
     #   # └──────┴─────────────┘
-    def clip(lower_bound, upper_bound)
+    def clip(lower_bound = nil, upper_bound = nil)
       if !lower_bound.nil?
-        lower_bound = Utils.parse_as_expression(lower_bound, str_as_lit: true)
+        lower_bound = Utils.parse_into_expression(lower_bound)
       end
       if !upper_bound.nil?
-        upper_bound = Utils.parse_as_expression(upper_bound, str_as_lit: true)
+        upper_bound = Utils.parse_into_expression(upper_bound)
       end
       _from_rbexpr(_rbexpr.clip(lower_bound, upper_bound))
     end
@@ -5321,18 +6277,38 @@ module Polars
     #
     # @example
     #   df = Polars::DataFrame.new({"foo" => [1, 2, 3, 4, 5, 6, 7, 8, 9]})
-    #   df.select(Polars.col("foo").reshape([3, 3]))
+    #   square = df.select(Polars.col("foo").reshape([3, 3]))
     #   # =>
     #   # shape: (3, 1)
-    #   # ┌───────────┐
-    #   # │ foo       │
-    #   # │ ---       │
-    #   # │ list[i64] │
-    #   # ╞═══════════╡
-    #   # │ [1, 2, 3] │
-    #   # │ [4, 5, 6] │
-    #   # │ [7, 8, 9] │
-    #   # └───────────┘
+    #   # ┌───────────────┐
+    #   # │ foo           │
+    #   # │ ---           │
+    #   # │ array[i64, 3] │
+    #   # ╞═══════════════╡
+    #   # │ [1, 2, 3]     │
+    #   # │ [4, 5, 6]     │
+    #   # │ [7, 8, 9]     │
+    #   # └───────────────┘
+    #
+    # @example
+    #   square.select(Polars.col("foo").reshape([9]))
+    #   # =>
+    #   # shape: (9, 1)
+    #   # ┌─────┐
+    #   # │ foo │
+    #   # │ --- │
+    #   # │ i64 │
+    #   # ╞═════╡
+    #   # │ 1   │
+    #   # │ 2   │
+    #   # │ 3   │
+    #   # │ 4   │
+    #   # │ 5   │
+    #   # │ 6   │
+    #   # │ 7   │
+    #   # │ 8   │
+    #   # │ 9   │
+    #   # └─────┘
     def reshape(dims)
       _from_rbexpr(_rbexpr.reshape(dims))
     end
@@ -5408,14 +6384,14 @@ module Polars
       end
 
       if !n.nil? && frac.nil?
-        n = Utils.parse_as_expression(n)
+        n = Utils.parse_into_expression(n)
         return _from_rbexpr(_rbexpr.sample_n(n, with_replacement, shuffle, seed))
       end
 
       if frac.nil?
         frac = 1.0
       end
-      frac = Utils.parse_as_expression(frac)
+      frac = Utils.parse_into_expression(frac)
       _from_rbexpr(
         _rbexpr.sample_frac(frac, with_replacement, shuffle, seed)
       )
@@ -5548,11 +6524,17 @@ module Polars
 
     # Count all unique values and create a struct mapping value to count.
     #
-    # @param multithreaded [Boolean]
-    #   Better to turn this off in the aggregation context, as it can lead to
-    #   contention.
     # @param sort [Boolean]
-    #   Ensure the output is sorted from most values to least.
+    #   Sort the output by count in descending order.
+    #   If set to `false` (default), the order of the output is random.
+    # @param parallel [Boolean]
+    #   Execute the computation in parallel.
+    # @param name [String]
+    #   Give the resulting count column a specific name;
+    #   if `normalize` is true defaults to "count",
+    #   otherwise defaults to "proportion".
+    # @param normalize [Boolean]
+    #   If true gives relative frequencies of the unique values
     #
     # @return [Expr]
     #
@@ -5578,8 +6560,22 @@ module Polars
     #   # │ {"b",2}   │
     #   # │ {"a",1}   │
     #   # └───────────┘
-    def value_counts(multithreaded: false, sort: false)
-      _from_rbexpr(_rbexpr.value_counts(multithreaded, sort))
+    def value_counts(
+      sort: false,
+      parallel: false,
+      name: nil,
+      normalize: false
+    )
+      if name.nil?
+        if normalize
+          name = "proportion"
+        else
+          name = "count"
+        end
+      end
+      _from_rbexpr(
+        _rbexpr.value_counts(sort, parallel, name, normalize)
+      )
     end
 
     # Return a count of the unique values in the order of appearance.
@@ -5954,6 +6950,10 @@ module Polars
     #   # │ 3   ┆ 1.0 ┆ 10.0     │
     #   # └─────┴─────┴──────────┘
     def replace(old, new = NO_DEFAULT, default: NO_DEFAULT, return_dtype: nil)
+      if !default.eql?(NO_DEFAULT)
+        return replace_strict(old, new, default: default, return_dtype: return_dtype)
+      end
+
       if new.eql?(NO_DEFAULT) && old.is_a?(Hash)
         new = Series.new(old.values)
         old = Series.new(old.keys)
@@ -5966,17 +6966,164 @@ module Polars
         end
       end
 
-      old = Utils.parse_as_expression(old, str_as_lit: true)
-      new = Utils.parse_as_expression(new, str_as_lit: true)
+      old = Utils.parse_into_expression(old, str_as_lit: true)
+      new = Utils.parse_into_expression(new, str_as_lit: true)
 
-      default =
-        if default.eql?(NO_DEFAULT)
-          nil
-        else
-          Utils.parse_as_expression(default, str_as_lit: true)
-        end
+      result = _from_rbexpr(_rbexpr.replace(old, new))
+
+      if !return_dtype.nil?
+        result = result.cast(return_dtype)
+      end
 
-      _from_rbexpr(_rbexpr.replace(old, new, default, return_dtype))
+      result
+    end
+
+    # Replace all values by different values.
+    #
+    # @param old [Object]
+    #   Value or sequence of values to replace.
+    #   Accepts expression input. Sequences are parsed as Series,
+    #   other non-expression inputs are parsed as literals.
+    #   Also accepts a mapping of values to their replacement as syntactic sugar for
+    #   `replace_all(old: Series.new(mapping.keys), new: Serie.new(mapping.values))`.
+    # @param new [Object]
+    #   Value or sequence of values to replace by.
+    #   Accepts expression input. Sequences are parsed as Series,
+    #   other non-expression inputs are parsed as literals.
+    #   Length must match the length of `old` or have length 1.
+    # @param default [Object]
+    #   Set values that were not replaced to this value. If no default is specified,
+    #   (default), an error is raised if any values were not replaced.
+    #   Accepts expression input. Non-expression inputs are parsed as literals.
+    # @param return_dtype [Object]
+    #   The data type of the resulting expression. If set to `nil` (default),
+    #   the data type is determined automatically based on the other inputs.
+    #
+    # @return [Expr]
+    #
+    # @note
+    #   The global string cache must be enabled when replacing categorical values.
+    #
+    # @example Replace values by passing sequences to the `old` and `new` parameters.
+    #   df = Polars::DataFrame.new({"a" => [1, 2, 2, 3]})
+    #   df.with_columns(
+    #     replaced: Polars.col("a").replace_strict([1, 2, 3], [100, 200, 300])
+    #   )
+    #   # =>
+    #   # shape: (4, 2)
+    #   # ┌─────┬──────────┐
+    #   # │ a   ┆ replaced │
+    #   # │ --- ┆ ---      │
+    #   # │ i64 ┆ i64      │
+    #   # ╞═════╪══════════╡
+    #   # │ 1   ┆ 100      │
+    #   # │ 2   ┆ 200      │
+    #   # │ 2   ┆ 200      │
+    #   # │ 3   ┆ 300      │
+    #   # └─────┴──────────┘
+    #
+    # @example By default, an error is raised if any non-null values were not replaced. Specify a default to set all values that were not matched.
+    #   mapping = {2 => 200, 3 => 300}
+    #   df.with_columns(replaced: Polars.col("a").replace_strict(mapping, default: -1))
+    #   # =>
+    #   # shape: (4, 2)
+    #   # ┌─────┬──────────┐
+    #   # │ a   ┆ replaced │
+    #   # │ --- ┆ ---      │
+    #   # │ i64 ┆ i64      │
+    #   # ╞═════╪══════════╡
+    #   # │ 1   ┆ -1       │
+    #   # │ 2   ┆ 200      │
+    #   # │ 2   ┆ 200      │
+    #   # │ 3   ┆ 300      │
+    #   # └─────┴──────────┘
+    #
+    # @example Replacing by values of a different data type sets the return type based on a combination of the `new` data type and the `default` data type.
+    #   df = Polars::DataFrame.new({"a" => ["x", "y", "z"]})
+    #   mapping = {"x" => 1, "y" => 2, "z" => 3}
+    #   df.with_columns(replaced: Polars.col("a").replace_strict(mapping))
+    #   # =>
+    #   # shape: (3, 2)
+    #   # ┌─────┬──────────┐
+    #   # │ a   ┆ replaced │
+    #   # │ --- ┆ ---      │
+    #   # │ str ┆ i64      │
+    #   # ╞═════╪══════════╡
+    #   # │ x   ┆ 1        │
+    #   # │ y   ┆ 2        │
+    #   # │ z   ┆ 3        │
+    #   # └─────┴──────────┘
+    #
+    # @example
+    #   df.with_columns(replaced: Polars.col("a").replace_strict(mapping, default: "x"))
+    #   # =>
+    #   # shape: (3, 2)
+    #   # ┌─────┬──────────┐
+    #   # │ a   ┆ replaced │
+    #   # │ --- ┆ ---      │
+    #   # │ str ┆ str      │
+    #   # ╞═════╪══════════╡
+    #   # │ x   ┆ 1        │
+    #   # │ y   ┆ 2        │
+    #   # │ z   ┆ 3        │
+    #   # └─────┴──────────┘
+    #
+    # @example Set the `return_dtype` parameter to control the resulting data type directly.
+    #   df.with_columns(
+    #     replaced: Polars.col("a").replace_strict(mapping, return_dtype: Polars::UInt8)
+    #   )
+    #   # =>
+    #   # shape: (3, 2)
+    #   # ┌─────┬──────────┐
+    #   # │ a   ┆ replaced │
+    #   # │ --- ┆ ---      │
+    #   # │ str ┆ u8       │
+    #   # ╞═════╪══════════╡
+    #   # │ x   ┆ 1        │
+    #   # │ y   ┆ 2        │
+    #   # │ z   ┆ 3        │
+    #   # └─────┴──────────┘
+    #
+    # @example Expression input is supported for all parameters.
+    #   df = Polars::DataFrame.new({"a" => [1, 2, 2, 3], "b" => [1.5, 2.5, 5.0, 1.0]})
+    #   df.with_columns(
+    #     replaced: Polars.col("a").replace_strict(
+    #       Polars.col("a").max,
+    #       Polars.col("b").sum,
+    #       default: Polars.col("b")
+    #     )
+    #   )
+    #   # =>
+    #   # shape: (4, 3)
+    #   # ┌─────┬─────┬──────────┐
+    #   # │ a   ┆ b   ┆ replaced │
+    #   # │ --- ┆ --- ┆ ---      │
+    #   # │ i64 ┆ f64 ┆ f64      │
+    #   # ╞═════╪═════╪══════════╡
+    #   # │ 1   ┆ 1.5 ┆ 1.5      │
+    #   # │ 2   ┆ 2.5 ┆ 2.5      │
+    #   # │ 2   ┆ 5.0 ┆ 5.0      │
+    #   # │ 3   ┆ 1.0 ┆ 10.0     │
+    #   # └─────┴─────┴──────────┘
+    def replace_strict(
+      old,
+      new = NO_DEFAULT,
+      default: NO_DEFAULT,
+      return_dtype: nil
+    )
+      if new.eql?(NO_DEFAULT) && old.is_a?(Hash)
+        new = Series.new(old.values)
+        old = Series.new(old.keys)
+      end
+
+      old = Utils.parse_into_expression(old, str_as_lit: true, list_as_series: true)
+      new = Utils.parse_into_expression(new, str_as_lit: true, list_as_series: true)
+
+      default = default.eql?(NO_DEFAULT) ? nil : Utils.parse_into_expression(default, str_as_lit: true)
+
+      _from_rbexpr(
+        _rbexpr.replace_strict(old, new, default, return_dtype)
+      )
     end
 
     # Create an object namespace of all list related methods.
@@ -6053,7 +7200,7 @@ module Polars
     end
 
     def _to_expr(other)
-      other.is_a?(Expr) ? other : Utils.lit(other)
+      other.is_a?(Expr) ? other : F.lit(other)
     end
 
     def _prepare_alpha(com, span, half_life, alpha)
@@ -6101,5 +7248,9 @@ module Polars
       end
       [window_size, min_periods]
     end
+
+    def _prepare_rolling_by_window_args(window_size)
+      window_size
+    end
   end
 end