polars-df 0.15.0 → 0.26.0

data/lib/polars/expr.rb

@@ -1,9 +1,6 @@
 module Polars
   # Expressions that can be used in various contexts.
   class Expr
-    # @private
-    NO_DEFAULT = Object.new
-
     # @private
     attr_accessor :_rbexpr
 
@@ -26,56 +23,59 @@ module Polars
     #
     # @return [Expr]
     def ^(other)
-      _from_rbexpr(_rbexpr._xor(_to_rbexpr(other)))
+      other = Utils.parse_into_expression(other)
+      wrap_expr(_rbexpr.xor_(other))
     end
 
     # Bitwise AND.
     #
     # @return [Expr]
     def &(other)
-      _from_rbexpr(_rbexpr._and(_to_rbexpr(other)))
+      other = Utils.parse_into_expression(other)
+      wrap_expr(_rbexpr.and_(other))
     end
 
     # Bitwise OR.
     #
     # @return [Expr]
     def |(other)
-      _from_rbexpr(_rbexpr._or(_to_rbexpr(other)))
+      other = Utils.parse_into_expression(other)
+      wrap_expr(_rbexpr.or_(other))
     end
 
     # Performs addition.
     #
     # @return [Expr]
     def +(other)
-      _from_rbexpr(_rbexpr + _to_rbexpr(other))
+      wrap_expr(_rbexpr + _to_rbexpr(other))
     end
 
     # Performs subtraction.
     #
     # @return [Expr]
     def -(other)
-      _from_rbexpr(_rbexpr - _to_rbexpr(other))
+      wrap_expr(_rbexpr - _to_rbexpr(other))
     end
 
     # Performs multiplication.
     #
     # @return [Expr]
     def *(other)
-      _from_rbexpr(_rbexpr * _to_rbexpr(other))
+      wrap_expr(_rbexpr * _to_rbexpr(other))
     end
 
     # Performs division.
     #
     # @return [Expr]
     def /(other)
-      _from_rbexpr(_rbexpr / _to_rbexpr(other))
+      wrap_expr(_rbexpr / _to_rbexpr(other))
     end
 
     # Returns the modulo.
     #
     # @return [Expr]
     def %(other)
-      _from_rbexpr(_rbexpr % _to_rbexpr(other))
+      wrap_expr(_rbexpr % _to_rbexpr(other))
     end
 
     # Raises to the power of exponent.
@@ -83,49 +83,49 @@ module Polars
     # @return [Expr]
     def **(power)
       exponent = Utils.parse_into_expression(power)
-      _from_rbexpr(_rbexpr.pow(exponent))
+      wrap_expr(_rbexpr.pow(exponent))
     end
 
     # Greater than or equal.
     #
     # @return [Expr]
     def >=(other)
-      _from_rbexpr(_rbexpr.gt_eq(_to_expr(other)._rbexpr))
+      wrap_expr(_rbexpr.gt_eq(_to_expr(other)._rbexpr))
     end
 
     # Less than or equal.
     #
     # @return [Expr]
     def <=(other)
-      _from_rbexpr(_rbexpr.lt_eq(_to_expr(other)._rbexpr))
+      wrap_expr(_rbexpr.lt_eq(_to_expr(other)._rbexpr))
     end
 
     # Equal.
     #
     # @return [Expr]
     def ==(other)
-      _from_rbexpr(_rbexpr.eq(_to_expr(other)._rbexpr))
+      wrap_expr(_rbexpr.eq(_to_expr(other)._rbexpr))
     end
 
     # Not equal.
     #
     # @return [Expr]
     def !=(other)
-      _from_rbexpr(_rbexpr.neq(_to_expr(other)._rbexpr))
+      wrap_expr(_rbexpr.neq(_to_expr(other)._rbexpr))
     end
 
     # Less than.
     #
     # @return [Expr]
     def <(other)
-      _from_rbexpr(_rbexpr.lt(_to_expr(other)._rbexpr))
+      wrap_expr(_rbexpr.lt(_to_expr(other)._rbexpr))
     end
 
     # Greater than.
     #
     # @return [Expr]
     def >(other)
-      _from_rbexpr(_rbexpr.gt(_to_expr(other)._rbexpr))
+      wrap_expr(_rbexpr.gt(_to_expr(other)._rbexpr))
     end
 
     # Performs boolean not.
@@ -134,31 +134,59 @@ module Polars
     def !
       is_not
     end
+    alias_method :~, :!
 
     # Performs negation.
     #
     # @return [Expr]
     def -@
-      _from_rbexpr(_rbexpr.neg)
+      wrap_expr(_rbexpr.neg)
     end
 
-    # Cast to physical representation of the logical dtype.
+    # Read a serialized expression from a file.
+    #
+    # @param source [Object]
+    #   Path to a file or a file-like object (by file-like object, we refer to
+    #   objects that have a `read` method, such as a file handler or `StringIO`).
+    #
+    # @return [Expr]
+    #
+    # @note
+    #   This function uses  marshaling if the logical plan contains Ruby UDFs,
+    #   and as such inherits the security implications. Deserializing can execute
+    #   arbitrary code, so it should only be attempted on trusted data.
+    #
+    # @note
+    #   Serialization is not stable across Polars versions: a LazyFrame serialized
+    #   in one Polars version may not be deserializable in another Polars version.
     #
-    # - `:date` -> `:i32`
-    # - `:datetime` -> `:i64`
-    # - `:time` -> `:i64`
-    # - `:duration` -> `:i64`
-    # - `:cat` -> `:u32`
-    # - Other data types will be left unchanged.
+    # @example
+    #   expr = Polars.col("foo").sum.over("bar")
+    #   bytes = expr.meta.serialize
+    #   Polars::Expr.deserialize(StringIO.new(bytes))
+    #   # => col("foo").sum().over([col("bar")])
+    def self.deserialize(source)
+      raise Todo unless RbExpr.respond_to?(:deserialize_binary)
+
+      if Utils.pathlike?(source)
+        source = Utils.normalize_filepath(source)
+      end
+
+      deserializer = RbExpr.method(:deserialize_binary)
+
+      _from_rbexpr(deserializer.(source))
+    end
+
+    # Cast to physical representation of the logical dtype.
     #
     # @return [Expr]
     #
     # @example
     #   Polars::DataFrame.new({"vals" => ["a", "x", nil, "a"]}).with_columns(
     #     [
-    #       Polars.col("vals").cast(:cat),
+    #       Polars.col("vals").cast(Polars::Categorical),
     #       Polars.col("vals")
-    #         .cast(:cat)
+    #         .cast(Polars::Categorical)
     #         .to_physical
     #         .alias("vals_physical")
     #     ]
@@ -176,7 +204,7 @@ module Polars
     #   # │ a    ┆ 0             │
     #   # └──────┴───────────────┘
     def to_physical
-      _from_rbexpr(_rbexpr.to_physical)
+      wrap_expr(_rbexpr.to_physical)
     end
 
     # Check if any boolean value in a Boolean column is `true`.
@@ -195,8 +223,8 @@ module Polars
     #   # ╞══════╪═══════╡
     #   # │ true ┆ false │
     #   # └──────┴───────┘
-    def any(drop_nulls: true)
-      _from_rbexpr(_rbexpr.any(drop_nulls))
+    def any(ignore_nulls: true)
+      wrap_expr(_rbexpr.any(ignore_nulls))
     end
 
     # Check if all boolean values in a Boolean column are `true`.
@@ -220,8 +248,66 @@ module Polars
     #   # ╞══════╪═══════╪═══════╡
     #   # │ true ┆ false ┆ false │
     #   # └──────┴───────┴───────┘
-    def all(drop_nulls: true)
-      _from_rbexpr(_rbexpr.all(drop_nulls))
+    def all(ignore_nulls: true)
+      wrap_expr(_rbexpr.all(ignore_nulls))
+    end
+
+    # Return whether the column is empty.
+    #
+    # @note
+    #   This functionality is considered **unstable**. It may be changed
+    #   at any point without it being considered a breaking change.
+    #
+    # @param ignore_nulls [Boolean]
+    #   If true a column containing only nulls will also be considered empty.
+    #   The default is false.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"x" => [nil, nil]})
+    #   df.select(
+    #     a: Polars.col("x").is_empty,
+    #     b: Polars.col("x").drop_nulls.is_empty,
+    #     c: Polars.col("x").is_empty(ignore_nulls: true)
+    #   )
+    #   # =>
+    #   # shape: (1, 3)
+    #   # ┌───────┬──────┬──────┐
+    #   # │ a     ┆ b    ┆ c    │
+    #   # │ ---   ┆ ---  ┆ ---  │
+    #   # │ bool  ┆ bool ┆ bool │
+    #   # ╞═══════╪══════╪══════╡
+    #   # │ false ┆ true ┆ true │
+    #   # └───────┴──────┴──────┘
+    def is_empty(ignore_nulls: false)
+      wrap_expr(_rbexpr.is_empty(ignore_nulls))
+    end
+
+    # Return indices where expression evaluates `true`.
+    #
+    # @return [Expr]
+    #
+    # @note
+    #   Modifies number of rows returned, so will fail in combination with other
+    #   expressions. Use as only expression in `select` / `with_columns`.
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"a" => [1, 1, 2, 1]})
+    #   df.select((Polars.col("a") == 1).arg_true)
+    #   # =>
+    #   # shape: (3, 1)
+    #   # ┌─────┐
+    #   # │ a   │
+    #   # │ --- │
+    #   # │ u32 │
+    #   # ╞═════╡
+    #   # │ 0   │
+    #   # │ 1   │
+    #   # │ 3   │
+    #   # └─────┘
+    def arg_true
+      wrap_expr(Plr.arg_where(_rbexpr))
     end
 
     # Compute the square root of the elements.
@@ -243,7 +329,29 @@ module Polars
     #   # │ 2.0      │
     #   # └──────────┘
     def sqrt
-      self**0.5
+      wrap_expr(_rbexpr.sqrt)
+    end
+
+    # Compute the cube root of the elements.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"values" => [1.0, 2.0, 4.0]})
+    #   df.select(Polars.col("values").cbrt)
+    #   # =>
+    #   # shape: (3, 1)
+    #   # ┌──────────┐
+    #   # │ values   │
+    #   # │ ---      │
+    #   # │ f64      │
+    #   # ╞══════════╡
+    #   # │ 1.0      │
+    #   # │ 1.259921 │
+    #   # │ 1.587401 │
+    #   # └──────────┘
+    def cbrt
+      wrap_expr(_rbexpr.cbrt)
     end
 
     # Compute the base 10 logarithm of the input array, element-wise.
@@ -287,7 +395,7 @@ module Polars
     #   # │ 54.59815 │
     #   # └──────────┘
     def exp
-      _from_rbexpr(_rbexpr.exp)
+      wrap_expr(_rbexpr.exp)
     end
 
     # Rename the output of an expression.
@@ -322,23 +430,20 @@ module Polars
     #   # │ 3   ┆ null │
     #   # └─────┴──────┘
     def alias(name)
-      _from_rbexpr(_rbexpr._alias(name))
+      wrap_expr(_rbexpr.alias(name))
     end
 
-    # TODO support symbols for exclude
-
     # Exclude certain columns from a wildcard/regex selection.
     #
     # You may also use regexes in the exclude list. They must start with `^` and end
     # with `$`.
     #
     # @param columns [Object]
-    #   Column(s) to exclude from selection.
-    #   This can be:
-    #
-    #   - a column name, or multiple column names
-    #   - a regular expression starting with `^` and ending with `$`
-    #   - a dtype or multiple dtypes
+    #   The name or datatype of the column(s) to exclude. Accepts regular expression
+    #   input. Regular expressions should start with `^` and end with `$`.
+    # @param more_columns [Array]
+    #   Additional names or datatypes of columns to exclude, specified as positional
+    #   arguments.
     #
     # @return [Expr]
     #
@@ -362,132 +467,56 @@ module Polars
     #   # │ 2   ┆ 2.5  │
     #   # │ 3   ┆ 1.5  │
     #   # └─────┴──────┘
-    def exclude(columns)
-      if columns.is_a?(::String)
-        columns = [columns]
-        return _from_rbexpr(_rbexpr.exclude(columns))
-      elsif !columns.is_a?(::Array)
-        columns = [columns]
-        return _from_rbexpr(_rbexpr.exclude_dtype(columns))
-      end
-
-      if !columns.all? { |a| a.is_a?(::String) } || !columns.all? { |a| Utils.is_polars_dtype(a) }
-        raise ArgumentError, "input should be all string or all DataType"
-      end
-
-      if columns[0].is_a?(::String)
-        _from_rbexpr(_rbexpr.exclude(columns))
-      else
-        _from_rbexpr(_rbexpr.exclude_dtype(columns))
-      end
-    end
-
-    # Keep the original root name of the expression.
-    #
-    # @return [Expr]
-    #
-    # @example
-    #   df = Polars::DataFrame.new(
-    #     {
-    #       "a" => [1, 2],
-    #       "b" => [3, 4]
-    #     }
-    #   )
-    #   df.with_columns([(Polars.col("a") * 9).alias("c").keep_name])
-    #   # =>
-    #   # shape: (2, 2)
-    #   # ┌─────┬─────┐
-    #   # │ a   ┆ b   │
-    #   # │ --- ┆ --- │
-    #   # │ i64 ┆ i64 │
-    #   # ╞═════╪═════╡
-    #   # │ 9   ┆ 3   │
-    #   # │ 18  ┆ 4   │
-    #   # └─────┴─────┘
-    def keep_name
-      name.keep
+    def exclude(columns, *more_columns)
+      meta.as_selector.exclude(columns, *more_columns).as_expr
     end
 
-    # Add a prefix to the root column name of the expression.
-    #
-    # @return [Expr]
+    # Offers a structured way to apply a sequence of user-defined functions (UDFs).
     #
-    # @example
-    #   df = Polars::DataFrame.new(
-    #     {
-    #       "a" => [1, 2, 3],
-    #       "b" => ["x", "y", "z"]
-    #     }
-    #   )
-    #   df.with_columns(Polars.all.reverse.name.prefix("reverse_"))
-    #   # =>
-    #   # shape: (3, 4)
-    #   # ┌─────┬─────┬───────────┬───────────┐
-    #   # │ a   ┆ b   ┆ reverse_a ┆ reverse_b │
-    #   # │ --- ┆ --- ┆ ---       ┆ ---       │
-    #   # │ i64 ┆ str ┆ i64       ┆ str       │
-    #   # ╞═════╪═════╪═══════════╪═══════════╡
-    #   # │ 1   ┆ x   ┆ 3         ┆ z         │
-    #   # │ 2   ┆ y   ┆ 2         ┆ y         │
-    #   # │ 3   ┆ z   ┆ 1         ┆ x         │
-    #   # └─────┴─────┴───────────┴───────────┘
-    def prefix(prefix)
-      name.prefix(prefix)
-    end
-
-    # Add a suffix to the root column name of the expression.
+    # @param function [Object]
+    #   Callable; will receive the expression as the first parameter,
+    #   followed by any given args/kwargs.
+    # @param args [Array]
+    #   Arguments to pass to the UDF.
+    # @param kwargs [Hash]
+    #   Keyword arguments to pass to the UDF.
     #
-    # @return [Expr]
+    # @return [Object]
     #
     # @example
-    #   df = Polars::DataFrame.new(
-    #     {
-    #       "a" => [1, 2, 3],
-    #       "b" => ["x", "y", "z"]
-    #     }
-    #   )
-    #   df.with_columns(Polars.all.reverse.name.suffix("_reverse"))
-    #   # =>
-    #   # shape: (3, 4)
-    #   # ┌─────┬─────┬───────────┬───────────┐
-    #   # │ a   ┆ b   ┆ a_reverse ┆ b_reverse │
-    #   # │ --- ┆ --- ┆ ---       ┆ ---       │
-    #   # │ i64 ┆ str ┆ i64       ┆ str       │
-    #   # ╞═════╪═════╪═══════════╪═══════════╡
-    #   # │ 1   ┆ x   ┆ 3         ┆ z         │
-    #   # │ 2   ┆ y   ┆ 2         ┆ y         │
-    #   # │ 3   ┆ z   ┆ 1         ┆ x         │
-    #   # └─────┴─────┴───────────┴───────────┘
-    def suffix(suffix)
-      name.suffix(suffix)
-    end
-
-    # Rename the output of an expression by mapping a function over the root name.
+    #   extract_number = lambda do |expr|
+    #     # Extract the digits from a string.
+    #     expr.str.extract('\d+', group_index: 0).cast(Polars::Int64)
+    #   end
     #
-    # @return [Expr]
+    #   scale_negative_even = lambda do |expr, n: 1|
+    #     # Set even numbers negative, and scale by a user-supplied value.
+    #     expr = Polars.when(expr % 2 == 0).then(-expr).otherwise(expr)
+    #     expr * n
+    #   end
     #
-    # @example
-    #   df = Polars::DataFrame.new(
-    #     {
-    #       "A" => [1, 2],
-    #       "B" => [3, 4]
-    #     }
-    #   )
-    #   df.select(
-    #     Polars.all.reverse.map_alias { |colName| colName + "_reverse" }
+    #   df = Polars::DataFrame.new({"val" => ["a: 1", "b: 2", "c: 3", "d: 4"]})
+    #   df.with_columns(
+    #     udfs: Polars.col("val").pipe(extract_number).pipe(scale_negative_even, n: 5)
     #   )
     #   # =>
-    #   # shape: (2, 2)
-    #   # ┌───────────┬───────────┐
-    #   # │ A_reverse ┆ B_reverse │
-    #   # │ ---       ┆ ---       │
-    #   # │ i64       ┆ i64       │
-    #   # ╞═══════════╪═══════════╡
-    #   # │ 2         ┆ 4         │
-    #   # │ 1         ┆ 3         │
-    #   # └───────────┴───────────┘
-    def map_alias(&f)
-      name.map(&f)
+    #   # shape: (4, 2)
+    #   # ┌──────┬──────┐
+    #   # │ val  ┆ udfs │
+    #   # │ ---  ┆ ---  │
+    #   # │ str  ┆ i64  │
+    #   # ╞══════╪══════╡
+    #   # │ a: 1 ┆ 5    │
+    #   # │ b: 2 ┆ -10  │
+    #   # │ c: 3 ┆ 15   │
+    #   # │ d: 4 ┆ -20  │
+    #   # └──────┴──────┘
+    def pipe(
+      function,
+      *args,
+      **kwargs
+    )
+      function.(self, *args, **kwargs)
     end
 
     # Negate a boolean expression.
@@ -527,7 +556,7 @@ module Polars
     #   # │ true  │
     #   # └───────┘
     def is_not
-      _from_rbexpr(_rbexpr.not_)
+      wrap_expr(_rbexpr.not_)
     end
     alias_method :not_, :is_not
 
@@ -542,7 +571,7 @@ module Polars
     #       "b" => [1.0, 2.0, Float::NAN, 1.0, 5.0]
     #     }
     #   )
-    #   df.with_column(Polars.all.is_null.suffix("_isnull"))
+    #   df.with_columns(Polars.all.is_null.name.suffix("_isnull"))
     #   # =>
     #   # shape: (5, 4)
     #   # ┌──────┬─────┬──────────┬──────────┐
@@ -557,7 +586,7 @@ module Polars
     #   # │ 5    ┆ 5.0 ┆ false    ┆ false    │
     #   # └──────┴─────┴──────────┴──────────┘
     def is_null
-      _from_rbexpr(_rbexpr.is_null)
+      wrap_expr(_rbexpr.is_null)
     end
 
     # Returns a boolean Series indicating which values are not null.
@@ -571,7 +600,7 @@ module Polars
     #       "b" => [1.0, 2.0, Float::NAN, 1.0, 5.0]
     #     }
     #   )
-    #   df.with_column(Polars.all.is_not_null.suffix("_not_null"))
+    #   df.with_columns(Polars.all.is_not_null.name.suffix("_not_null"))
     #   # =>
     #   # shape: (5, 4)
     #   # ┌──────┬─────┬────────────┬────────────┐
@@ -586,7 +615,7 @@ module Polars
     #   # │ 5    ┆ 5.0 ┆ true       ┆ true       │
     #   # └──────┴─────┴────────────┴────────────┘
     def is_not_null
-      _from_rbexpr(_rbexpr.is_not_null)
+      wrap_expr(_rbexpr.is_not_null)
     end
 
     # Returns a boolean Series indicating which values are finite.
@@ -612,7 +641,7 @@ module Polars
     #   # │ true ┆ false │
     #   # └──────┴───────┘
     def is_finite
-      _from_rbexpr(_rbexpr.is_finite)
+      wrap_expr(_rbexpr.is_finite)
     end
 
     # Returns a boolean Series indicating which values are infinite.
@@ -638,7 +667,7 @@ module Polars
     #   # │ false ┆ true  │
     #   # └───────┴───────┘
     def is_infinite
-      _from_rbexpr(_rbexpr.is_infinite)
+      wrap_expr(_rbexpr.is_infinite)
     end
 
     # Returns a boolean Series indicating which values are NaN.
@@ -656,7 +685,7 @@ module Polars
     #       "b" => [1.0, 2.0, Float::NAN, 1.0, 5.0]
     #     }
     #   )
-    #   df.with_column(Polars.col(Polars::Float64).is_nan.suffix("_isnan"))
+    #   df.with_columns(Polars.col(Polars::Float64).is_nan.name.suffix("_isnan"))
     #   # =>
     #   # shape: (5, 3)
     #   # ┌──────┬─────┬─────────┐
@@ -671,7 +700,7 @@ module Polars
     #   # │ 5    ┆ 5.0 ┆ false   │
     #   # └──────┴─────┴─────────┘
     def is_nan
-      _from_rbexpr(_rbexpr.is_nan)
+      wrap_expr(_rbexpr.is_nan)
     end
 
     # Returns a boolean Series indicating which values are not NaN.
@@ -689,7 +718,7 @@ module Polars
     #       "b" => [1.0, 2.0, Float::NAN, 1.0, 5.0]
     #     }
     #   )
-    #   df.with_column(Polars.col(Polars::Float64).is_not_nan.suffix("_is_not_nan"))
+    #   df.with_columns(Polars.col(Polars::Float64).is_not_nan.name.suffix("_is_not_nan"))
     #   # =>
     #   # shape: (5, 3)
     #   # ┌──────┬─────┬──────────────┐
@@ -704,7 +733,7 @@ module Polars
     #   # │ 5    ┆ 5.0 ┆ true         │
     #   # └──────┴─────┴──────────────┘
     def is_not_nan
-      _from_rbexpr(_rbexpr.is_not_nan)
+      wrap_expr(_rbexpr.is_not_nan)
     end
 
     # Get the group indexes of the group by operation.
@@ -739,7 +768,7 @@ module Polars
     #   # │ two   ┆ [3, 4, 5] │
     #   # └───────┴───────────┘
     def agg_groups
-      _from_rbexpr(_rbexpr.agg_groups)
+      wrap_expr(_rbexpr.agg_groups)
     end
 
     # Count the number of values in this expression.
@@ -759,7 +788,7 @@ module Polars
     #   # │ 3   ┆ 2   │
     #   # └─────┴─────┘
     def count
-      _from_rbexpr(_rbexpr.count)
+      wrap_expr(_rbexpr.count)
     end
 
     # Count the number of values in this expression.
@@ -779,7 +808,7 @@ module Polars
     #   # │ 3   ┆ 3   │
     #   # └─────┴─────┘
     def len
-      _from_rbexpr(_rbexpr.len)
+      wrap_expr(_rbexpr.len)
     end
     alias_method :length, :len
 
@@ -818,7 +847,7 @@ module Polars
       if !length.is_a?(Expr)
         length = Polars.lit(length)
       end
-      _from_rbexpr(_rbexpr.slice(offset._rbexpr, length._rbexpr))
+      wrap_expr(_rbexpr.slice(offset._rbexpr, length._rbexpr))
     end
 
     # Append expressions.
@@ -852,7 +881,7 @@ module Polars
     #   # └─────┴──────┘
     def append(other, upcast: true)
       other = Utils.parse_into_expression(other)
-      _from_rbexpr(_rbexpr.append(other, upcast))
+      wrap_expr(_rbexpr.append(other, upcast))
     end
 
     # Create a single chunk of memory for this Series.
@@ -877,7 +906,7 @@ module Polars
     #   # │ 2      │
     #   # └────────┘
     def rechunk
-      _from_rbexpr(_rbexpr.rechunk)
+      wrap_expr(_rbexpr.rechunk)
     end
 
     # Drop null values.
@@ -904,7 +933,7 @@ module Polars
     #   # │ NaN │
     #   # └─────┘
     def drop_nulls
-      _from_rbexpr(_rbexpr.drop_nulls)
+      wrap_expr(_rbexpr.drop_nulls)
     end
 
     # Drop floating point NaN values.
@@ -931,7 +960,7 @@ module Polars
     #   # │ 4.0  │
     #   # └──────┘
     def drop_nans
-      _from_rbexpr(_rbexpr.drop_nans)
+      wrap_expr(_rbexpr.drop_nans)
     end
 
     # Get an array with the cumulative sum computed at every element.
@@ -942,8 +971,8 @@ module Polars
     # @return [Expr]
     #
     # @note
-    #   Dtypes in `:i8`, `:u8`, `:i16`, and `:u16` are cast to
-    #   `:i64` before summing to prevent overflow issues.
+    #   Dtypes in \\\\{Int8, UInt8, Int16, UInt16} are cast to
+    #   Int64 before summing to prevent overflow issues.
     #
     # @example
     #   df = Polars::DataFrame.new({"a" => [1, 2, 3, 4]})
@@ -966,9 +995,8 @@ module Polars
     #   # │ 10  ┆ 4         │
     #   # └─────┴───────────┘
     def cum_sum(reverse: false)
-      _from_rbexpr(_rbexpr.cum_sum(reverse))
+      wrap_expr(_rbexpr.cum_sum(reverse))
     end
-    alias_method :cumsum, :cum_sum
 
     # Get an array with the cumulative product computed at every element.
     #
@@ -978,8 +1006,8 @@ module Polars
     # @return [Expr]
     #
     # @note
-    #   Dtypes in `:i8`, `:u8`, `:i16`, and `:u16` are cast to
-    #   `:i64` before summing to prevent overflow issues.
+    #   Dtypes in \\\\{Int8, UInt8, Int16, UInt16} are cast to
+    #   Int64 before summing to prevent overflow issues.
     #
     # @example
     #   df = Polars::DataFrame.new({"a" => [1, 2, 3, 4]})
@@ -1002,9 +1030,8 @@ module Polars
     #   # │ 24  ┆ 4         │
     #   # └─────┴───────────┘
     def cum_prod(reverse: false)
-      _from_rbexpr(_rbexpr.cum_prod(reverse))
+      wrap_expr(_rbexpr.cum_prod(reverse))
     end
-    alias_method :cumprod, :cum_prod
 
     # Get an array with the cumulative min computed at every element.
     #
@@ -1034,9 +1061,8 @@ module Polars
     #   # │ 1   ┆ 4         │
     #   # └─────┴───────────┘
     def cum_min(reverse: false)
-      _from_rbexpr(_rbexpr.cum_min(reverse))
+      wrap_expr(_rbexpr.cum_min(reverse))
     end
-    alias_method :cummin, :cum_min
 
     # Get an array with the cumulative max computed at every element.
     #
@@ -1066,9 +1092,8 @@ module Polars
     #   # │ 4   ┆ 4         │
     #   # └─────┴───────────┘
     def cum_max(reverse: false)
-      _from_rbexpr(_rbexpr.cum_max(reverse))
+      wrap_expr(_rbexpr.cum_max(reverse))
     end
-    alias_method :cummax, :cum_max
 
     # Get an array with the cumulative count computed at every element.
     #
@@ -1100,9 +1125,8 @@ module Polars
     #   # │ d    ┆ 3         ┆ 1                 │
     #   # └──────┴───────────┴───────────────────┘
     def cum_count(reverse: false)
-      _from_rbexpr(_rbexpr.cum_count(reverse))
+      wrap_expr(_rbexpr.cum_count(reverse))
     end
-    alias_method :cumcount, :cum_count
 
     # Rounds down to the nearest integer value.
     #
@@ -1126,7 +1150,7 @@ module Polars
     #   # │ 1.0 │
     #   # └─────┘
     def floor
-      _from_rbexpr(_rbexpr.floor)
+      wrap_expr(_rbexpr.floor)
     end
 
     # Rounds up to the nearest integer value.
@@ -1151,13 +1175,20 @@ module Polars
     #   # │ 2.0 │
     #   # └─────┘
     def ceil
-      _from_rbexpr(_rbexpr.ceil)
+      wrap_expr(_rbexpr.ceil)
     end
 
     # Round underlying floating point data by `decimals` digits.
     #
     # @param decimals [Integer]
     #   Number of decimals to round by.
+    # @param mode ['half_to_even', 'half_away_from_zero']
+    #   RoundMode.
+    #
+    #   * *half_to_even*
+    #     round to the nearest even number
+    #   * *half_away_from_zero*
+    #     round to the nearest number away from zero
     #
     # @return [Expr]
     #
@@ -1176,8 +1207,76 @@ module Polars
     #   # │ 1.0 │
     #   # │ 1.2 │
     #   # └─────┘
-    def round(decimals = 0)
-      _from_rbexpr(_rbexpr.round(decimals))
+    def round(decimals = 0, mode: "half_to_even")
+      wrap_expr(_rbexpr.round(decimals, mode))
+    end
+
+    # Round to a number of significant figures.
+    #
+    # @param digits [Integer]
+    #   Number of significant figures to round to.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"a" => [0.01234, 3.333, 1234.0]})
+    #   df.with_columns(Polars.col("a").round_sig_figs(2).alias("round_sig_figs"))
+    #   # =>
+    #   # shape: (3, 2)
+    #   # ┌─────────┬────────────────┐
+    #   # │ a       ┆ round_sig_figs │
+    #   # │ ---     ┆ ---            │
+    #   # │ f64     ┆ f64            │
+    #   # ╞═════════╪════════════════╡
+    #   # │ 0.01234 ┆ 0.012          │
+    #   # │ 3.333   ┆ 3.3            │
+    #   # │ 1234.0  ┆ 1200.0         │
+    #   # └─────────┴────────────────┘
+    def round_sig_figs(digits)
+      wrap_expr(_rbexpr.round_sig_figs(digits))
+    end
+
+    # Truncate numeric data toward zero to `decimals` number of decimal places.
+    #
+    # @param decimals [Integer]
+    #   Number of decimal places to truncate to.
+    #
+    # @return [Expr]
+    #
+    # @note
+    #   Truncation discards the fractional part beyond the given number of decimals.
+    #   For example, when rounding to 0 decimals 0.25, -0.25, 0.99, and -0.99 will
+    #   all round to 0. When rounding to 1 decimal 1.9999 rounds to 1.9 and -1.9999
+    #   rounds to -1.9. There is no tiebreak behaviour at midpoint values as there
+    #   is with :meth:`round` so 0.5 and -0.5 will also round to 0 when decimals=1.
+    #
+    # @note
+    #   This method performs numeric truncation. For truncating temporal
+    #   data (dates/datetimes), use :func:`Expr.dt.truncate` instead.
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"n" => [-9.9999, 0.12345, 1.0251, 8.8765]})
+    #   df.with_columns(
+    #     t0: Polars.col("n").truncate(0),
+    #     t1: Polars.col("n").truncate(1),
+    #     t2: Polars.col("n").truncate(2),
+    #     t3: Polars.col("n").truncate(3),
+    #     t4: Polars.col("n").truncate(4)
+    #   )
+    #   # =>
+    #   # shape: (4, 6)
+    #   # ┌─────────┬──────┬──────┬───────┬────────┬─────────┐
+    #   # │ n       ┆ t0   ┆ t1   ┆ t2    ┆ t3     ┆ t4      │
+    #   # │ ---     ┆ ---  ┆ ---  ┆ ---   ┆ ---    ┆ ---     │
+    #   # │ f64     ┆ f64  ┆ f64  ┆ f64   ┆ f64    ┆ f64     │
+    #   # ╞═════════╪══════╪══════╪═══════╪════════╪═════════╡
+    #   # │ -9.9999 ┆ -9.0 ┆ -9.9 ┆ -9.99 ┆ -9.999 ┆ -9.9999 │
+    #   # │ 0.12345 ┆ 0.0  ┆ 0.1  ┆ 0.12  ┆ 0.123  ┆ 0.1234  │
+    #   # │ 1.0251  ┆ 1.0  ┆ 1.0  ┆ 1.02  ┆ 1.025  ┆ 1.025   │
+    #   # │ 8.8765  ┆ 8.0  ┆ 8.8  ┆ 8.87  ┆ 8.876  ┆ 8.8765  │
+    #   # └─────────┴──────┴──────┴───────┴────────┴─────────┘
+    def truncate(decimals = 0)
+      Utils.wrap_expr(_rbexpr.truncate(decimals))
     end
 
     # Compute the dot/inner product between two Expressions.
@@ -1206,13 +1305,16 @@ module Polars
     #   # └─────┘
     def dot(other)
       other = Utils.parse_into_expression(other, str_as_lit: false)
-      _from_rbexpr(_rbexpr.dot(other))
+      wrap_expr(_rbexpr.dot(other))
     end
 
     # Compute the most occurring value(s).
     #
     # Can return multiple Values.
     #
+    # @param maintain_order [Boolean]
+    #   Maintain order of data. This requires more work.
+    #
     # @return [Expr]
     #
     # @example
@@ -1233,17 +1335,20 @@ module Polars
     #   # │ 1   ┆ 1   │
     #   # │ 1   ┆ 2   │
     #   # └─────┴─────┘
-    def mode
-      _from_rbexpr(_rbexpr.mode)
+    def mode(maintain_order: false)
+      wrap_expr(_rbexpr.mode(maintain_order))
     end
 
     # Cast between data types.
     #
-    # @param dtype [Symbol]
+    # @param dtype [Object]
     #   DataType to cast to.
     # @param strict [Boolean]
     #   Throw an error if a cast could not be done.
     #   For instance, due to an overflow.
+    # @param wrap_numerical [Boolean]
+    #   If true numeric casts wrap overflowing values instead of
+    #   marking the cast as invalid.
     #
     # @return [Expr]
     #
@@ -1256,8 +1361,8 @@ module Polars
     #   )
     #   df.with_columns(
     #     [
-    #       Polars.col("a").cast(:f64),
-    #       Polars.col("b").cast(:i32)
+    #       Polars.col("a").cast(Polars::Float64),
+    #       Polars.col("b").cast(Polars::Int32)
     #     ]
     #   )
     #   # =>
@@ -1271,16 +1376,16 @@ module Polars
     #   # │ 2.0 ┆ 5   │
     #   # │ 3.0 ┆ 6   │
     #   # └─────┴─────┘
-    def cast(dtype, strict: true)
-      dtype = Utils.rb_type_to_dtype(dtype)
-      _from_rbexpr(_rbexpr.cast(dtype, strict))
+    def cast(dtype, strict: true, wrap_numerical: false)
+      dtype = Utils.parse_into_datatype_expr(dtype)
+      wrap_expr(_rbexpr.cast(dtype._rbdatatype_expr, strict, wrap_numerical))
     end
 
     # Sort this column. In projection/ selection context the whole column is sorted.
     #
     # If used in a group by context, the groups are sorted.
     #
-    # @param reverse [Boolean]
+    # @param descending [Boolean]
     #   false -> order from small to large.
     #   true -> order from large to small.
     # @param nulls_last [Boolean]
@@ -1347,8 +1452,8 @@ module Polars
     #   # │ two   ┆ [3, 4, 99] │
     #   # │ one   ┆ [1, 2, 98] │
     #   # └───────┴────────────┘
-    def sort(reverse: false, nulls_last: false)
-      _from_rbexpr(_rbexpr.sort_with(reverse, nulls_last))
+    def sort(descending: false, nulls_last: false)
+      wrap_expr(_rbexpr.sort_with(descending, nulls_last))
     end
 
     # Return the `k` largest elements.
@@ -1387,7 +1492,113 @@ module Polars
     #   # └───────┴──────────┘
     def top_k(k: 5)
       k = Utils.parse_into_expression(k)
-      _from_rbexpr(_rbexpr.top_k(k))
+      wrap_expr(_rbexpr.top_k(k))
+    end
+
+    # Return the elements corresponding to the `k` largest elements of the `by` column(s).
+    #
+    # Non-null elements are always preferred over null elements, regardless of
+    # the value of `reverse`. The output is not guaranteed to be in any
+    # particular order, call :func:`sort` after this function if you wish the
+    # output to be sorted.
+    #
+    # @param by [Object]
+    #   Column(s) used to determine the largest elements.
+    #   Accepts expression input. Strings are parsed as column names.
+    # @param k [Integer]
+    #   Number of elements to return.
+    # @param reverse [Object]
+    #   Consider the `k` smallest elements of the `by` column(s) (instead of the `k`
+    #   largest). This can be specified per column by passing an array of
+    #   booleans.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "a" => [1, 2, 3, 4, 5, 6],
+    #       "b" => [6, 5, 4, 3, 2, 1],
+    #       "c" => ["Apple", "Orange", "Apple", "Apple", "Banana", "Banana"]
+    #     }
+    #   )
+    #   # =>
+    #   # shape: (6, 3)
+    #   # ┌─────┬─────┬────────┐
+    #   # │ a   ┆ b   ┆ c      │
+    #   # │ --- ┆ --- ┆ ---    │
+    #   # │ i64 ┆ i64 ┆ str    │
+    #   # ╞═════╪═════╪════════╡
+    #   # │ 1   ┆ 6   ┆ Apple  │
+    #   # │ 2   ┆ 5   ┆ Orange │
+    #   # │ 3   ┆ 4   ┆ Apple  │
+    #   # │ 4   ┆ 3   ┆ Apple  │
+    #   # │ 5   ┆ 2   ┆ Banana │
+    #   # │ 6   ┆ 1   ┆ Banana │
+    #   # └─────┴─────┴────────┘
+    #
+    # @example Get the top 2 rows by column `a` or `b`.
+    #   df.select(
+    #     Polars.all.top_k_by("a", k: 2).name.suffix("_top_by_a"),
+    #     Polars.all.top_k_by("b", k: 2).name.suffix("_top_by_b")
+    #   )
+    #   # =>
+    #   # shape: (2, 6)
+    #   # ┌────────────┬────────────┬────────────┬────────────┬────────────┬────────────┐
+    #   # │ a_top_by_a ┆ b_top_by_a ┆ c_top_by_a ┆ a_top_by_b ┆ b_top_by_b ┆ c_top_by_b │
+    #   # │ ---        ┆ ---        ┆ ---        ┆ ---        ┆ ---        ┆ ---        │
+    #   # │ i64        ┆ i64        ┆ str        ┆ i64        ┆ i64        ┆ str        │
+    #   # ╞════════════╪════════════╪════════════╪════════════╪════════════╪════════════╡
+    #   # │ 6          ┆ 1          ┆ Banana     ┆ 1          ┆ 6          ┆ Apple      │
+    #   # │ 5          ┆ 2          ┆ Banana     ┆ 2          ┆ 5          ┆ Orange     │
+    #   # └────────────┴────────────┴────────────┴────────────┴────────────┴────────────┘
+    #
+    # @example Get the top 2 rows by multiple columns with given order.
+    #   df.select(
+    #     Polars.all
+    #     .top_k_by(["c", "a"], k: 2, reverse: [false, true])
+    #     .name.suffix("_by_ca"),
+    #     Polars.all
+    #     .top_k_by(["c", "b"], k: 2, reverse: [false, true])
+    #     .name.suffix("_by_cb")
+    #   )
+    #   # =>
+    #   # shape: (2, 6)
+    #   # ┌─────────┬─────────┬─────────┬─────────┬─────────┬─────────┐
+    #   # │ a_by_ca ┆ b_by_ca ┆ c_by_ca ┆ a_by_cb ┆ b_by_cb ┆ c_by_cb │
+    #   # │ ---     ┆ ---     ┆ ---     ┆ ---     ┆ ---     ┆ ---     │
+    #   # │ i64     ┆ i64     ┆ str     ┆ i64     ┆ i64     ┆ str     │
+    #   # ╞═════════╪═════════╪═════════╪═════════╪═════════╪═════════╡
+    #   # │ 2       ┆ 5       ┆ Orange  ┆ 2       ┆ 5       ┆ Orange  │
+    #   # │ 5       ┆ 2       ┆ Banana  ┆ 6       ┆ 1       ┆ Banana  │
+    #   # └─────────┴─────────┴─────────┴─────────┴─────────┴─────────┘
+    #
+    # @example Get the top 2 rows by column `a` in each group.
+    #   df.group_by("c", maintain_order: true)
+    #     .agg(Polars.all.top_k_by("a", k: 2))
+    #     .explode(Polars.all.exclude("c"))
+    #   # =>
+    #   # shape: (5, 3)
+    #   # ┌────────┬─────┬─────┐
+    #   # │ c      ┆ a   ┆ b   │
+    #   # │ ---    ┆ --- ┆ --- │
+    #   # │ str    ┆ i64 ┆ i64 │
+    #   # ╞════════╪═════╪═════╡
+    #   # │ Apple  ┆ 4   ┆ 3   │
+    #   # │ Apple  ┆ 3   ┆ 4   │
+    #   # │ Orange ┆ 2   ┆ 5   │
+    #   # │ Banana ┆ 6   ┆ 1   │
+    #   # │ Banana ┆ 5   ┆ 2   │
+    #   # └────────┴─────┴─────┘
+    def top_k_by(
+      by,
+      k: 5,
+      reverse: false
+    )
+      k = Utils.parse_into_expression(k)
+      by = Utils.parse_into_list_of_expressions(by)
+      reverse = Utils.extend_bool(reverse, by.length, "reverse", "by")
+      wrap_expr(_rbexpr.top_k_by(by, k, reverse))
     end
 
     # Return the `k` smallest elements.
@@ -1426,12 +1637,118 @@ module Polars
     #   # └───────┴──────────┘
     def bottom_k(k: 5)
       k = Utils.parse_into_expression(k)
-      _from_rbexpr(_rbexpr.bottom_k(k))
+      wrap_expr(_rbexpr.bottom_k(k))
+    end
+
+    # Return the elements corresponding to the `k` smallest elements of the `by` column(s).
+    #
+    # Non-null elements are always preferred over null elements, regardless of
+    # the value of `reverse`. The output is not guaranteed to be in any
+    # particular order, call :func:`sort` after this function if you wish the
+    # output to be sorted.
+    #
+    # @param by [Object]
+    #   Column(s) used to determine the smallest elements.
+    #   Accepts expression input. Strings are parsed as column names.
+    # @param k [Integer]
+    #   Number of elements to return.
+    # @param reverse [Object]
+    #   Consider the `k` largest elements of the `by` column(s) (instead of the `k`
+    #   smallest). This can be specified per column by passing an array of
+    #   booleans.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "a" => [1, 2, 3, 4, 5, 6],
+    #       "b" => [6, 5, 4, 3, 2, 1],
+    #       "c" => ["Apple", "Orange", "Apple", "Apple", "Banana", "Banana"],
+    #     }
+    #   )
+    #   # =>
+    #   # shape: (6, 3)
+    #   # ┌─────┬─────┬────────┐
+    #   # │ a   ┆ b   ┆ c      │
+    #   # │ --- ┆ --- ┆ ---    │
+    #   # │ i64 ┆ i64 ┆ str    │
+    #   # ╞═════╪═════╪════════╡
+    #   # │ 1   ┆ 6   ┆ Apple  │
+    #   # │ 2   ┆ 5   ┆ Orange │
+    #   # │ 3   ┆ 4   ┆ Apple  │
+    #   # │ 4   ┆ 3   ┆ Apple  │
+    #   # │ 5   ┆ 2   ┆ Banana │
+    #   # │ 6   ┆ 1   ┆ Banana │
+    #   # └─────┴─────┴────────┘
+    #
+    # @example Get the bottom 2 rows by column `a` or `b`.
+    #   df.select(
+    #     Polars.all.bottom_k_by("a", k: 2).name.suffix("_btm_by_a"),
+    #     Polars.all.bottom_k_by("b", k: 2).name.suffix("_btm_by_b")
+    #   )
+    #   # =>
+    #   # shape: (2, 6)
+    #   # ┌────────────┬────────────┬────────────┬────────────┬────────────┬────────────┐
+    #   # │ a_btm_by_a ┆ b_btm_by_a ┆ c_btm_by_a ┆ a_btm_by_b ┆ b_btm_by_b ┆ c_btm_by_b │
+    #   # │ ---        ┆ ---        ┆ ---        ┆ ---        ┆ ---        ┆ ---        │
+    #   # │ i64        ┆ i64        ┆ str        ┆ i64        ┆ i64        ┆ str        │
+    #   # ╞════════════╪════════════╪════════════╪════════════╪════════════╪════════════╡
+    #   # │ 1          ┆ 6          ┆ Apple      ┆ 6          ┆ 1          ┆ Banana     │
+    #   # │ 2          ┆ 5          ┆ Orange     ┆ 5          ┆ 2          ┆ Banana     │
+    #   # └────────────┴────────────┴────────────┴────────────┴────────────┴────────────┘
+    #
+    # @example Get the bottom 2 rows by multiple columns with given order.
+    #   df.select(
+    #     Polars.all
+    #     .bottom_k_by(["c", "a"], k: 2, reverse: [false, true])
+    #     .name.suffix("_by_ca"),
+    #     Polars.all
+    #     .bottom_k_by(["c", "b"], k: 2, reverse: [false, true])
+    #     .name.suffix("_by_cb"),
+    #   )
+    #   # =>
+    #   # shape: (2, 6)
+    #   # ┌─────────┬─────────┬─────────┬─────────┬─────────┬─────────┐
+    #   # │ a_by_ca ┆ b_by_ca ┆ c_by_ca ┆ a_by_cb ┆ b_by_cb ┆ c_by_cb │
+    #   # │ ---     ┆ ---     ┆ ---     ┆ ---     ┆ ---     ┆ ---     │
+    #   # │ i64     ┆ i64     ┆ str     ┆ i64     ┆ i64     ┆ str     │
+    #   # ╞═════════╪═════════╪═════════╪═════════╪═════════╪═════════╡
+    #   # │ 4       ┆ 3       ┆ Apple   ┆ 1       ┆ 6       ┆ Apple   │
+    #   # │ 3       ┆ 4       ┆ Apple   ┆ 3       ┆ 4       ┆ Apple   │
+    #   # └─────────┴─────────┴─────────┴─────────┴─────────┴─────────┘
+    #
+    # @example Get the bottom 2 rows by column `a` in each group.
+    #   df.group_by("c", maintain_order: true)
+    #     .agg(Polars.all.bottom_k_by("a", k: 2))
+    #     .explode(Polars.all.exclude("c"))
+    #   # =>
+    #   # shape: (5, 3)
+    #   # ┌────────┬─────┬─────┐
+    #   # │ c      ┆ a   ┆ b   │
+    #   # │ ---    ┆ --- ┆ --- │
+    #   # │ str    ┆ i64 ┆ i64 │
+    #   # ╞════════╪═════╪═════╡
+    #   # │ Apple  ┆ 1   ┆ 6   │
+    #   # │ Apple  ┆ 3   ┆ 4   │
+    #   # │ Orange ┆ 2   ┆ 5   │
+    #   # │ Banana ┆ 5   ┆ 2   │
+    #   # │ Banana ┆ 6   ┆ 1   │
+    #   # └────────┴─────┴─────┘
+    def bottom_k_by(
+      by,
+      k: 5,
+      reverse: false
+    )
+      k = Utils.parse_into_expression(k)
+      by = Utils.parse_into_list_of_expressions(by)
+      reverse = Utils.extend_bool(reverse, by.length, "reverse", "by")
+      wrap_expr(_rbexpr.bottom_k_by(by, k, reverse))
     end
 
     # Get the index values that would sort this column.
     #
-    # @param reverse [Boolean]
+    # @param descending [Boolean]
     #   Sort in reverse (descending) order.
     # @param nulls_last [Boolean]
     #   Place null values last instead of first.
@@ -1456,8 +1773,8 @@ module Polars
     #   # │ 0   │
     #   # │ 2   │
     #   # └─────┘
-    def arg_sort(reverse: false, nulls_last: false)
-      _from_rbexpr(_rbexpr.arg_sort(reverse, nulls_last))
+    def arg_sort(descending: false, nulls_last: false)
+      wrap_expr(_rbexpr.arg_sort(descending, nulls_last))
     end
 
     # Get the index of the maximal value.
@@ -1481,7 +1798,7 @@ module Polars
     #   # │ 2   │
     #   # └─────┘
     def arg_max
-      _from_rbexpr(_rbexpr.arg_max)
+      wrap_expr(_rbexpr.arg_max)
     end
 
     # Get the index of the minimal value.
@@ -1505,13 +1822,50 @@ module Polars
     #   # │ 1   │
     #   # └─────┘
     def arg_min
-      _from_rbexpr(_rbexpr.arg_min)
+      wrap_expr(_rbexpr.arg_min)
+    end
+
+    # Get the index of the first occurrence of a value, or `nil` if it's not found.
+    #
+    # @param element [Object]
+    #   Value to find.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"a" => [1, nil, 17]})
+    #   df.select(
+    #     [
+    #       Polars.col("a").index_of(17).alias("seventeen"),
+    #       Polars.col("a").index_of(nil).alias("null"),
+    #       Polars.col("a").index_of(55).alias("fiftyfive")
+    #     ]
+    #   )
+    #   # =>
+    #   # shape: (1, 3)
+    #   # ┌───────────┬──────┬───────────┐
+    #   # │ seventeen ┆ null ┆ fiftyfive │
+    #   # │ ---       ┆ ---  ┆ ---       │
+    #   # │ u32       ┆ u32  ┆ u32       │
+    #   # ╞═══════════╪══════╪═══════════╡
+    #   # │ 2         ┆ 1    ┆ null      │
+    #   # └───────────┴──────┴───────────┘
+    def index_of(element)
+      element = Utils.parse_into_expression(element, str_as_lit: true)
+      wrap_expr(_rbexpr.index_of(element))
     end
 
     # Find indices where elements should be inserted to maintain order.
     #
     # @param element [Object]
     #   Expression or scalar value.
+    # @param side ['any', 'left', 'right']
+    #   If 'any', the index of the first suitable location found is given.
+    #   If 'left', the index of the leftmost suitable location found is given.
+    #   If 'right', return the rightmost suitable location found is given.
+    # @param descending [Boolean]
+    #   Boolean indicating whether the values are descending or not (they
+    #   are required to be sorted either way).
     #
     # @return [Expr]
     #
@@ -1537,9 +1891,9 @@ module Polars
     #   # ╞══════╪═══════╪═════╡
     #   # │ 0    ┆ 2     ┆ 4   │
     #   # └──────┴───────┴─────┘
-    def search_sorted(element, side: "any")
+    def search_sorted(element, side: "any", descending: false)
       element = Utils.parse_into_expression(element, str_as_lit: false)
-      _from_rbexpr(_rbexpr.search_sorted(element, side))
+      wrap_expr(_rbexpr.search_sorted(element, side, descending))
     end
 
     # Sort this column by the ordering of another column, or multiple other columns.
@@ -1549,9 +1903,18 @@ module Polars
     #
     # @param by [Object]
     #   The column(s) used for sorting.
-    # @param reverse [Boolean]
+    # @param more_by [Array]
+    #   Additional columns to sort by, specified as positional arguments.
+    # @param descending [Boolean]
     #   false -> order from small to large.
     #   true -> order from large to small.
+    # @param nulls_last [Boolean]
+    #   Place null values last; can specify a single boolean applying to all columns
+    #   or an array of booleans for per-column control.
+    # @param multithreaded [Boolean]
+    #   Sort using multiple threads.
+    # @param maintain_order [Boolean]
+    #   Whether the order should be maintained if elements are equal.
     #
     # @return [Expr]
     #
@@ -1584,13 +1947,13 @@ module Polars
     #   # │ one   │
     #   # │ two   │
     #   # └───────┘
-    def sort_by(by, *more_by, reverse: false, nulls_last: false, multithreaded: true, maintain_order: false)
+    def sort_by(by, *more_by, descending: false, nulls_last: false, multithreaded: true, maintain_order: false)
       by = Utils.parse_into_list_of_expressions(by, *more_by)
-      reverse = Utils.extend_bool(reverse, by.length, "reverse", "by")
+      descending = Utils.extend_bool(descending, by.length, "descending", "by")
       nulls_last = Utils.extend_bool(nulls_last, by.length, "nulls_last", "by")
-      _from_rbexpr(
+      wrap_expr(
         _rbexpr.sort_by(
-          by, reverse, nulls_last, multithreaded, maintain_order
+          by, descending, nulls_last, multithreaded, maintain_order
         )
       )
     end
@@ -1599,6 +1962,11 @@ module Polars
     #
     # @param indices [Expr]
     #   An expression that leads to a `:u32` dtyped Series.
+    # @param null_on_oob [Boolean]
+    #   Behavior if an index is out of bounds:
+    #
+    #   - true  -> set the result to null
+    #   - false -> raise an error
     #
     # @return [Expr]
     #
@@ -1616,7 +1984,7 @@ module Polars
     #       "value" => [1, 98, 2, 3, 99, 4]
     #     }
     #   )
-    #   df.group_by("group", maintain_order: true).agg(Polars.col("value").take([2, 1]))
+    #   df.group_by("group", maintain_order: true).agg(Polars.col("value").gather([2, 1]))
     #   # =>
     #   # shape: (2, 2)
     #   # ┌───────┬───────────┐
@@ -1627,20 +1995,24 @@ module Polars
     #   # │ one   ┆ [2, 98]   │
     #   # │ two   ┆ [4, 99]   │
     #   # └───────┴───────────┘
-    def gather(indices)
+    def gather(indices, null_on_oob: false)
       if indices.is_a?(::Array)
-        indices_lit = Polars.lit(Series.new("", indices, dtype: :u32))._rbexpr
+        indices_lit_rbexpr = Polars.lit(Series.new("", indices, dtype: Int64))._rbexpr
       else
-        indices_lit = Utils.parse_into_expression(indices, str_as_lit: false)
+        indices_lit_rbexpr = Utils.parse_into_expression(indices)
       end
-      _from_rbexpr(_rbexpr.gather(indices_lit))
+      wrap_expr(_rbexpr.gather(indices_lit_rbexpr, null_on_oob))
     end
-    alias_method :take, :gather
 
     # Return a single value by index.
     #
     # @param index [Object]
     #   An expression that leads to a UInt32 index.
+    # @param null_on_oob [Boolean]
+    #   Behavior if an index is out of bounds:
+    #
+    #   - true  -> set the result to null
+    #   - false -> raise an error
     #
     # @return [Expr]
     #
@@ -1669,9 +2041,9 @@ module Polars
     #   # │ one   ┆ 98    │
     #   # │ two   ┆ 99    │
     #   # └───────┴───────┘
-    def get(index)
+    def get(index, null_on_oob: false)
       index_lit = Utils.parse_into_expression(index)
-      _from_rbexpr(_rbexpr.get(index_lit))
+      wrap_expr(_rbexpr.get(index_lit, null_on_oob))
     end
 
     # Shift the values by a given period.
@@ -1703,38 +2075,10 @@ module Polars
         fill_value = Utils.parse_into_expression(fill_value, str_as_lit: true)
       end
       n = Utils.parse_into_expression(n)
-      _from_rbexpr(_rbexpr.shift(n, fill_value))
+      wrap_expr(_rbexpr.shift(n, fill_value))
     end
 
-    # Shift the values by a given period and fill the resulting null values.
-    #
-    # @param periods [Integer]
-    #   Number of places to shift (may be negative).
-    # @param fill_value [Object]
-    #   Fill nil values with the result of this expression.
-    #
-    # @return [Expr]
-    #
-    # @example
-    #   df = Polars::DataFrame.new({"foo" => [1, 2, 3, 4]})
-    #   df.select(Polars.col("foo").shift_and_fill(1, "a"))
-    #   # =>
-    #   # shape: (4, 1)
-    #   # ┌─────┐
-    #   # │ foo │
-    #   # │ --- │
-    #   # │ str │
-    #   # ╞═════╡
-    #   # │ a   │
-    #   # │ 1   │
-    #   # │ 2   │
-    #   # │ 3   │
-    #   # └─────┘
-    def shift_and_fill(periods, fill_value)
-      shift(periods, fill_value: fill_value)
-    end
-
-    # Fill null values using the specified value or strategy.
+    # Fill null values using the specified value or strategy.
     #
     # To interpolate over null values see interpolate.
     #
@@ -1806,9 +2150,9 @@ module Polars
 
       if !value.nil?
         value = Utils.parse_into_expression(value, str_as_lit: true)
-        _from_rbexpr(_rbexpr.fill_null(value))
+        wrap_expr(_rbexpr.fill_null(value))
       else
-        _from_rbexpr(_rbexpr.fill_null_with_strategy(strategy, limit))
+        wrap_expr(_rbexpr.fill_null_with_strategy(strategy, limit))
       end
     end
 
@@ -1835,9 +2179,9 @@ module Polars
     #   # │ null ┆ zero │
     #   # │ zero ┆ 6.0  │
     #   # └──────┴──────┘
-    def fill_nan(fill_value)
-      fill_value = Utils.parse_into_expression(fill_value, str_as_lit: true)
-      _from_rbexpr(_rbexpr.fill_nan(fill_value))
+    def fill_nan(value)
+      fill_value_rbexpr = Utils.parse_into_expression(value, str_as_lit: true)
+      wrap_expr(_rbexpr.fill_nan(fill_value_rbexpr))
     end
 
     # Fill missing values with the latest seen values.
@@ -1867,7 +2211,7 @@ module Polars
     #   # │ 2   ┆ 6   │
     #   # └─────┴─────┘
     def forward_fill(limit: nil)
-      _from_rbexpr(_rbexpr.forward_fill(limit))
+      fill_null(strategy: "forward", limit: limit)
     end
 
     # Fill missing values with the next to be seen values.
@@ -1897,7 +2241,7 @@ module Polars
     #   # │ null ┆ 6   │
     #   # └──────┴─────┘
     def backward_fill(limit: nil)
-      _from_rbexpr(_rbexpr.backward_fill(limit))
+      fill_null(strategy: "backward", limit: limit)
     end
 
     # Reverse the selection.
@@ -1933,7 +2277,7 @@ module Polars
     #   # │ 5   ┆ banana ┆ 1   ┆ beetle ┆ 1         ┆ banana         ┆ 5         ┆ beetle       │
     #   # └─────┴────────┴─────┴────────┴───────────┴────────────────┴───────────┴──────────────┘
     def reverse
-      _from_rbexpr(_rbexpr.reverse)
+      wrap_expr(_rbexpr.reverse)
     end
 
     # Get standard deviation.
@@ -1956,7 +2300,7 @@ module Polars
     #   # │ 1.0 │
     #   # └─────┘
     def std(ddof: 1)
-      _from_rbexpr(_rbexpr.std(ddof))
+      wrap_expr(_rbexpr.std(ddof))
     end
 
     # Get variance.
@@ -1979,7 +2323,7 @@ module Polars
     #   # │ 1.0 │
     #   # └─────┘
     def var(ddof: 1)
-      _from_rbexpr(_rbexpr.var(ddof))
+      wrap_expr(_rbexpr.var(ddof))
     end
 
     # Get maximum value.
@@ -1999,7 +2343,39 @@ module Polars
     #   # │ 1.0 │
     #   # └─────┘
     def max
-      _from_rbexpr(_rbexpr.max)
+      wrap_expr(_rbexpr.max)
+    end
+
+    # Get maximum value, ordered by another expression.
+    #
+    # If the by expression has multiple values equal to the maximum it is not
+    # defined which value will be chosen.
+    #
+    # @note
+    #   This functionality is considered **unstable**. It may be changed
+    #   at any point without it being considered a breaking change.
+    #
+    # @param by [Object]
+    #   Column used to determine the largest element.
+    #   Accepts expression input. Strings are parsed as column names.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"a" => [-1.0, Float::NAN, 1.0], "b" => ["x", "y", "z"]})
+    #   df.select(Polars.col("b").max_by("a"))
+    #   # =>
+    #   # shape: (1, 1)
+    #   # ┌─────┐
+    #   # │ b   │
+    #   # │ --- │
+    #   # │ str │
+    #   # ╞═════╡
+    #   # │ z   │
+    #   # └─────┘
+    def max_by(by)
+      by_rbexpr = Utils.parse_into_expression(by)
+      wrap_expr(_rbexpr.max_by(by_rbexpr))
     end
 
     # Get minimum value.
@@ -2019,7 +2395,39 @@ module Polars
     #   # │ -1.0 │
     #   # └──────┘
     def min
-      _from_rbexpr(_rbexpr.min)
+      wrap_expr(_rbexpr.min)
+    end
+
+    # Get minimum value, ordered by another expression.
+    #
+    # If the by expression has multiple values equal to the minimum it is not
+    # defined which value will be chosen.
+    #
+    # @note
+    #   This functionality is considered **unstable**. It may be changed
+    #   at any point without it being considered a breaking change.
+    #
+    # @param by [Object]
+    #   Column used to determine the smallest element.
+    #   Accepts expression input. Strings are parsed as column names.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"a" => [-1.0, Float::NAN, 1.0], "b" => ["x", "y", "z"]})
+    #   df.select(Polars.col("b").min_by("a"))
+    #   # =>
+    #   # shape: (1, 1)
+    #   # ┌─────┐
+    #   # │ b   │
+    #   # │ --- │
+    #   # │ str │
+    #   # ╞═════╡
+    #   # │ x   │
+    #   # └─────┘
+    def min_by(by)
+      by_rbexpr = Utils.parse_into_expression(by)
+      wrap_expr(_rbexpr.min_by(by_rbexpr))
     end
 
     # Get maximum value, but propagate/poison encountered NaN values.
@@ -2039,7 +2447,7 @@ module Polars
     #   # │ NaN │
     #   # └─────┘
     def nan_max
-      _from_rbexpr(_rbexpr.nan_max)
+      wrap_expr(_rbexpr.nan_max)
     end
 
     # Get minimum value, but propagate/poison encountered NaN values.
@@ -2059,7 +2467,7 @@ module Polars
     #   # │ NaN │
     #   # └─────┘
     def nan_min
-      _from_rbexpr(_rbexpr.nan_min)
+      wrap_expr(_rbexpr.nan_min)
     end
 
     # Get sum value.
@@ -2067,8 +2475,8 @@ module Polars
     # @return [Expr]
     #
     # @note
-    #   Dtypes in `:i8`, `:u8`, `:i16`, and `:u16` are cast to
-    #   `:i64` before summing to prevent overflow issues.
+    #   Dtypes in \\\\{Int8, UInt8, Int16, UInt16} are cast to
+    #   Int64 before summing to prevent overflow issues.
     #
     # @example
     #   df = Polars::DataFrame.new({"a" => [-1, 0, 1]})
@@ -2083,7 +2491,7 @@ module Polars
     #   # │ 0   │
     #   # └─────┘
     def sum
-      _from_rbexpr(_rbexpr.sum)
+      wrap_expr(_rbexpr.sum)
     end
 
     # Get mean value.
@@ -2103,7 +2511,7 @@ module Polars
     #   # │ 0.0 │
     #   # └─────┘
     def mean
-      _from_rbexpr(_rbexpr.mean)
+      wrap_expr(_rbexpr.mean)
     end
 
     # Get median value using linear interpolation.
@@ -2123,7 +2531,7 @@ module Polars
     #   # │ 0.0 │
     #   # └─────┘
     def median
-      _from_rbexpr(_rbexpr.median)
+      wrap_expr(_rbexpr.median)
     end
 
     # Compute the product of an expression.
@@ -2143,7 +2551,7 @@ module Polars
     #   # │ 6   │
     #   # └─────┘
     def product
-      _from_rbexpr(_rbexpr.product)
+      wrap_expr(_rbexpr.product)
     end
 
     # Count unique values.
@@ -2163,7 +2571,7 @@ module Polars
     #   # │ 2   │
     #   # └─────┘
     def n_unique
-      _from_rbexpr(_rbexpr.n_unique)
+      wrap_expr(_rbexpr.n_unique)
     end
 
     # Approx count unique values.
@@ -2185,9 +2593,8 @@ module Polars
     #   # │ 2   │
     #   # └─────┘
     def approx_n_unique
-      _from_rbexpr(_rbexpr.approx_n_unique)
+      wrap_expr(_rbexpr.approx_n_unique)
     end
-    alias_method :approx_unique, :approx_n_unique
 
     # Count null values.
     #
@@ -2211,7 +2618,33 @@ module Polars
     #   # │ 2   ┆ 0   │
     #   # └─────┴─────┘
     def null_count
-      _from_rbexpr(_rbexpr.null_count)
+      wrap_expr(_rbexpr.null_count)
+    end
+
+    # Check whether the expression contains one or more null values.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "a" => [nil, 1, nil],
+    #       "b" => [10, nil, 300],
+    #       "c" => [350, 650, 850]
+    #     }
+    #   )
+    #   df.select(Polars.all.has_nulls)
+    #   # =>
+    #   # shape: (1, 3)
+    #   # ┌──────┬──────┬───────┐
+    #   # │ a    ┆ b    ┆ c     │
+    #   # │ ---  ┆ ---  ┆ ---   │
+    #   # │ bool ┆ bool ┆ bool  │
+    #   # ╞══════╪══════╪═══════╡
+    #   # │ true ┆ true ┆ false │
+    #   # └──────┴──────┴───────┘
+    def has_nulls
+      null_count > 0
     end
 
     # Get index of first unique value.
@@ -2251,7 +2684,7 @@ module Polars
     #   # │ 1   │
     #   # └─────┘
     def arg_unique
-      _from_rbexpr(_rbexpr.arg_unique)
+      wrap_expr(_rbexpr.arg_unique)
     end
 
     # Get unique values of this expression.
@@ -2276,14 +2709,19 @@ module Polars
     #   # └─────┘
     def unique(maintain_order: false)
       if maintain_order
-        _from_rbexpr(_rbexpr.unique_stable)
+        wrap_expr(_rbexpr.unique_stable)
       else
-        _from_rbexpr(_rbexpr.unique)
+        wrap_expr(_rbexpr.unique)
       end
     end
 
     # Get the first value.
     #
+    # @param ignore_nulls [Boolean]
+    #   Ignore null values (default `false`).
+    #   If set to `true`, the first non-null value is returned, otherwise `nil` is
+    #   returned if no non-null value exists.
+    #
     # @return [Expr]
     #
     # @example
@@ -2298,12 +2736,17 @@ module Polars
     #   # ╞═════╡
     #   # │ 1   │
     #   # └─────┘
-    def first
-      _from_rbexpr(_rbexpr.first)
+    def first(ignore_nulls: false)
+      wrap_expr(_rbexpr.first(ignore_nulls))
     end
 
     # Get the last value.
     #
+    # @param ignore_nulls [Boolean]
+    #   Ignore null values (default `false`).
+    #   If set to `true`, the last non-null value is returned, otherwise `nil` is
+    #   returned if no non-null value exists.
+    #
     # @return [Expr]
     #
     # @example
@@ -2318,8 +2761,45 @@ module Polars
     #   # ╞═════╡
     #   # │ 2   │
     #   # └─────┘
-    def last
-      _from_rbexpr(_rbexpr.last)
+    def last(ignore_nulls: false)
+      wrap_expr(_rbexpr.last(ignore_nulls))
+    end
+
+    # Get the single value.
+    #
+    # This raises an error if there is not exactly one value.
+    #
+    # @param allow_empty [Boolean]
+    #   Allow having no values to return `null`.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"a" => [1]})
+    #   df.select(Polars.col("a").item)
+    #   # =>
+    #   # shape: (1, 1)
+    #   # ┌─────┐
+    #   # │ a   │
+    #   # │ --- │
+    #   # │ i64 │
+    #   # ╞═════╡
+    #   # │ 1   │
+    #   # └─────┘
+    #
+    # @example
+    #   df.head(0).select(Polars.col("a").item(allow_empty: true))
+    #   # =>
+    #   # shape: (1, 1)
+    #   # ┌──────┐
+    #   # │ a    │
+    #   # │ ---  │
+    #   # │ i64  │
+    #   # ╞══════╡
+    #   # │ null │
+    #   # └──────┘
+    def item(allow_empty: false)
+      Utils.wrap_expr(_rbexpr.item(allow_empty))
     end
 
     # Apply window function over a subgroup.
@@ -2327,8 +2807,40 @@ module Polars
     # This is similar to a group by + aggregation + self join.
     # Or similar to [window functions in Postgres](https://www.postgresql.org/docs/current/tutorial-window.html).
     #
-    # @param expr [Object]
-    #   Column(s) to group by.
+    # @param partition_by [Object]
+    #   Column(s) to group by. Accepts expression input. Strings are parsed as
+    #   column names.
+    # @param more_exprs [Array]
+    #   Additional columns to group by, specified as positional arguments.
+    # @param order_by [Object]
+    #   Order the window functions/aggregations with the partitioned groups by
+    #   the result of the expression passed to `order_by`.
+    # @param descending [Boolean]
+    #   In case 'order_by' is given, indicate whether to order in ascending or
+    #   descending order.
+    # @param nulls_last [Boolean]
+    #   In case 'order_by' is given, indicate whether to order
+    #   the nulls in last position.
+    # @param mapping_strategy ['group_to_rows', 'join', 'explode']
+    #   - group_to_rows
+    #       If the aggregation results in multiple values per group, map them back
+    #       to their row position in the DataFrame. This can only be done if each
+    #       group yields the same elements before aggregation as after. If the
+    #       aggregation results in one scalar value per group, this value will be
+    #       mapped to every row.
+    #   - join
+    #       If the aggregation may result in multiple values per group, join the
+    #       values as 'List<group_dtype>' to each row position. Warning: this can be
+    #       memory intensive. If the aggregation always results in one scalar value
+    #       per group, join this value as '<group_dtype>' to each row position.
+    #   - explode
+    #       If the aggregation may result in multiple values per group, map each
+    #       value to a new row, similar to the results of `group_by` + `agg` +
+    #       `explode`. If the aggregation always results in one scalar value per
+    #       group, map this value to one row position. Sorting of the given groups
+    #       is required if the groups are not part of the window operation for the
+    #       operation, otherwise the result would not make sense. This operation
+    #       changes the number of rows.
     #
     # @return [Expr]
     #
@@ -2339,7 +2851,7 @@ module Polars
     #       "values" => [1, 2, 3]
     #     }
     #   )
-    #   df.with_column(
+    #   df.with_columns(
     #     Polars.col("values").max.over("groups").alias("max_by_group")
     #   )
     #   # =>
@@ -2381,9 +2893,145 @@ module Polars
     #   # │ 6      │
     #   # │ 4      │
     #   # └────────┘
-    def over(expr)
-      rbexprs = Utils.parse_into_list_of_expressions(expr)
-      _from_rbexpr(_rbexpr.over(rbexprs))
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "store_id" => ["a", "a", "b", "b"],
+    #       "date" => [Date.new(2024, 9, 18), Date.new(2024, 9, 17), Date.new(2024, 9, 18), Date.new(2024, 9, 16)],
+    #       "sales" => [7, 9, 8, 10]
+    #     }
+    #   )
+    #   df.with_columns(
+    #     cumulative_sales: Polars.col("sales").cum_sum.over("store_id", order_by: "date")
+    #   )
+    #   # =>
+    #   # shape: (4, 4)
+    #   # ┌──────────┬────────────┬───────┬──────────────────┐
+    #   # │ store_id ┆ date       ┆ sales ┆ cumulative_sales │
+    #   # │ ---      ┆ ---        ┆ ---   ┆ ---              │
+    #   # │ str      ┆ date       ┆ i64   ┆ i64              │
+    #   # ╞══════════╪════════════╪═══════╪══════════════════╡
+    #   # │ a        ┆ 2024-09-18 ┆ 7     ┆ 16               │
+    #   # │ a        ┆ 2024-09-17 ┆ 9     ┆ 9                │
+    #   # │ b        ┆ 2024-09-18 ┆ 8     ┆ 18               │
+    #   # │ b        ┆ 2024-09-16 ┆ 10    ┆ 10               │
+    #   # └──────────┴────────────┴───────┴──────────────────┘
+    def over(partition_by = nil, *more_exprs, order_by: nil, descending: false, nulls_last: false, mapping_strategy: "group_to_rows")
+      partition_by_rbexprs =
+        if !partition_by.nil?
+          Utils.parse_into_list_of_expressions(partition_by, *more_exprs)
+        else
+          nil
+        end
+
+      order_by_rbexprs = !order_by.nil? ? Utils.parse_into_list_of_expressions(order_by) : nil
+
+      wrap_expr(_rbexpr.over(partition_by_rbexprs, order_by_rbexprs, descending, nulls_last, mapping_strategy))
+    end
+
+    # Create rolling groups based on a temporal or integer column.
+    #
+    # If you have a time series `<t_0, t_1, ..., t_n>`, then by default the
+    # windows created will be
+    #
+    #   * (t_0 - period, t_0]
+    #   * (t_1 - period, t_1]
+    #   * ...
+    #   * (t_n - period, t_n]
+    #
+    # whereas if you pass a non-default `offset`, then the windows will be
+    #
+    #   * (t_0 + offset, t_0 + offset + period]
+    #   * (t_1 + offset, t_1 + offset + period]
+    #   * ...
+    #   * (t_n + offset, t_n + offset + period]
+    #
+    # The `period` and `offset` arguments are created either from a timedelta, or
+    # by using 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)
+    # - 1i    (1 index count)
+    #
+    # Or combine them:
+    # "3d12h4m25s" # 3 days, 12 hours, 4 minutes, and 25 seconds
+    #
+    # 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 index_column [Object]
+    #   Column used to group based on the time window.
+    #   Often of type Date/Datetime.
+    #   This column must be sorted in ascending order.
+    #   In case of a rolling group by on indices, dtype needs to be one of
+    #   \\\\{UInt32, UInt64, Int32, Int64}. Note that the first three get temporarily
+    #   cast to Int64, so if performance matters use an Int64 column.
+    # @param period [Object]
+    #   Length of the window - must be non-negative.
+    # @param offset [Object]
+    #   Offset of the window. Default is `-period`.
+    # @param closed ['right', 'left', 'both', 'none']
+    #   Define which sides of the temporal interval are closed (inclusive).
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   dates = [
+    #     "2020-01-01 13:45:48",
+    #     "2020-01-01 16:42:13",
+    #     "2020-01-01 16:45:09",
+    #     "2020-01-02 18:12:48",
+    #     "2020-01-03 19:45:32",
+    #     "2020-01-08 23:16:43"
+    #   ]
+    #   df = Polars::DataFrame.new({"dt" => dates, "a": [3, 7, 5, 9, 2, 1]}).with_columns(
+    #     Polars.col("dt").str.strptime(Polars::Datetime).set_sorted
+    #   )
+    #   df.with_columns(
+    #     sum_a: Polars.sum("a").rolling(index_column: "dt", period: "2d"),
+    #     min_a: Polars.min("a").rolling(index_column: "dt", period: "2d"),
+    #     max_a: Polars.max("a").rolling(index_column: "dt", period: "2d")
+    #   )
+    #   # =>
+    #   # shape: (6, 5)
+    #   # ┌─────────────────────┬─────┬───────┬───────┬───────┐
+    #   # │ dt                  ┆ a   ┆ sum_a ┆ min_a ┆ max_a │
+    #   # │ ---                 ┆ --- ┆ ---   ┆ ---   ┆ ---   │
+    #   # │ datetime[μs]        ┆ i64 ┆ i64   ┆ i64   ┆ i64   │
+    #   # ╞═════════════════════╪═════╪═══════╪═══════╪═══════╡
+    #   # │ 2020-01-01 13:45:48 ┆ 3   ┆ 3     ┆ 3     ┆ 3     │
+    #   # │ 2020-01-01 16:42:13 ┆ 7   ┆ 10    ┆ 3     ┆ 7     │
+    #   # │ 2020-01-01 16:45:09 ┆ 5   ┆ 15    ┆ 3     ┆ 7     │
+    #   # │ 2020-01-02 18:12:48 ┆ 9   ┆ 24    ┆ 3     ┆ 9     │
+    #   # │ 2020-01-03 19:45:32 ┆ 2   ┆ 11    ┆ 2     ┆ 9     │
+    #   # │ 2020-01-08 23:16:43 ┆ 1   ┆ 1     ┆ 1     ┆ 1     │
+    #   # └─────────────────────┴─────┴───────┴───────┴───────┘
+    def rolling(
+      index_column:,
+      period:,
+      offset: nil,
+      closed: "right"
+    )
+      index_column_rbexpr = Utils.parse_into_expression(index_column)
+      if offset.nil?
+        offset = Utils.negate_duration_string(Utils.parse_as_duration_string(period))
+      end
+
+      period = Utils.parse_as_duration_string(period)
+      offset = Utils.parse_as_duration_string(offset)
+
+      wrap_expr(_rbexpr.rolling(index_column_rbexpr, period, offset, closed))
     end
 
     # Get mask of unique values.
@@ -2405,7 +3053,7 @@ module Polars
     #   # │ true  │
     #   # └───────┘
     def is_unique
-      _from_rbexpr(_rbexpr.is_unique)
+      wrap_expr(_rbexpr.is_unique)
     end
 
     # Get a mask of the first unique value.
@@ -2418,7 +3066,7 @@ module Polars
     #       "num" => [1, 2, 3, 1, 5]
     #     }
     #   )
-    #   df.with_column(Polars.col("num").is_first.alias("is_first"))
+    #   df.with_columns(Polars.col("num").is_first_distinct.alias("is_first"))
     #   # =>
     #   # shape: (5, 2)
     #   # ┌─────┬──────────┐
@@ -2433,9 +3081,32 @@ module Polars
     #   # │ 5   ┆ true     │
     #   # └─────┴──────────┘
     def is_first_distinct
-      _from_rbexpr(_rbexpr.is_first_distinct)
+      wrap_expr(_rbexpr.is_first_distinct)
+    end
+
+    # Return a boolean mask indicating the last occurrence of each distinct value.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"a" => [1, 1, 2, 3, 2]})
+    #   df.with_columns(Polars.col("a").is_last_distinct.alias("last"))
+    #   # =>
+    #   # shape: (5, 2)
+    #   # ┌─────┬───────┐
+    #   # │ a   ┆ last  │
+    #   # │ --- ┆ ---   │
+    #   # │ i64 ┆ bool  │
+    #   # ╞═════╪═══════╡
+    #   # │ 1   ┆ false │
+    #   # │ 1   ┆ true  │
+    #   # │ 2   ┆ false │
+    #   # │ 3   ┆ true  │
+    #   # │ 2   ┆ true  │
+    #   # └─────┴───────┘
+    def is_last_distinct
+      wrap_expr(_rbexpr.is_last_distinct)
     end
-    alias_method :is_first, :is_first_distinct
 
     # Get mask of duplicated values.
     #
@@ -2456,7 +3127,7 @@ module Polars
     #   # │ false │
     #   # └───────┘
     def is_duplicated
-      _from_rbexpr(_rbexpr.is_duplicated)
+      wrap_expr(_rbexpr.is_duplicated)
     end
 
     # Get a boolean mask of the local maximum peaks.
@@ -2480,7 +3151,7 @@ module Polars
     #   # │ true  │
     #   # └───────┘
     def peak_max
-      _from_rbexpr(_rbexpr.peak_max)
+      wrap_expr(_rbexpr.peak_max)
     end
 
     # Get a boolean mask of the local minimum peaks.
@@ -2504,7 +3175,7 @@ module Polars
     #   # │ false │
     #   # └───────┘
     def peak_min
-      _from_rbexpr(_rbexpr.peak_min)
+      wrap_expr(_rbexpr.peak_min)
     end
 
     # Get quantile value.
@@ -2578,7 +3249,7 @@ module Polars
     #   # └─────┘
     def quantile(quantile, interpolation: "nearest")
       quantile = Utils.parse_into_expression(quantile, str_as_lit: false)
-      _from_rbexpr(_rbexpr.quantile(quantile, interpolation))
+      wrap_expr(_rbexpr.quantile(quantile, interpolation))
     end
 
     # Bin continuous values into discrete categories.
@@ -2604,17 +3275,17 @@ module Polars
     #   )
     #   # =>
     #   # shape: (5, 2)
-    #   # ┌─────┬─────┐
-    #   # │ foo ┆ cut │
-    #   # │ --- ┆ --- │
-    #   # │ i64 ┆ cat │
-    #   # ╞═════╪═════╡
-    #   # │ -2  ┆ a   │
-    #   # │ -1  ┆ a   │
-    #   # │ 0   ┆ b   │
-    #   # │ 1   ┆ b   │
-    #   # │ 2   ┆ c   │
-    #   # └─────┴─────┘
+    #   # ┌─────┬──────┐
+    #   # │ foo ┆ cut  │
+    #   # │ --- ┆ ---  │
+    #   # │ i64 ┆ enum │
+    #   # ╞═════╪══════╡
+    #   # │ -2  ┆ a    │
+    #   # │ -1  ┆ a    │
+    #   # │ 0   ┆ b    │
+    #   # │ 1   ┆ b    │
+    #   # │ 2   ┆ c    │
+    #   # └─────┴──────┘
     #
     # @example Add both the category and the breakpoint.
     #   df.with_columns(
@@ -2625,7 +3296,7 @@ module Polars
     #   # ┌─────┬────────────┬────────────┐
     #   # │ foo ┆ breakpoint ┆ category   │
     #   # │ --- ┆ ---        ┆ ---        │
-    #   # │ i64 ┆ f64        ┆ cat        │
+    #   # │ i64 ┆ f64        ┆ enum       │
     #   # ╞═════╪════════════╪════════════╡
     #   # │ -2  ┆ -1.0       ┆ (-inf, -1] │
     #   # │ -1  ┆ -1.0       ┆ (-inf, -1] │
@@ -2634,7 +3305,7 @@ module Polars
     #   # │ 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))
+      wrap_expr(_rbexpr.cut(breaks, labels, left_closed, include_breaks))
     end
 
     # Bin continuous values into discrete categories based on their quantiles.
@@ -2725,7 +3396,7 @@ module Polars
         )
       end
 
-      _from_rbexpr(rbexpr)
+      wrap_expr(rbexpr)
     end
 
     # Get the lengths of runs of identical values.
@@ -2750,7 +3421,7 @@ module Polars
     #   # │ 2   ┆ 3     │
     #   # └─────┴───────┘
     def rle
-      _from_rbexpr(_rbexpr.rle)
+      wrap_expr(_rbexpr.rle)
     end
 
     # Map values to run IDs.
@@ -2778,7 +3449,7 @@ module Polars
     #   # │ 1   ┆ y    ┆ 2   ┆ 3    │
     #   # └─────┴──────┴─────┴──────┘
     def rle_id
-      _from_rbexpr(_rbexpr.rle_id)
+      wrap_expr(_rbexpr.rle_id)
     end
 
     # Filter a single column.
@@ -2786,8 +3457,12 @@ module Polars
     # Mostly useful in an aggregation context. If you want to filter on a DataFrame
     # level, use `LazyFrame#filter`.
     #
-    # @param predicate [Expr]
-    #   Boolean expression.
+    # @param predicates [Array]
+    #   Expression(s) that evaluates to a boolean Series.
+    # @param constraints [Hash]
+    #   Column filters; use `name = value` to filter columns by the supplied value.
+    #   Each constraint will behave the same as `Polars.col(name).eq(value)`, and
+    #   be implicitly joined with the other filter conditions using `&`.
     #
     # @return [Expr]
     #
@@ -2816,64 +3491,25 @@ module Polars
     #   # │ g1        ┆ 1   ┆ 2   │
     #   # │ g2        ┆ 0   ┆ 3   │
     #   # └───────────┴─────┴─────┘
-    def filter(predicate)
-      _from_rbexpr(_rbexpr.filter(predicate._rbexpr))
-    end
-
-    # Filter a single column.
-    #
-    # Alias for {#filter}.
-    #
-    # @param predicate [Expr]
-    #   Boolean expression.
-    #
-    # @return [Expr]
-    #
-    # @example
-    #   df = Polars::DataFrame.new(
-    #     {
-    #       "group_col" => ["g1", "g1", "g2"],
-    #       "b" => [1, 2, 3]
-    #     }
-    #   )
-    #   (
-    #     df.group_by("group_col").agg(
-    #       [
-    #         Polars.col("b").where(Polars.col("b") < 2).sum.alias("lt"),
-    #         Polars.col("b").where(Polars.col("b") >= 2).sum.alias("gte")
-    #       ]
-    #     )
-    #   ).sort("group_col")
-    #   # =>
-    #   # shape: (2, 3)
-    #   # ┌───────────┬─────┬─────┐
-    #   # │ group_col ┆ lt  ┆ gte │
-    #   # │ ---       ┆ --- ┆ --- │
-    #   # │ str       ┆ i64 ┆ i64 │
-    #   # ╞═══════════╪═════╪═════╡
-    #   # │ g1        ┆ 1   ┆ 2   │
-    #   # │ g2        ┆ 0   ┆ 3   │
-    #   # └───────────┴─────┴─────┘
-    def where(predicate)
-      filter(predicate)
+    def filter(*predicates, **constraints)
+      predicate = Utils.parse_predicates_constraints_into_expression(
+        *predicates, **constraints
+      )
+      wrap_expr(_rbexpr.filter(predicate))
     end
 
-    # Apply a custom Ruby function to a Series or sequence of Series.
+    # Apply a custom Ruby function to a Series or array of Series.
     #
-    # The output of this custom function must be a Series.
-    # If you want to apply a custom function elementwise over single values, see
-    # {#apply}. A use case for `map` is when you want to transform an
-    # expression with a third-party library.
-    #
-    # Read more in [the book](https://pola-rs.github.io/polars-book/user-guide/dsl/custom_functions.html).
-    #
-    # @param return_dtype [Symbol]
+    # @param return_dtype [Object]
     #   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!
+    # @param returns_scalar [Boolean]
+    #   If the function returns a scalar, by default it will be wrapped in
+    #   a list in the output, since the assumption is that the function
+    #   always returns something Series-like. If you want to keep the
+    #   result as a scalar, set this argument to True.
     #
     # @return [Expr]
     #
@@ -2884,7 +3520,7 @@ module Polars
     #       "cosine" => [1.0, 0.0, -1.0, 0.0]
     #     }
     #   )
-    #   df.select(Polars.all.map { |x| x.to_numpy.argmax })
+    #   df.select(Polars.all.map_batches(returns_scalar: true) { |x| x.to_numo.argmax })
     #   # =>
     #   # shape: (1, 2)
     #   # ┌──────┬────────┐
@@ -2894,22 +3530,24 @@ module Polars
     #   # ╞══════╪════════╡
     #   # │ 1    ┆ 0      │
     #   # └──────┴────────┘
-    # def map_batches(return_dtype: nil, agg_list: false, is_elementwise: false, returns_scalar: false, &f)
-    #   if !return_dtype.nil?
-    #     return_dtype = Utils.rb_type_to_dtype(return_dtype)
-    #   end
-    #   _from_rbexpr(
-    #     _rbexpr.map_batches(
-    #       # TODO _map_batches_wrapper
-    #       f,
-    #       return_dtype,
-    #       agg_list,
-    #       is_elementwise,
-    #       returns_scalar
-    #     )
-    #   )
-    # end
-    # alias_method :map, :map_batches
+    def map_batches(
+      return_dtype: nil,
+      is_elementwise: false,
+      returns_scalar: false,
+      &function
+    )
+      _wrap = lambda do |sl, *args, **kwargs|
+        function.(sl[0], *args, **kwargs)
+      end
+
+      F.map_batches(
+        [self],
+        return_dtype: return_dtype,
+        is_elementwise: is_elementwise,
+        returns_scalar: returns_scalar,
+        &_wrap
+      )
+    end
 
     # Apply a custom/user-defined function (UDF) in a GroupBy or Projection context.
     #
@@ -2934,24 +3572,24 @@ module Polars
     # Wherever possible you should strongly prefer the native expression API
     # to achieve the best performance.
     #
-    # @param return_dtype [Symbol]
+    # @param return_dtype [Object]
     #   Dtype of the output Series.
     #   If not set, polars will assume that
     #   the dtype remains unchanged.
     #
     # @return [Expr]
     #
-    # @example
+    # @example The function is applied to each element of column `'a'`:
     #   df = Polars::DataFrame.new(
     #     {
     #       "a" => [1, 2, 3, 1],
     #       "b" => ["a", "b", "c", "c"]
     #     }
     #   )
-    #
-    # @example In a selection context, the function is applied by row.
-    #   df.with_column(
-    #     Polars.col("a").map_elements { |x| x * 2 }.alias("a_times_2")
+    #   df.with_columns(
+    #     Polars.col("a")
+    #     .map_elements(return_dtype: Polars.self_dtype) { |x| x * 2 }
+    #     .alias("a_times_2")
     #   )
     #   # =>
     #   # shape: (4, 3)
@@ -2965,44 +3603,37 @@ module Polars
     #   # │ 3   ┆ c   ┆ 6         │
     #   # │ 1   ┆ c   ┆ 2         │
     #   # └─────┴─────┴───────────┘
-    #
-    # @example In a GroupBy context the function is applied by group:
-    #   df.lazy
-    #     .group_by("b", maintain_order: true)
-    #     .agg(
-    #       [
-    #         Polars.col("a").map_elements { |x| x.sum }
-    #       ]
-    #     )
-    #     .collect
-    #   # =>
-    #   # shape: (3, 2)
-    #   # ┌─────┬─────┐
-    #   # │ b   ┆ a   │
-    #   # │ --- ┆ --- │
-    #   # │ str ┆ i64 │
-    #   # ╞═════╪═════╡
-    #   # │ a   ┆ 1   │
-    #   # │ b   ┆ 2   │
-    #   # │ c   ┆ 4   │
-    #   # └─────┴─────┘
-    # 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_batches(agg_list: true, return_dtype: return_dtype, &wrap_f)
-    # end
-    # alias_method :apply, :map_elements
+    def map_elements(
+      return_dtype: nil,
+      skip_nulls: true,
+      pass_name: false,
+      strategy: "thread_local",
+      returns_scalar: false,
+      &function
+    )
+      if pass_name
+        raise Todo
+      else
+        wrap_f = lambda do |x, **kwargs|
+          return_dtype = kwargs[:return_dtype]
+          x.map_elements(return_dtype: return_dtype, skip_nulls: skip_nulls, &function)
+        end
+      end
+
+      if strategy == "thread_local"
+        map_batches(
+          return_dtype: return_dtype,
+          returns_scalar: false,
+          is_elementwise: true,
+          &wrap_f
+        )
+      elsif strategy == "threading"
+        raise Todo
+      else
+        msg = "strategy #{strategy.inspect} is not supported"
+        raise ArgumentError, msg
+      end
+    end
 
     # Explode a list or utf8 Series. This means that every item is expanded to a new
     # row.
@@ -3011,6 +3642,11 @@ module Polars
     #
     # @return [Expr]
     #
+    # @deprecated
+    #  `Expr#flatten` is deprecated and will be removed in a future version.
+    #   Use `Expr.list.explode(keep_nulls: false, empty_as_null: false)` instead,
+    #   which provides the behavior you likely expect.
+    #
     # @example
     #  df = Polars::DataFrame.new(
     #    {
@@ -3030,7 +3666,7 @@ module Polars
     #  # │ b     ┆ [2, 3, 4] │
     #  # └───────┴───────────┘
     def flatten
-      _from_rbexpr(_rbexpr.explode)
+      explode(empty_as_null: true, keep_nulls: true)
     end
 
     # Explode a list or utf8 Series.
@@ -3056,8 +3692,8 @@ module Polars
     #   # │ 5   │
     #   # │ 6   │
     #   # └─────┘
-    def explode
-      _from_rbexpr(_rbexpr.explode)
+    def explode(empty_as_null: true, keep_nulls: true)
+      wrap_expr(_rbexpr.explode(empty_as_null, keep_nulls))
     end
 
     # Take every nth value in the Series and return as a new Series.
@@ -3079,9 +3715,8 @@ module Polars
     #   # │ 7   │
     #   # └─────┘
     def gather_every(n, offset = 0)
-      _from_rbexpr(_rbexpr.gather_every(n, offset))
+      wrap_expr(_rbexpr.gather_every(n, offset))
     end
-    alias_method :take_every, :gather_every
 
     # Get the first `n` rows.
     #
@@ -3105,7 +3740,7 @@ module Polars
     #   # │ 3   │
     #   # └─────┘
     def head(n = 10)
-      _from_rbexpr(_rbexpr.head(n))
+      wrap_expr(_rbexpr.head(n))
     end
 
     # Get the last `n` rows.
@@ -3130,7 +3765,7 @@ module Polars
     #   # │ 7   │
     #   # └─────┘
     def tail(n = 10)
-      _from_rbexpr(_rbexpr.tail(n))
+      wrap_expr(_rbexpr.tail(n))
     end
 
     # Get the first `n` rows.
@@ -3160,39 +3795,122 @@ module Polars
       head(n)
     end
 
-    # Method equivalent of equality operator `expr == other`.
+    # Method equivalent of bitwise "and" operator `expr & other & ...`.
     #
-    # @param other [Object]
-    #   A literal or expression value to compare with.
+    # @param others [Array]
+    #   One or more integer or boolean expressions to evaluate/combine.
     #
     # @return [Expr]
+    #
     # @example
     #   df = Polars::DataFrame.new(
     #     {
-    #       "x" => [1.0, 2.0, Float::NAN, 4.0],
-    #       "y" => [2.0, 2.0, Float::NAN, 4.0]
+    #       "x" => [5, 6, 7, 4, 8],
+    #       "y" => [1.5, 2.5, 1.0, 4.0, -5.75],
+    #       "z" => [-9, 2, -1, 4, 8]
     #     }
     #   )
-    #   df.with_columns(
-    #     Polars.col("x").eq(Polars.col("y")).alias("x == y")
+    #   df.select(
+    #     (Polars.col("x") >= Polars.col("z"))
+    #     .and_(
+    #       Polars.col("y") >= Polars.col("z"),
+    #       Polars.col("y") == Polars.col("y"),
+    #       Polars.col("z") <= Polars.col("x"),
+    #       Polars.col("y") != Polars.col("x"),
+    #     )
+    #     .alias("all")
     #   )
     #   # =>
-    #   # shape: (4, 3)
-    #   # ┌─────┬─────┬────────┐
-    #   # │ x   ┆ y   ┆ x == y │
-    #   # │ --- ┆ --- ┆ ---    │
-    #   # │ f64 ┆ f64 ┆ bool   │
-    #   # ╞═════╪═════╪════════╡
-    #   # │ 1.0 ┆ 2.0 ┆ false  │
-    #   # │ 2.0 ┆ 2.0 ┆ true   │
-    #   # │ NaN ┆ NaN ┆ true   │
-    #   # │ 4.0 ┆ 4.0 ┆ true   │
-    #   # └─────┴─────┴────────┘
+    #   # shape: (5, 1)
+    #   # ┌───────┐
+    #   # │ all   │
+    #   # │ ---   │
+    #   # │ bool  │
+    #   # ╞═══════╡
+    #   # │ true  │
+    #   # │ true  │
+    #   # │ true  │
+    #   # │ false │
+    #   # │ false │
+    #   # └───────┘
+    def and_(*others)
+      ([self] + others).reduce(:&)
+    end
+
+    # Method equivalent of bitwise "or" operator `expr | other | ...`.
+    #
+    # @param others [Array]
+    #   One or more integer or boolean expressions to evaluate/combine.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "x" => [5, 6, 7, 4, 8],
+    #       "y" => [1.5, 2.5, 1.0, 4.0, -5.75],
+    #       "z" => [-9, 2, -1, 4, 8]
+    #     }
+    #   )
+    #   df.select(
+    #     (Polars.col("x") == Polars.col("y"))
+    #     .or_(
+    #       Polars.col("x") == Polars.col("y"),
+    #       Polars.col("y") == Polars.col("z"),
+    #       Polars.col("y").cast(Integer) == Polars.col("z"),
+    #     )
+    #     .alias("any")
+    #   )
+    #   # =>
+    #   # shape: (5, 1)
+    #   # ┌───────┐
+    #   # │ any   │
+    #   # │ ---   │
+    #   # │ bool  │
+    #   # ╞═══════╡
+    #   # │ false │
+    #   # │ true  │
+    #   # │ false │
+    #   # │ true  │
+    #   # │ false │
+    #   # └───────┘
+    def or_(*others)
+      ([self] + others).reduce(:|)
+    end
+
+    # Method equivalent of equality operator `expr == other`.
+    #
+    # @param other [Object]
+    #   A literal or expression value to compare with.
+    #
+    # @return [Expr]
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "x" => [1.0, 2.0, Float::NAN, 4.0],
+    #       "y" => [2.0, 2.0, Float::NAN, 4.0]
+    #     }
+    #   )
+    #   df.with_columns(
+    #     Polars.col("x").eq(Polars.col("y")).alias("x == y")
+    #   )
+    #   # =>
+    #   # shape: (4, 3)
+    #   # ┌─────┬─────┬────────┐
+    #   # │ x   ┆ y   ┆ x == y │
+    #   # │ --- ┆ --- ┆ ---    │
+    #   # │ f64 ┆ f64 ┆ bool   │
+    #   # ╞═════╪═════╪════════╡
+    #   # │ 1.0 ┆ 2.0 ┆ false  │
+    #   # │ 2.0 ┆ 2.0 ┆ true   │
+    #   # │ NaN ┆ NaN ┆ true   │
+    #   # │ 4.0 ┆ 4.0 ┆ true   │
+    #   # └─────┴─────┴────────┘
     def eq(other)
       self == other
     end
 
-    # Method equivalent of equality operator `expr == other` where `None == None`.
+    # Method equivalent of equality operator `expr == other` where `nil == nil`.
     #
     # This differs from default `eq` where null values are propagated.
     #
@@ -3228,7 +3946,7 @@ module Polars
     #   # └──────┴──────┴────────┴────────────────┘
     def eq_missing(other)
       other = Utils.parse_into_expression(other, str_as_lit: true)
-      _from_rbexpr(_rbexpr.eq_missing(other))
+      wrap_expr(_rbexpr.eq_missing(other))
     end
 
     # Method equivalent of "greater than or equal" operator `expr >= other`.
@@ -3396,7 +4114,7 @@ module Polars
       self != other
     end
 
-    # Method equivalent of equality operator `expr != other` where `None == None`.
+    # Method equivalent of equality operator `expr != other` where `nil == nil`.
     #
     # This differs from default `ne` where null values are propagated.
     #
@@ -3432,7 +4150,7 @@ module Polars
     #   # └──────┴──────┴────────┴────────────────┘
     def ne_missing(other)
       other = Utils.parse_into_expression(other, str_as_lit: true)
-      _from_rbexpr(_rbexpr.neq_missing(other))
+      wrap_expr(_rbexpr.neq_missing(other))
     end
 
     # Method equivalent of addition operator `expr + other`.
@@ -3509,7 +4227,7 @@ module Polars
     #   # │ 5   ┆ 2.5 ┆ 2    │
     #   # └─────┴─────┴──────┘
     def floordiv(other)
-      _from_rbexpr(_rbexpr.floordiv(_to_rbexpr(other)))
+      wrap_expr(_rbexpr.floordiv(_to_rbexpr(other)))
     end
 
     # Method equivalent of modulus operator `expr % other`.
@@ -3711,7 +4429,9 @@ module Polars
     # Check if elements of this expression are present in the other Series.
     #
     # @param other [Object]
-    #   Series or sequence of primitive type.
+    #   Series or array of primitive type.
+    # @param nulls_equal [Boolean]
+    #   If true, treat null as a distinct value. Null values will not propagate.
     #
     # @return [Expr]
     #
@@ -3719,29 +4439,21 @@ module Polars
     #   df = Polars::DataFrame.new(
     #     {"sets" => [[1, 2, 3], [1, 2], [9, 10]], "optional_members" => [1, 2, 3]}
     #   )
-    #   df.select([Polars.col("optional_members").is_in("sets").alias("contains")])
+    #   df.with_columns(contains: Polars.col("optional_members").is_in("sets"))
     #   # =>
-    #   # shape: (3, 1)
-    #   # ┌──────────┐
-    #   # │ contains │
-    #   # │ ---      │
-    #   # │ bool     │
-    #   # ╞══════════╡
-    #   # │ true     │
-    #   # │ true     │
-    #   # │ false    │
-    #   # └──────────┘
-    def is_in(other)
-      if other.is_a?(::Array)
-        if other.length == 0
-          other = Polars.lit(nil)._rbexpr
-        else
-          other = Polars.lit(Series.new(other))._rbexpr
-        end
-      else
-        other = Utils.parse_into_expression(other, str_as_lit: false)
-      end
-      _from_rbexpr(_rbexpr.is_in(other))
+    #   # shape: (3, 3)
+    #   # ┌───────────┬──────────────────┬──────────┐
+    #   # │ sets      ┆ optional_members ┆ contains │
+    #   # │ ---       ┆ ---              ┆ ---      │
+    #   # │ list[i64] ┆ i64              ┆ bool     │
+    #   # ╞═══════════╪══════════════════╪══════════╡
+    #   # │ [1, 2, 3] ┆ 1                ┆ true     │
+    #   # │ [1, 2]    ┆ 2                ┆ true     │
+    #   # │ [9, 10]   ┆ 3                ┆ false    │
+    #   # └───────────┴──────────────────┴──────────┘
+    def is_in(other, nulls_equal: false)
+      other = Utils.parse_into_expression(other)
+      wrap_expr(_rbexpr.is_in(other, nulls_equal))
     end
     alias_method :in?, :is_in
 
@@ -3777,7 +4489,7 @@ module Polars
     #   # └─────────────────┘
     def repeat_by(by)
       by = Utils.parse_into_expression(by, str_as_lit: false)
-      _from_rbexpr(_rbexpr.repeat_by(by))
+      wrap_expr(_rbexpr.repeat_by(by))
     end
 
     # Check if this expression is between start and end.
@@ -3850,14 +4562,51 @@ module Polars
       lower_bound = Utils.parse_into_expression(lower_bound)
       upper_bound = Utils.parse_into_expression(upper_bound)
 
-      _from_rbexpr(
+      wrap_expr(
         _rbexpr.is_between(lower_bound, upper_bound, closed)
       )
     end
 
+    # Check if this expression is close, i.e. almost equal, to the other expression.
+    #
+    # @param abs_tol [Float]
+    #   Absolute tolerance. This is the maximum allowed absolute difference between
+    #   two values. Must be non-negative.
+    # @param rel_tol [Float]
+    #   Relative tolerance. This is the maximum allowed difference between two
+    #   values, relative to the larger absolute value. Must be in the range [0, 1).
+    # @param nans_equal [Boolean]
+    #   Whether NaN values should be considered equal.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"a" => [1.5, 2.0, 2.5], "b" => [1.55, 2.2, 3.0]})
+    #   df.with_columns(Polars.col("a").is_close("b", abs_tol: 0.1).alias("is_close"))
+    #   # =>
+    #   # shape: (3, 3)
+    #   # ┌─────┬──────┬──────────┐
+    #   # │ a   ┆ b    ┆ is_close │
+    #   # │ --- ┆ ---  ┆ ---      │
+    #   # │ f64 ┆ f64  ┆ bool     │
+    #   # ╞═════╪══════╪══════════╡
+    #   # │ 1.5 ┆ 1.55 ┆ true     │
+    #   # │ 2.0 ┆ 2.2  ┆ false    │
+    #   # │ 2.5 ┆ 3.0  ┆ false    │
+    #   # └─────┴──────┴──────────┘
+    def is_close(
+      other,
+      abs_tol: 0.0,
+      rel_tol: 1.0e-09,
+      nans_equal: false
+    )
+      other = Utils.parse_into_expression(other)
+      wrap_expr(_rbexpr.is_close(other, abs_tol, rel_tol, nans_equal))
+    end
+
     # Hash the elements in the selection.
     #
-    # The hash value is of type `:u64`.
+    # The hash value is of type `UInt64`.
     #
     # @param seed [Integer]
     #   Random seed parameter. Defaults to 0.
@@ -3877,7 +4626,7 @@ module Polars
     #       "b" => ["x", nil, "z"]
     #     }
     #   )
-    #   df.with_column(Polars.all._hash(10, 20, 30, 40))
+    #   df.with_columns(Polars.all.hash_(10, 20, 30, 40))
     #   # =>
     #   # shape: (3, 2)
     #   # ┌──────────────────────┬──────────────────────┐
@@ -3889,30 +4638,35 @@ module Polars
     #   # │ 16386608652769605760 ┆ 11638928888656214026 │
     #   # │ 11638928888656214026 ┆ 11040941213715918520 │
     #   # └──────────────────────┴──────────────────────┘
-    def _hash(seed = 0, seed_1 = nil, seed_2 = nil, seed_3 = nil)
+    def hash_(seed = 0, seed_1 = nil, seed_2 = nil, seed_3 = nil)
       k0 = seed
       k1 = seed_1.nil? ? seed : seed_1
       k2 = seed_2.nil? ? seed : seed_2
       k3 = seed_3.nil? ? seed : seed_3
-      _from_rbexpr(_rbexpr._hash(k0, k1, k2, k3))
+      wrap_expr(_rbexpr._hash(k0, k1, k2, k3))
     end
 
-    # Reinterpret the underlying bits as a signed/unsigned integer.
+    # Reinterpret the underlying bits as a signed/unsigned integer or float.
+    #
+    # This operation is only allowed for numeric types of the same size.
+    # For lower bits numbers, you can safely use the cast operation.
     #
-    # This operation is only allowed for 64bit integers. For lower bits integers,
-    # you can safely use that cast operation.
+    # Either `signed` or `dtype` can be specified.
     #
     # @param signed [Boolean]
-    #   If true, reinterpret as `:i64`. Otherwise, reinterpret as `:u64`.
+    #   If true, reinterpret as signed integer. Otherwise, reinterpret
+    #   as unsigned integer.
+    # @param dtype [Object]
+    #   DataType to reinterpret to.
     #
     # @return [Expr]
     #
     # @example
-    #   s = Polars::Series.new("a", [1, 1, 2], dtype: :u64)
+    #   s = Polars::Series.new("a", [1, 1, 2], dtype: Polars::UInt64)
     #   df = Polars::DataFrame.new([s])
     #   df.select(
     #     [
-    #       Polars.col("a").reinterpret(signed: true).alias("reinterpreted"),
+    #       Polars.col("a").reinterpret(dtype: Polars::Int64).alias("reinterpreted"),
     #       Polars.col("a").alias("original")
     #     ]
     #   )
@@ -3927,8 +4681,13 @@ module Polars
     #   # │ 1             ┆ 1        │
     #   # │ 2             ┆ 2        │
     #   # └───────────────┴──────────┘
-    def reinterpret(signed: false)
-      _from_rbexpr(_rbexpr.reinterpret(signed))
+    def reinterpret(signed: nil, dtype: nil)
+      if signed.nil? == dtype.nil?
+        msg = "reinterpret requires exactly one of `signed` or `dtype` to be specified"
+        raise ArgumentError, msg
+      end
+
+      wrap_expr(_rbexpr.reinterpret(signed, dtype))
     end
 
     # Print the value that this expression evaluates to and pass on the value.
@@ -3937,14 +4696,14 @@ module Polars
     #
     # @example
     #   df = Polars::DataFrame.new({"foo" => [1, 1, 2]})
-    #   df.select(Polars.col("foo").cumsum._inspect("value is: %s").alias("bar"))
+    #   df.select(Polars.col("foo").cum_sum.inspect_("value is: %s").alias("bar"))
     #   # =>
     #   # value is: shape: (3,)
     #   # Series: 'foo' [i64]
     #   # [
-    #   #     1
-    #   #     2
-    #   #     4
+    #   #         1
+    #   #         2
+    #   #         4
     #   # ]
     #   # shape: (3, 1)
     #   # ┌─────┐
@@ -3956,14 +4715,14 @@ module Polars
     #   # │ 2   │
     #   # │ 4   │
     #   # └─────┘
-    # def _inspect(fmt = "%s")
-    #   inspect = lambda do |s|
-    #     puts(fmt % [s])
-    #     s
-    #   end
+    def inspect_(fmt = "%s")
+      inspect = lambda do |s|
+        puts(fmt % [s])
+        s
+      end
 
-    #   map(return_dtype: nil, agg_list: true, &inspect)
-    # end
+      map_batches(return_dtype: F.dtype_of(self), &inspect)
+    end
 
     # Fill nulls with linear interpolation over missing values.
     #
@@ -3991,7 +4750,38 @@ module Polars
     #   # │ 3.0 ┆ 3.0 │
     #   # └─────┴─────┘
     def interpolate(method: "linear")
-      _from_rbexpr(_rbexpr.interpolate(method))
+      wrap_expr(_rbexpr.interpolate(method))
+    end
+
+    # Fill null values using interpolation based on another column.
+    #
+    # @param by [Expr] Column to interpolate values based on.
+    #
+    # @return [Expr]
+    #
+    # @example Fill null values using linear interpolation.
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "a" => [1, nil, nil, 3],
+    #       "b" => [1, 2, 7, 8]
+    #     }
+    #   )
+    #   df.with_columns(a_interpolated: Polars.col("a").interpolate_by("b"))
+    #   # =>
+    #   # shape: (4, 3)
+    #   # ┌──────┬─────┬────────────────┐
+    #   # │ a    ┆ b   ┆ a_interpolated │
+    #   # │ ---  ┆ --- ┆ ---            │
+    #   # │ i64  ┆ i64 ┆ f64            │
+    #   # ╞══════╪═════╪════════════════╡
+    #   # │ 1    ┆ 1   ┆ 1.0            │
+    #   # │ null ┆ 2   ┆ 1.285714       │
+    #   # │ null ┆ 7   ┆ 2.714286       │
+    #   # │ 3    ┆ 8   ┆ 3.0            │
+    #   # └──────┴─────┴────────────────┘
+    def interpolate_by(by)
+      by = Utils.parse_into_expression(by)
+      wrap_expr(_rbexpr.interpolate_by(by))
     end
 
     # Apply a rolling min based on another column.
@@ -4018,14 +4808,12 @@ module Polars
     #   (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]
+    # @param min_samples [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]
     #
@@ -4086,14 +4874,13 @@ module Polars
     def rolling_min_by(
       by,
       window_size,
-      min_periods: 1,
-      closed: "right",
-      warn_if_unsorted: nil
+      min_samples: 1,
+      closed: "right"
     )
       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)
+      wrap_expr(
+        _rbexpr.rolling_min_by(by, window_size, min_samples, closed)
       )
     end
 
@@ -4121,14 +4908,12 @@ module Polars
     #   (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]
+    # @param min_samples [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]
     #
@@ -4215,14 +5000,13 @@ module Polars
     def rolling_max_by(
       by,
       window_size,
-      min_periods: 1,
-      closed: "right",
-      warn_if_unsorted: nil
+      min_samples: 1,
+      closed: "right"
     )
       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)
+      wrap_expr(
+        _rbexpr.rolling_max_by(by, window_size, min_samples, closed)
       )
     end
 
@@ -4250,14 +5034,12 @@ module Polars
     #   (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]
+    # @param min_samples [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]
     #
@@ -4346,17 +5128,16 @@ module Polars
     def rolling_mean_by(
       by,
       window_size,
-      min_periods: 1,
-      closed: "right",
-      warn_if_unsorted: nil
+      min_samples: 1,
+      closed: "right"
     )
       window_size = _prepare_rolling_by_window_args(window_size)
       by = Utils.parse_into_expression(by)
-      _from_rbexpr(
+      wrap_expr(
         _rbexpr.rolling_mean_by(
           by,
           window_size,
-          min_periods,
+          min_samples,
           closed
         )
       )
@@ -4386,14 +5167,12 @@ module Polars
     #   (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]
+    # @param min_samples [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]
     #
@@ -4480,14 +5259,13 @@ module Polars
     def rolling_sum_by(
       by,
       window_size,
-      min_periods: 1,
-      closed: "right",
-      warn_if_unsorted: nil
+      min_samples: 0,
+      closed: "right"
     )
       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)
+      wrap_expr(
+        _rbexpr.rolling_sum_by(by, window_size, min_samples, closed)
       )
     end
 
@@ -4515,7 +5293,7 @@ module Polars
     #   (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]
+    # @param min_samples [Integer]
     #   The number of values in the window that should be non-null before computing
     #   a result.
     # @param closed ['left', 'right', 'both', 'none']
@@ -4523,8 +5301,6 @@ module Polars
     #   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]
     #
@@ -4611,18 +5387,17 @@ module Polars
     def rolling_std_by(
       by,
       window_size,
-      min_periods: 1,
+      min_samples: 1,
       closed: "right",
-      ddof: 1,
-      warn_if_unsorted: nil
+      ddof: 1
     )
       window_size = _prepare_rolling_by_window_args(window_size)
       by = Utils.parse_into_expression(by)
-      _from_rbexpr(
+      wrap_expr(
         _rbexpr.rolling_std_by(
           by,
           window_size,
-          min_periods,
+          min_samples,
           closed,
           ddof
         )
@@ -4653,7 +5428,7 @@ module Polars
     #   (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]
+    # @param min_samples [Integer]
     #   The number of values in the window that should be non-null before computing
     #   a result.
     # @param closed ['left', 'right', 'both', 'none']
@@ -4661,8 +5436,6 @@ module Polars
     #   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]
     #
@@ -4749,18 +5522,17 @@ module Polars
     def rolling_var_by(
       by,
       window_size,
-      min_periods: 1,
+      min_samples: 1,
       closed: "right",
-      ddof: 1,
-      warn_if_unsorted: nil
+      ddof: 1
     )
       window_size = _prepare_rolling_by_window_args(window_size)
       by = Utils.parse_into_expression(by)
-      _from_rbexpr(
+      wrap_expr(
         _rbexpr.rolling_var_by(
           by,
           window_size,
-          min_periods,
+          min_samples,
           closed,
           ddof
         )
@@ -4791,14 +5563,12 @@ module Polars
     #   (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]
+    # @param min_samples [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]
     #
@@ -4861,14 +5631,13 @@ module Polars
     def rolling_median_by(
       by,
       window_size,
-      min_periods: 1,
-      closed: "right",
-      warn_if_unsorted: nil
+      min_samples: 1,
+      closed: "right"
     )
       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)
+      wrap_expr(
+        _rbexpr.rolling_median_by(by, window_size, min_samples, closed)
       )
     end
 
@@ -4876,10 +5645,6 @@ module Polars
     #
     # @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:
@@ -4900,14 +5665,16 @@ module Polars
     #   (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]
+    # @param quantile [Float]
+    #   Quantile between 0.0 and 1.0.
+    # @param interpolation ['nearest', 'higher', 'lower', 'midpoint', 'linear']
+    #   Interpolation method.
+    # @param min_samples [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]
     #
@@ -4972,24 +5739,110 @@ module Polars
       window_size,
       quantile:,
       interpolation: "nearest",
-      min_periods: 1,
-      closed: "right",
-      warn_if_unsorted: nil
+      min_samples: 1,
+      closed: "right"
     )
       window_size = _prepare_rolling_by_window_args(window_size)
       by = Utils.parse_into_expression(by)
-      _from_rbexpr(
+      wrap_expr(
         _rbexpr.rolling_quantile_by(
           by,
           quantile,
           interpolation,
           window_size,
-          min_periods,
+          min_samples,
           closed,
         )
       )
     end
 
+    # Compute a rolling rank based on another column.
+    #
+    # @note
+    #   This functionality is considered **unstable**. It may be changed
+    #   at any point without it being considered a breaking change.
+    #
+    # Given a `by` column `<t_0, t_1, ..., t_n>`, then `closed: "right"`
+    # (the default) means the windows will be:
+    #
+    #   - (t_0 - window_size, t_0]
+    #   - (t_1 - window_size, t_1]
+    #   - ...
+    #   - (t_n - window_size, t_n]
+    #
+    # @param by [Expr]
+    #   Should be `DateTime`, `Date`, `UInt64`, `UInt32`, `Int64`,
+    #   or `Int32` data type (note that the integral ones require using `'i'`
+    #   in `window size`).
+    # @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)
+    #   - 1i    (1 index count)
+    #
+    #   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 method ['average', 'min', 'max', 'dense', 'random']
+    #   The method used to assign ranks to tied elements.
+    #   The following methods are available (default is 'average'):
+    #
+    #   - 'average' : The average of the ranks that would have been assigned to
+    #     all the tied values is assigned to each value.
+    #   - 'min' : The minimum of the ranks that would have been assigned to all
+    #     the tied values is assigned to each value. (This is also referred to
+    #     as "competition" ranking.)
+    #   - 'max' : The maximum of the ranks that would have been assigned to all
+    #     the tied values is assigned to each value.
+    #   - 'dense' : Like 'min', but the rank of the next highest element is
+    #     assigned the rank immediately after those assigned to the tied
+    #     elements.
+    #   - 'random' : Choose a random rank for each value in a tie.
+    # @param seed [Integer]
+    #   Random seed used when `method: 'random'`. If set to nil (default), a
+    #   random seed is generated for each rolling rank operation.
+    # @param min_samples [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'`.
+    #
+    # @return [Expr]
+    def rolling_rank_by(
+      by,
+      window_size,
+      method: "average",
+      seed: nil,
+      min_samples: 1,
+      closed: "right"
+    )
+      window_size = _prepare_rolling_by_window_args(window_size)
+      by_rbexpr = Utils.parse_into_expression(by)
+      Utils.wrap_expr(
+        _rbexpr.rolling_rank_by(
+          by_rbexpr,
+          window_size,
+          method,
+          seed,
+          min_samples,
+          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
@@ -5017,9 +5870,9 @@ module Polars
     # @param weights [Array]
     #   An optional slice with the same length as the window that will be multiplied
     #   elementwise with the values in the window.
-    # @param min_periods [Integer]
+    # @param min_samples [Integer]
     #   The number of values in the window that should be non-null before computing
-    #   a result. If None, it will be set equal to window size.
+    #   a result. If nil, it will be set equal to window size.
     # @param center [Boolean]
     #   Set the labels at the center of the window
     #
@@ -5029,7 +5882,7 @@ module Polars
     #
     # @note
     #   If you want to compute multiple aggregation statistics over the same dynamic
-    #   window, consider using `group_by_rolling` this method can cache the window size
+    #   window, consider using `rolling` this method can cache the window size
     #   computation.
     #
     # @return [Expr]
@@ -5058,12 +5911,12 @@ module Polars
     def rolling_min(
       window_size,
       weights: nil,
-      min_periods: nil,
+      min_samples: nil,
       center: false
     )
-      _from_rbexpr(
+      wrap_expr(
         _rbexpr.rolling_min(
-          window_size, weights, min_periods, center
+          window_size, weights, min_samples, center
         )
       )
     end
@@ -5095,9 +5948,9 @@ module Polars
     # @param weights [Array]
     #   An optional slice with the same length as the window that will be multiplied
     #   elementwise with the values in the window.
-    # @param min_periods [Integer]
+    # @param min_samples [Integer]
     #   The number of values in the window that should be non-null before computing
-    #   a result. If None, it will be set equal to window size.
+    #   a result. If nil, it will be set equal to window size.
     # @param center [Boolean]
     #   Set the labels at the center of the window
     #
@@ -5107,7 +5960,7 @@ module Polars
     #
     # @note
     #   If you want to compute multiple aggregation statistics over the same dynamic
-    #   window, consider using `group_by_rolling` this method can cache the window size
+    #   window, consider using `rolling` this method can cache the window size
     #   computation.
     #
     # @return [Expr]
@@ -5136,12 +5989,12 @@ module Polars
     def rolling_max(
       window_size,
       weights: nil,
-      min_periods: nil,
+      min_samples: nil,
       center: false
     )
-      _from_rbexpr(
+      wrap_expr(
         _rbexpr.rolling_max(
-          window_size, weights, min_periods, center
+          window_size, weights, min_samples, center
         )
       )
     end
@@ -5173,9 +6026,9 @@ module Polars
     # @param weights [Array]
     #   An optional slice with the same length as the window that will be multiplied
     #   elementwise with the values in the window.
-    # @param min_periods [Integer]
+    # @param min_samples [Integer]
     #   The number of values in the window that should be non-null before computing
-    #   a result. If None, it will be set equal to window size.
+    #   a result. If nil, it will be set equal to window size.
     # @param center [Boolean]
     #   Set the labels at the center of the window
     #
@@ -5185,7 +6038,7 @@ module Polars
     #
     # @note
     #   If you want to compute multiple aggregation statistics over the same dynamic
-    #   window, consider using `group_by_rolling` this method can cache the window size
+    #   window, consider using `rolling` this method can cache the window size
     #   computation.
     #
     # @return [Expr]
@@ -5214,12 +6067,12 @@ module Polars
     def rolling_mean(
       window_size,
       weights: nil,
-      min_periods: nil,
+      min_samples: nil,
       center: false
     )
-      _from_rbexpr(
+      wrap_expr(
         _rbexpr.rolling_mean(
-          window_size, weights, min_periods, center
+          window_size, weights, min_samples, center
         )
       )
     end
@@ -5251,9 +6104,9 @@ module Polars
     # @param weights [Array]
     #   An optional slice with the same length as the window that will be multiplied
     #   elementwise with the values in the window.
-    # @param min_periods [Integer]
+    # @param min_samples [Integer]
     #   The number of values in the window that should be non-null before computing
-    #   a result. If None, it will be set equal to window size.
+    #   a result. If nil, it will be set equal to window size.
     # @param center [Boolean]
     #   Set the labels at the center of the window
     #
@@ -5263,7 +6116,7 @@ module Polars
     #
     # @note
     #   If you want to compute multiple aggregation statistics over the same dynamic
-    #   window, consider using `group_by_rolling` this method can cache the window size
+    #   window, consider using `rolling` this method can cache the window size
     #   computation.
     #
     # @return [Expr]
@@ -5292,12 +6145,12 @@ module Polars
     def rolling_sum(
       window_size,
       weights: nil,
-      min_periods: nil,
+      min_samples: nil,
       center: false
     )
-      _from_rbexpr(
+      wrap_expr(
         _rbexpr.rolling_sum(
-          window_size, weights, min_periods, center
+          window_size, weights, min_samples, center
         )
       )
     end
@@ -5329,11 +6182,13 @@ module Polars
     # @param weights [Array]
     #   An optional slice with the same length as the window that will be multiplied
     #   elementwise with the values in the window.
-    # @param min_periods [Integer]
+    # @param min_samples [Integer]
     #   The number of values in the window that should be non-null before computing
-    #   a result. If None, it will be set equal to window size.
+    #   a result. If nil, it will be set equal to window size.
     # @param center [Boolean]
     #   Set the labels at the center of the window
+    # @param ddof [Integer]
+    #   "Delta Degrees of Freedom": The divisor for a length N window is N - ddof
     #
     # @note
     #   This functionality is experimental and may change without it being considered a
@@ -5341,7 +6196,7 @@ module Polars
     #
     # @note
     #   If you want to compute multiple aggregation statistics over the same dynamic
-    #   window, consider using `group_by_rolling` this method can cache the window size
+    #   window, consider using `rolling` this method can cache the window size
     #   computation.
     #
     # @return [Expr]
@@ -5370,13 +6225,13 @@ module Polars
     def rolling_std(
       window_size,
       weights: nil,
-      min_periods: nil,
+      min_samples: nil,
       center: false,
       ddof: 1
     )
-      _from_rbexpr(
+      wrap_expr(
         _rbexpr.rolling_std(
-          window_size, weights, min_periods, center, ddof
+          window_size, weights, min_samples, center, ddof
         )
       )
     end
@@ -5408,11 +6263,13 @@ module Polars
     # @param weights [Array]
     #   An optional slice with the same length as the window that will be multiplied
     #   elementwise with the values in the window.
-    # @param min_periods [Integer]
+    # @param min_samples [Integer]
     #   The number of values in the window that should be non-null before computing
-    #   a result. If None, it will be set equal to window size.
+    #   a result. If nil, it will be set equal to window size.
     # @param center [Boolean]
     #   Set the labels at the center of the window
+    # @param ddof [Integer]
+    #   "Delta Degrees of Freedom": The divisor for a length N window is N - ddof
     #
     # @note
     #   This functionality is experimental and may change without it being considered a
@@ -5420,7 +6277,7 @@ module Polars
     #
     # @note
     #   If you want to compute multiple aggregation statistics over the same dynamic
-    #   window, consider using `group_by_rolling` this method can cache the window size
+    #   window, consider using `rolling` this method can cache the window size
     #   computation.
     #
     # @return [Expr]
@@ -5449,13 +6306,13 @@ module Polars
     def rolling_var(
       window_size,
       weights: nil,
-      min_periods: nil,
+      min_samples: nil,
       center: false,
       ddof: 1
     )
-      _from_rbexpr(
+      wrap_expr(
         _rbexpr.rolling_var(
-          window_size, weights, min_periods, center, ddof
+          window_size, weights, min_samples, center, ddof
         )
       )
     end
@@ -5483,9 +6340,9 @@ module Polars
     # @param weights [Array]
     #   An optional slice with the same length as the window that will be multiplied
     #   elementwise with the values in the window.
-    # @param min_periods [Integer]
+    # @param min_samples [Integer]
     #   The number of values in the window that should be non-null before computing
-    #   a result. If None, it will be set equal to window size.
+    #   a result. If nil, it will be set equal to window size.
     # @param center [Boolean]
     #   Set the labels at the center of the window
     #
@@ -5495,7 +6352,7 @@ module Polars
     #
     # @note
     #   If you want to compute multiple aggregation statistics over the same dynamic
-    #   window, consider using `group_by_rolling` this method can cache the window size
+    #   window, consider using `rolling` this method can cache the window size
     #   computation.
     #
     # @return [Expr]
@@ -5524,12 +6381,12 @@ module Polars
     def rolling_median(
       window_size,
       weights: nil,
-      min_periods: nil,
+      min_samples: nil,
       center: false
     )
-      _from_rbexpr(
+      wrap_expr(
         _rbexpr.rolling_median(
-          window_size, weights, min_periods, center
+          window_size, weights, min_samples, center
         )
       )
     end
@@ -5561,9 +6418,9 @@ module Polars
     # @param weights [Array]
     #   An optional slice with the same length as the window that will be multiplied
     #   elementwise with the values in the window.
-    # @param min_periods [Integer]
+    # @param min_samples [Integer]
     #   The number of values in the window that should be non-null before computing
-    #   a result. If None, it will be set equal to window size.
+    #   a result. If nil, it will be set equal to window size.
     # @param center [Boolean]
     #   Set the labels at the center of the window
     #
@@ -5573,7 +6430,7 @@ module Polars
     #
     # @note
     #   If you want to compute multiple aggregation statistics over the same dynamic
-    #   window, consider using `group_by_rolling` this method can cache the window size
+    #   window, consider using `rolling` this method can cache the window size
     #   computation.
     #
     # @return [Expr]
@@ -5594,89 +6451,98 @@ module Polars
     #   # ╞══════╡
     #   # │ null │
     #   # │ null │
-    #   # │ 1.0  │
     #   # │ 2.0  │
     #   # │ 3.0  │
     #   # │ 4.0  │
+    #   # │ 6.0  │
     #   # └──────┘
     def rolling_quantile(
       quantile,
       interpolation: "nearest",
       window_size: 2,
       weights: nil,
-      min_periods: nil,
+      min_samples: nil,
       center: false
     )
-      _from_rbexpr(
+      wrap_expr(
         _rbexpr.rolling_quantile(
-          quantile, interpolation, window_size, weights, min_periods, center
+          quantile, interpolation, window_size, weights, min_samples, center
         )
       )
     end
 
-    # Apply a custom rolling window function.
+    # Compute a rolling rank.
     #
-    # Prefer the specific rolling window functions over this one, as they are faster.
+    # @note
+    #   This functionality is considered **unstable**. It may be changed
+    #   at any point without it being considered a breaking change.
     #
-    # Prefer:
-    # * rolling_min
-    # * rolling_max
-    # * rolling_mean
-    # * rolling_sum
+    # A window of length `window_size` will traverse the array. The values
+    # that fill this window will be ranked according to the `method`
+    # parameter. The resulting values will be the rank of the value that is
+    # at the end of the sliding window.
     #
     # @param window_size [Integer]
-    #   The length of the window.
-    # @param weights [Object]
-    #   An optional slice with the same length as the window that will be multiplied
-    #   elementwise with the values in the window.
-    # @param min_periods [Integer]
+    #   Integer size of the rolling window.
+    # @param method ['average', 'min', 'max', 'dense', 'random']
+    #   The method used to assign ranks to tied elements.
+    #   The following methods are available (default is 'average'):
+    #
+    #   - 'average' : The average of the ranks that would have been assigned to
+    #     all the tied values is assigned to each value.
+    #   - 'min' : The minimum of the ranks that would have been assigned to all
+    #     the tied values is assigned to each value. (This is also referred to
+    #     as "competition" ranking.)
+    #   - 'max' : The maximum of the ranks that would have been assigned to all
+    #     the tied values is assigned to each value.
+    #   - 'dense' : Like 'min', but the rank of the next highest element is
+    #     assigned the rank immediately after those assigned to the tied
+    #     elements.
+    #   - 'random' : Choose a random rank for each value in a tie.
+    # @param seed [Integer]
+    #   Random seed used when `method: 'random'`. If set to nil (default), a
+    #   random seed is generated for each rolling rank operation.
+    # @param min_samples [Integer]
     #   The number of values in the window that should be non-null before computing
-    #   a result. If nil, it will be set equal to window size.
+    #   a result. If set to `nil` (default), it will be set equal to `window_size`.
     # @param center [Boolean]
-    #   Set the labels at the center of the window
+    #   Set the labels at the center of the window.
     #
     # @return [Expr]
     #
     # @example
-    #   df = Polars::DataFrame.new(
-    #     {
-    #       "A" => [1.0, 2.0, 9.0, 2.0, 13.0]
-    #     }
-    #   )
-    #   df.select(
-    #     [
-    #       Polars.col("A").rolling_apply(window_size: 3) { |s| s.std }
-    #     ]
-    #   )
+    #   df = Polars::DataFrame.new({"a" => [1, 4, 4, 1, 9]})
+    #   df.select(Polars.col("a").rolling_rank(3, method: "average"))
     #   # =>
     #   # shape: (5, 1)
-    #   # ┌──────────┐
-    #   # │ A        │
-    #   # │ ---      │
-    #   # │ f64      │
-    #   # ╞══════════╡
-    #   # │ null     │
-    #   # │ null     │
-    #   # │ 4.358899 │
-    #   # │ 4.041452 │
-    #   # │ 5.567764 │
-    #   # └──────────┘
-    # def rolling_apply(
-    #   window_size:,
-    #   weights: nil,
-    #   min_periods: nil,
-    #   center: false,
-    #   &function
-    # )
-    #   if min_periods.nil?
-    #     min_periods = window_size
-    #   end
-    #   _from_rbexpr(
-    #     _rbexpr.rolling_apply(
-    #       function, window_size, weights, min_periods, center
-    #     )
-    #   )
-    # end
+    #   # ┌──────┐
+    #   # │ a    │
+    #   # │ ---  │
+    #   # │ f64  │
+    #   # ╞══════╡
+    #   # │ null │
+    #   # │ null │
+    #   # │ 2.5  │
+    #   # │ 1.0  │
+    #   # │ 3.0  │
+    #   # └──────┘
+    def rolling_rank(
+      window_size,
+      method: "average",
+      seed: nil,
+      min_samples: nil,
+      center: false
+    )
+      Utils.wrap_expr(
+        _rbexpr.rolling_rank(
+          window_size,
+          method,
+          seed,
+          min_samples,
+          center
+        )
+      )
+    end
 
     # Compute a rolling skew.
     #
@@ -5684,6 +6550,11 @@ module Polars
     #   Integer size of the rolling window.
     # @param bias [Boolean]
     #   If false, the calculations are corrected for statistical bias.
+    # @param min_samples [Integer]
+    #   The number of values in the window that should be non-null before computing
+    #   a result. If set to `nil` (default), it will be set equal to `window_size`.
+    # @param center [Boolean]
+    #   Set the labels at the center of the window.
     #
     # @return [Expr]
     #
@@ -5702,13 +6573,131 @@ module Polars
     #   # │ 0.381802 │
     #   # │ 0.47033  │
     #   # └──────────┘
-    def rolling_skew(window_size, bias: true)
-      _from_rbexpr(_rbexpr.rolling_skew(window_size, bias))
+    def rolling_skew(window_size, bias: true, min_samples: nil, center: false)
+      wrap_expr(_rbexpr.rolling_skew(window_size, bias, min_samples, center))
     end
 
-    # Compute absolute values.
+    # Compute a rolling kurtosis.
     #
-    # @return [Expr]
+    # @note
+    #   This functionality is considered **unstable**. It may be changed
+    #   at any point without it being considered a breaking change.
+    #
+    # The window at a given row will include the row itself, and the `window_size - 1`
+    # elements before it.
+    #
+    # @param window_size [Integer]
+    #   Integer size of the rolling window.
+    # @param fisher [Boolean]
+    #   If true, Fisher's definition is used (normal ==> 0.0). If false,
+    #   Pearson's definition is used (normal ==> 3.0).
+    # @param bias [Boolean]
+    #   If false, the calculations are corrected for statistical bias.
+    # @param min_samples [Integer]
+    #   The number of values in the window that should be non-null before computing
+    #   a result. If set to `nil` (default), it will be set equal to `window_size`.
+    # @param center
+    #   Set the labels at the center of the window.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"a" => [1, 4, 2, 9]})
+    #   df.select(Polars.col("a").rolling_kurtosis(3))
+    #   # =>
+    #   # shape: (4, 1)
+    #   # ┌──────┐
+    #   # │ a    │
+    #   # │ ---  │
+    #   # │ f64  │
+    #   # ╞══════╡
+    #   # │ null │
+    #   # │ null │
+    #   # │ -1.5 │
+    #   # │ -1.5 │
+    #   # └──────┘
+    def rolling_kurtosis(
+      window_size,
+      fisher: true,
+      bias: true,
+      min_samples: nil,
+      center: false
+    )
+      wrap_expr(
+        _rbexpr.rolling_kurtosis(
+          window_size,
+          fisher,
+          bias,
+          min_samples,
+          center
+        )
+      )
+    end
+
+    # Compute a custom rolling window function.
+    #
+    # @note
+    #   This functionality is considered **unstable**. It may be changed
+    #   at any point without it being considered a breaking change.
+    #
+    # @param window_size [Integer]
+    #   The length of the window in number of elements.
+    # @param weights [Object]
+    #   An optional slice with the same length as the window that will be multiplied
+    #   elementwise with the values in the window.
+    # @param min_samples [Integer]
+    #   The number of values in the window that should be non-null before computing
+    #   a result. If set to `nil` (default), it will be set equal to `window_size`.
+    # @param center [Boolean]
+    #   Set the labels at the center of the window.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"a" => [11.0, 2.0, 9.0, Float::NAN, 8.0]})
+    #   df.select(Polars.col("a").rolling_map(3) { |v| v.drop_nans.sum })
+    #   # =>
+    #   # shape: (5, 1)
+    #   # ┌──────┐
+    #   # │ a    │
+    #   # │ ---  │
+    #   # │ f64  │
+    #   # ╞══════╡
+    #   # │ null │
+    #   # │ null │
+    #   # │ 22.0 │
+    #   # │ 11.0 │
+    #   # │ 17.0 │
+    #   # └──────┘
+    def rolling_map(
+      window_size,
+      weights: nil,
+      min_samples: nil,
+      center: false,
+      &function
+    )
+      if min_samples.nil?
+        min_samples = window_size
+      end
+
+      _wrap = lambda do |rbs|
+        s = Utils.wrap_s(rbs)
+        rv = function.(s)
+        if rv.is_a?(Series)
+          rv._s
+        else
+          Series.new([rv])._s
+        end
+      end
+
+      wrap_expr(
+        _rbexpr.rolling_map(_wrap, window_size, weights, min_samples, center)
+      )
+    end
+
+    # Compute absolute values.
+    #
+    # @return [Expr]
     #
     # @example
     #   df = Polars::DataFrame.new(
@@ -5730,40 +6719,7 @@ module Polars
     #   # │ 2.0 │
     #   # └─────┘
     def abs
-      _from_rbexpr(_rbexpr.abs)
-    end
-
-    # Get the index values that would sort this column.
-    #
-    # Alias for {#arg_sort}.
-    #
-    # @param reverse [Boolean]
-    #   Sort in reverse (descending) order.
-    # @param nulls_last [Boolean]
-    #   Place null values last instead of first.
-    #
-    # @return [expr]
-    #
-    # @example
-    #   df = Polars::DataFrame.new(
-    #     {
-    #       "a" => [20, 10, 30]
-    #     }
-    #   )
-    #   df.select(Polars.col("a").argsort)
-    #   # =>
-    #   # shape: (3, 1)
-    #   # ┌─────┐
-    #   # │ a   │
-    #   # │ --- │
-    #   # │ u32 │
-    #   # ╞═════╡
-    #   # │ 1   │
-    #   # │ 0   │
-    #   # │ 2   │
-    #   # └─────┘
-    def argsort(reverse: false, nulls_last: false)
-      arg_sort(reverse: reverse, nulls_last: nulls_last)
+      wrap_expr(_rbexpr.abs)
     end
 
     # Assign ranks to data, dealing with ties appropriately.
@@ -5786,7 +6742,7 @@ module Polars
     #     the order that the values occur in the Series.
     #   - 'random' : Like 'ordinal', but the rank for ties is not dependent
     #     on the order that the values occur in the Series.
-    # @param reverse [Boolean]
+    # @param descending [Boolean]
     #   Reverse the operation.
     # @param seed [Integer]
     #   If `method: "random"`, use this as seed.
@@ -5826,8 +6782,8 @@ module Polars
     #   # │ 2   │
     #   # │ 5   │
     #   # └─────┘
-    def rank(method: "average", reverse: false, seed: nil)
-      _from_rbexpr(_rbexpr.rank(method, reverse, seed))
+    def rank(method: "average", descending: false, seed: nil)
+      wrap_expr(_rbexpr.rank(method, descending, seed))
     end
 
     # Calculate the n-th discrete difference.
@@ -5858,7 +6814,8 @@ module Polars
     #   # │ 20   │
     #   # └──────┘
     def diff(n: 1, null_behavior: "ignore")
-      _from_rbexpr(_rbexpr.diff(n, null_behavior))
+      n = Utils.parse_into_expression(n)
+      wrap_expr(_rbexpr.diff(n, null_behavior))
     end
 
     # Computes percentage change between values.
@@ -5879,7 +6836,7 @@ module Polars
     #       "a" => [10, 11, 12, nil, 12]
     #     }
     #   )
-    #   df.with_column(Polars.col("a").pct_change.alias("pct_change"))
+    #   df.with_columns(Polars.col("a").pct_change.alias("pct_change"))
     #   # =>
     #   # shape: (5, 2)
     #   # ┌──────┬────────────┐
@@ -5890,12 +6847,12 @@ module Polars
     #   # │ 10   ┆ null       │
     #   # │ 11   ┆ 0.1        │
     #   # │ 12   ┆ 0.090909   │
-    #   # │ null ┆ 0.0        │
-    #   # │ 12   ┆ 0.0        │
+    #   # │ null ┆ null       │
+    #   # │ 12   ┆ null       │
     #   # └──────┴────────────┘
     def pct_change(n: 1)
       n = Utils.parse_into_expression(n)
-      _from_rbexpr(_rbexpr.pct_change(n))
+      wrap_expr(_rbexpr.pct_change(n))
     end
 
     # Compute the sample skewness of a data set.
@@ -5924,7 +6881,7 @@ module Polars
     #   # │ 0.343622 │
     #   # └──────────┘
     def skew(bias: true)
-      _from_rbexpr(_rbexpr.skew(bias))
+      wrap_expr(_rbexpr.skew(bias))
     end
 
     # Compute the kurtosis (Fisher or Pearson) of a dataset.
@@ -5932,7 +6889,7 @@ module Polars
     # Kurtosis is the fourth central moment divided by the square of the
     # variance. If Fisher's definition is used, then 3.0 is subtracted from
     # the result to give 0.0 for a normal distribution.
-    # If bias is False then the kurtosis is calculated using k statistics to
+    # If bias is false then the kurtosis is calculated using k statistics to
     # eliminate bias coming from biased moment estimators
     #
     # @param fisher [Boolean]
@@ -5956,7 +6913,7 @@ module Polars
     #   # │ -1.153061 │
     #   # └───────────┘
     def kurtosis(fisher: true, bias: true)
-      _from_rbexpr(_rbexpr.kurtosis(fisher, bias))
+      wrap_expr(_rbexpr.kurtosis(fisher, bias))
     end
 
     # Set values outside the given boundaries to the boundary value.
@@ -5973,7 +6930,7 @@ module Polars
     #
     # @example
     #   df = Polars::DataFrame.new({"foo" => [-50, 5, nil, 50]})
-    #   df.with_column(Polars.col("foo").clip(1, 10).alias("foo_clipped"))
+    #   df.with_columns(Polars.col("foo").clip(1, 10).alias("foo_clipped"))
     #   # =>
     #   # shape: (4, 2)
     #   # ┌──────┬─────────────┐
@@ -5993,69 +6950,7 @@ module Polars
       if !upper_bound.nil?
         upper_bound = Utils.parse_into_expression(upper_bound)
       end
-      _from_rbexpr(_rbexpr.clip(lower_bound, upper_bound))
-    end
-
-    # Clip (limit) the values in an array to a `min` boundary.
-    #
-    # Only works for numerical types.
-    #
-    # If you want to clip other dtypes, consider writing a "when, then, otherwise"
-    # expression. See `when` for more information.
-    #
-    # @param lower_bound [Numeric]
-    #   Minimum value.
-    #
-    # @return [Expr]
-    #
-    # @example
-    #   df = Polars::DataFrame.new({"foo" => [-50, 5, nil, 50]})
-    #   df.with_column(Polars.col("foo").clip_min(0).alias("foo_clipped"))
-    #   # =>
-    #   # shape: (4, 2)
-    #   # ┌──────┬─────────────┐
-    #   # │ foo  ┆ foo_clipped │
-    #   # │ ---  ┆ ---         │
-    #   # │ i64  ┆ i64         │
-    #   # ╞══════╪═════════════╡
-    #   # │ -50  ┆ 0           │
-    #   # │ 5    ┆ 5           │
-    #   # │ null ┆ null        │
-    #   # │ 50   ┆ 50          │
-    #   # └──────┴─────────────┘
-    def clip_min(lower_bound)
-      clip(lower_bound, nil)
-    end
-
-    # Clip (limit) the values in an array to a `max` boundary.
-    #
-    # Only works for numerical types.
-    #
-    # If you want to clip other dtypes, consider writing a "when, then, otherwise"
-    # expression. See `when` for more information.
-    #
-    # @param upper_bound [Numeric]
-    #   Maximum value.
-    #
-    # @return [Expr]
-    #
-    # @example
-    #   df = Polars::DataFrame.new({"foo" => [-50, 5, nil, 50]})
-    #   df.with_column(Polars.col("foo").clip_max(0).alias("foo_clipped"))
-    #   # =>
-    #   # shape: (4, 2)
-    #   # ┌──────┬─────────────┐
-    #   # │ foo  ┆ foo_clipped │
-    #   # │ ---  ┆ ---         │
-    #   # │ i64  ┆ i64         │
-    #   # ╞══════╪═════════════╡
-    #   # │ -50  ┆ -50         │
-    #   # │ 5    ┆ 0           │
-    #   # │ null ┆ null        │
-    #   # │ 50   ┆ 0           │
-    #   # └──────┴─────────────┘
-    def clip_max(upper_bound)
-      clip(nil, upper_bound)
+      wrap_expr(_rbexpr.clip(lower_bound, upper_bound))
     end
 
     # Calculate the lower bound.
@@ -6078,7 +6973,7 @@ module Polars
     #   # │ -9223372036854775808 │
     #   # └──────────────────────┘
     def lower_bound
-      _from_rbexpr(_rbexpr.lower_bound)
+      wrap_expr(_rbexpr.lower_bound)
     end
 
     # Calculate the upper bound.
@@ -6101,7 +6996,7 @@ module Polars
     #   # │ 9223372036854775807 │
     #   # └─────────────────────┘
     def upper_bound
-      _from_rbexpr(_rbexpr.upper_bound)
+      wrap_expr(_rbexpr.upper_bound)
     end
 
     # Compute the element-wise indication of the sign.
@@ -6125,7 +7020,7 @@ module Polars
     #   # │ null │
     #   # └──────┘
     def sign
-      _from_rbexpr(_rbexpr.sign)
+      wrap_expr(_rbexpr.sign)
     end
 
     # Compute the element-wise value for the sine.
@@ -6145,7 +7040,7 @@ module Polars
     #   # │ 0.0 │
     #   # └─────┘
     def sin
-      _from_rbexpr(_rbexpr.sin)
+      wrap_expr(_rbexpr.sin)
     end
 
     # Compute the element-wise value for the cosine.
@@ -6165,7 +7060,7 @@ module Polars
     #   # │ 1.0 │
     #   # └─────┘
     def cos
-      _from_rbexpr(_rbexpr.cos)
+      wrap_expr(_rbexpr.cos)
     end
 
     # Compute the element-wise value for the tangent.
@@ -6185,7 +7080,27 @@ module Polars
     #   # │ 1.557408 │
     #   # └──────────┘
     def tan
-      _from_rbexpr(_rbexpr.tan)
+      wrap_expr(_rbexpr.tan)
+    end
+
+    # Compute the element-wise value for the cotangent.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"a" => [1.0]})
+    #   df.select(Polars.col("a").cot.round(2))
+    #   # =>
+    #   # shape: (1, 1)
+    #   # ┌──────┐
+    #   # │ a    │
+    #   # │ ---  │
+    #   # │ f64  │
+    #   # ╞══════╡
+    #   # │ 0.64 │
+    #   # └──────┘
+    def cot
+      wrap_expr(_rbexpr.cot)
     end
 
     # Compute the element-wise value for the inverse sine.
@@ -6205,7 +7120,7 @@ module Polars
     #   # │ 1.570796 │
     #   # └──────────┘
     def arcsin
-      _from_rbexpr(_rbexpr.arcsin)
+      wrap_expr(_rbexpr.arcsin)
     end
 
     # Compute the element-wise value for the inverse cosine.
@@ -6225,7 +7140,7 @@ module Polars
     #   # │ 1.570796 │
     #   # └──────────┘
     def arccos
-      _from_rbexpr(_rbexpr.arccos)
+      wrap_expr(_rbexpr.arccos)
     end
 
     # Compute the element-wise value for the inverse tangent.
@@ -6245,7 +7160,7 @@ module Polars
     #   # │ 0.785398 │
     #   # └──────────┘
     def arctan
-      _from_rbexpr(_rbexpr.arctan)
+      wrap_expr(_rbexpr.arctan)
     end
 
     # Compute the element-wise value for the hyperbolic sine.
@@ -6265,7 +7180,7 @@ module Polars
     #   # │ 1.175201 │
     #   # └──────────┘
     def sinh
-      _from_rbexpr(_rbexpr.sinh)
+      wrap_expr(_rbexpr.sinh)
     end
 
     # Compute the element-wise value for the hyperbolic cosine.
@@ -6285,7 +7200,7 @@ module Polars
     #   # │ 1.543081 │
     #   # └──────────┘
     def cosh
-      _from_rbexpr(_rbexpr.cosh)
+      wrap_expr(_rbexpr.cosh)
     end
 
     # Compute the element-wise value for the hyperbolic tangent.
@@ -6305,7 +7220,7 @@ module Polars
     #   # │ 0.761594 │
     #   # └──────────┘
     def tanh
-      _from_rbexpr(_rbexpr.tanh)
+      wrap_expr(_rbexpr.tanh)
     end
 
     # Compute the element-wise value for the inverse hyperbolic sine.
@@ -6325,7 +7240,7 @@ module Polars
     #   # │ 0.881374 │
     #   # └──────────┘
     def arcsinh
-      _from_rbexpr(_rbexpr.arcsinh)
+      wrap_expr(_rbexpr.arcsinh)
     end
 
     # Compute the element-wise value for the inverse hyperbolic cosine.
@@ -6345,7 +7260,7 @@ module Polars
     #   # │ 0.0 │
     #   # └─────┘
     def arccosh
-      _from_rbexpr(_rbexpr.arccosh)
+      wrap_expr(_rbexpr.arccosh)
     end
 
     # Compute the element-wise value for the inverse hyperbolic tangent.
@@ -6365,12 +7280,68 @@ module Polars
     #   # │ inf │
     #   # └─────┘
     def arctanh
-      _from_rbexpr(_rbexpr.arctanh)
+      wrap_expr(_rbexpr.arctanh)
+    end
+
+    # Convert from radians to degrees.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"a" => (-4...5).map { |x| x * Math::PI }})
+    #   df.select(Polars.col("a").degrees)
+    #   # =>
+    #   # shape: (9, 1)
+    #   # ┌────────┐
+    #   # │ a      │
+    #   # │ ---    │
+    #   # │ f64    │
+    #   # ╞════════╡
+    #   # │ -720.0 │
+    #   # │ -540.0 │
+    #   # │ -360.0 │
+    #   # │ -180.0 │
+    #   # │ 0.0    │
+    #   # │ 180.0  │
+    #   # │ 360.0  │
+    #   # │ 540.0  │
+    #   # │ 720.0  │
+    #   # └────────┘
+    def degrees
+      wrap_expr(_rbexpr.degrees)
+    end
+
+    # Convert from degrees to radians.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"a" => [-720, -540, -360, -180, 0, 180, 360, 540, 720]})
+    #   df.select(Polars.col("a").radians)
+    #   # =>
+    #   # shape: (9, 1)
+    #   # ┌────────────┐
+    #   # │ a          │
+    #   # │ ---        │
+    #   # │ f64        │
+    #   # ╞════════════╡
+    #   # │ -12.566371 │
+    #   # │ -9.424778  │
+    #   # │ -6.283185  │
+    #   # │ -3.141593  │
+    #   # │ 0.0        │
+    #   # │ 3.141593   │
+    #   # │ 6.283185   │
+    #   # │ 9.424778   │
+    #   # │ 12.566371  │
+    #   # └────────────┘
+    def radians
+      wrap_expr(_rbexpr.radians)
     end
 
     # Reshape this Expr to a flat Series or a Series of Lists.
     #
-    # @param dims [Array]
+    # @param dimensions [Array]
     #   Tuple of the dimension sizes. If a -1 is used in any of the dimensions, that
     #   dimension is inferred.
     #
@@ -6410,14 +7381,14 @@ module Polars
     #   # │ 8   │
     #   # │ 9   │
     #   # └─────┘
-    def reshape(dims)
-      _from_rbexpr(_rbexpr.reshape(dims))
+    def reshape(dimensions)
+      wrap_expr(_rbexpr.reshape(dimensions))
     end
 
     # Shuffle the contents of this expr.
     #
     # @param seed [Integer]
-    #   Seed for the random number generator. If set to None (default), a random
+    #   Seed for the random number generator. If set to nil (default), a random
     #   seed is generated using the `random` module.
     #
     # @return [Expr]
@@ -6433,35 +7404,35 @@ module Polars
     #   # │ i64 │
     #   # ╞═════╡
     #   # │ 2   │
-    #   # │ 1   │
     #   # │ 3   │
+    #   # │ 1   │
     #   # └─────┘
     def shuffle(seed: nil)
       if seed.nil?
         seed = rand(10000)
       end
-      _from_rbexpr(_rbexpr.shuffle(seed))
+      wrap_expr(_rbexpr.shuffle(seed))
     end
 
     # Sample from this expression.
     #
-    # @param frac [Float]
+    # @param fraction [Float]
     #   Fraction of items to return. Cannot be used with `n`.
     # @param with_replacement [Boolean]
     #   Allow values to be sampled more than once.
     # @param shuffle [Boolean]
     #   Shuffle the order of sampled data points.
     # @param seed [Integer]
-    #   Seed for the random number generator. If set to None (default), a random
+    #   Seed for the random number generator. If set to nil (default), a random
     #   seed is used.
     # @param n [Integer]
-    #   Number of items to return. Cannot be used with `frac`.
+    #   Number of items to return. Cannot be used with `fraction`.
     #
     # @return [Expr]
     #
     # @example
     #   df = Polars::DataFrame.new({"a" => [1, 2, 3]})
-    #   df.select(Polars.col("a").sample(frac: 1.0, with_replacement: true, seed: 1))
+    #   df.select(Polars.col("a").sample(fraction: 1.0, with_replacement: true, seed: 1))
     #   # =>
     #   # shape: (3, 1)
     #   # ┌─────┐
@@ -6470,31 +7441,31 @@ module Polars
     #   # │ i64 │
     #   # ╞═════╡
     #   # │ 3   │
-    #   # │ 1   │
+    #   # │ 3   │
     #   # │ 1   │
     #   # └─────┘
     def sample(
-      frac: nil,
-      with_replacement: true,
+      fraction: nil,
+      with_replacement: false,
       shuffle: false,
       seed: nil,
       n: nil
     )
-      if !n.nil? && !frac.nil?
-        raise ArgumentError, "cannot specify both `n` and `frac`"
+      if !n.nil? && !fraction.nil?
+        raise ArgumentError, "cannot specify both `n` and `fraction`"
       end
 
-      if !n.nil? && frac.nil?
+      if !n.nil? && fraction.nil?
         n = Utils.parse_into_expression(n)
-        return _from_rbexpr(_rbexpr.sample_n(n, with_replacement, shuffle, seed))
+        return wrap_expr(_rbexpr.sample_n(n, with_replacement, shuffle, seed))
       end
 
-      if frac.nil?
-        frac = 1.0
+      if fraction.nil?
+        fraction = 1.0
       end
-      frac = Utils.parse_into_expression(frac)
-      _from_rbexpr(
-        _rbexpr.sample_frac(frac, with_replacement, shuffle, seed)
+      fraction = Utils.parse_into_expression(fraction)
+      wrap_expr(
+        _rbexpr.sample_frac(fraction, with_replacement, shuffle, seed)
       )
     end
 
@@ -6522,11 +7493,80 @@ module Polars
       half_life: nil,
       alpha: nil,
       adjust: true,
-      min_periods: 1,
-      ignore_nulls: true
+      min_samples: 1,
+      ignore_nulls: false
     )
       alpha = _prepare_alpha(com, span, half_life, alpha)
-      _from_rbexpr(_rbexpr.ewm_mean(alpha, adjust, min_periods, ignore_nulls))
+      wrap_expr(_rbexpr.ewm_mean(alpha, adjust, min_samples, ignore_nulls))
+    end
+
+    # Compute time-based exponentially weighted moving average.
+    #
+    # @param by [Object]
+    #   Times to calculate average by. Should be `DateTime`, `Date`, `UInt64`,
+    #   `UInt32`, `Int64`, or `Int32` data type.
+    # @param half_life [Object]
+    #   Unit over which observation decays to half its value.
+    #
+    #   Can be created either from a timedelta, or
+    #   by using the following string language:
+    #
+    #   - 1ns   (1 nanosecond)
+    #   - 1us   (1 microsecond)
+    #   - 1ms   (1 millisecond)
+    #   - 1s    (1 second)
+    #   - 1m    (1 minute)
+    #   - 1h    (1 hour)
+    #   - 1d    (1 day)
+    #   - 1w    (1 week)
+    #   - 1i    (1 index count)
+    #
+    #   Or combine them:
+    #   "3d12h4m25s" # 3 days, 12 hours, 4 minutes, and 25 seconds
+    #
+    #   Note that `half_life` is treated as a constant duration - calendar
+    #   durations such as months (or even days in the time-zone-aware case)
+    #   are not supported, please express your duration in an approximately
+    #   equivalent number of hours (e.g. '370h' instead of '1mo').
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "values": [0, 1, 2, nil, 4],
+    #       "times": [
+    #           Date.new(2020, 1, 1),
+    #           Date.new(2020, 1, 3),
+    #           Date.new(2020, 1, 10),
+    #           Date.new(2020, 1, 15),
+    #           Date.new(2020, 1, 17)
+    #       ]
+    #     }
+    #   ).sort("times")
+    #   df.with_columns(
+    #     result: Polars.col("values").ewm_mean_by("times", half_life: "4d")
+    #   )
+    #   # =>
+    #   # shape: (5, 3)
+    #   # ┌────────┬────────────┬──────────┐
+    #   # │ values ┆ times      ┆ result   │
+    #   # │ ---    ┆ ---        ┆ ---      │
+    #   # │ i64    ┆ date       ┆ f64      │
+    #   # ╞════════╪════════════╪══════════╡
+    #   # │ 0      ┆ 2020-01-01 ┆ 0.0      │
+    #   # │ 1      ┆ 2020-01-03 ┆ 0.292893 │
+    #   # │ 2      ┆ 2020-01-10 ┆ 1.492474 │
+    #   # │ null   ┆ 2020-01-15 ┆ null     │
+    #   # │ 4      ┆ 2020-01-17 ┆ 3.254508 │
+    #   # └────────┴────────────┴──────────┘
+    def ewm_mean_by(
+      by,
+      half_life:
+    )
+      by = Utils.parse_into_expression(by)
+      half_life = Utils.parse_as_duration_string(half_life)
+      wrap_expr(_rbexpr.ewm_mean_by(by, half_life))
     end
 
     # Exponentially-weighted moving standard deviation.
@@ -6554,11 +7594,11 @@ module Polars
       alpha: nil,
       adjust: true,
       bias: false,
-      min_periods: 1,
-      ignore_nulls: true
+      min_samples: 1,
+      ignore_nulls: false
     )
       alpha = _prepare_alpha(com, span, half_life, alpha)
-      _from_rbexpr(_rbexpr.ewm_std(alpha, adjust, bias, min_periods, ignore_nulls))
+      wrap_expr(_rbexpr.ewm_std(alpha, adjust, bias, min_samples, ignore_nulls))
     end
 
     # Exponentially-weighted moving variance.
@@ -6586,11 +7626,11 @@ module Polars
       alpha: nil,
       adjust: true,
       bias: false,
-      min_periods: 1,
-      ignore_nulls: true
+      min_samples: 1,
+      ignore_nulls: false
     )
       alpha = _prepare_alpha(com, span, half_life, alpha)
-      _from_rbexpr(_rbexpr.ewm_var(alpha, adjust, bias, min_periods, ignore_nulls))
+      wrap_expr(_rbexpr.ewm_var(alpha, adjust, bias, min_samples, ignore_nulls))
     end
 
     # Extend the Series with given number of values.
@@ -6620,7 +7660,9 @@ module Polars
     #   # │ 99     │
     #   # └────────┘
     def extend_constant(value, n)
-      _from_rbexpr(_rbexpr.extend_constant(value, n))
+      value = Utils.parse_into_expression(value, str_as_lit: true)
+      n = Utils.parse_into_expression(n)
+      wrap_expr(_rbexpr.extend_constant(value, n))
     end
 
     # Count all unique values and create a struct mapping value to count.
@@ -6674,7 +7716,7 @@ module Polars
           name = "count"
         end
       end
-      _from_rbexpr(
+      wrap_expr(
         _rbexpr.value_counts(sort, parallel, name, normalize)
       )
     end
@@ -6709,7 +7751,7 @@ module Polars
     #   # │ 3   │
     #   # └─────┘
     def unique_counts
-      _from_rbexpr(_rbexpr.unique_counts)
+      wrap_expr(_rbexpr.unique_counts)
     end
 
     # Compute the logarithm to a given base.
@@ -6734,7 +7776,32 @@ module Polars
     #   # │ 1.584963 │
     #   # └──────────┘
     def log(base = Math::E)
-      _from_rbexpr(_rbexpr.log(base))
+      base_rbexpr = Utils.parse_into_expression(base)
+      wrap_expr(_rbexpr.log(base_rbexpr))
+    end
+
+    # Compute the natural logarithm of each element plus one.
+    #
+    # This computes `log(1 + x)` but is more numerically stable for `x` close to zero.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"a" => [1, 2, 3]})
+    #   df.select(Polars.col("a").log1p)
+    #   # =>
+    #   # shape: (3, 1)
+    #   # ┌──────────┐
+    #   # │ a        │
+    #   # │ ---      │
+    #   # │ f64      │
+    #   # ╞══════════╡
+    #   # │ 0.693147 │
+    #   # │ 1.098612 │
+    #   # │ 1.386294 │
+    #   # └──────────┘
+    def log1p
+      wrap_expr(_rbexpr.log1p)
     end
 
     # Computes the entropy.
@@ -6742,7 +7809,7 @@ module Polars
     # Uses the formula `-sum(pk * log(pk)` where `pk` are discrete probabilities.
     #
     # @param base [Float]
-    #   Given base, defaults to `e`.
+    #   Given base, defaults to `2`.
     # @param normalize [Boolean]
     #   Normalize pk if it doesn't sum to 1.
     #
@@ -6772,20 +7839,17 @@ module Polars
     #   # ╞═══════════╡
     #   # │ -6.754888 │
     #   # └───────────┘
-    def entropy(base: 2, normalize: true)
-      _from_rbexpr(_rbexpr.entropy(base, normalize))
+    def entropy(base: Math::E, normalize: true)
+      wrap_expr(_rbexpr.entropy(base, normalize))
     end
 
     # Run an expression over a sliding window that increases `1` slot every iteration.
     #
     # @param expr [Expr]
     #   Expression to evaluate
-    # @param min_periods [Integer]
+    # @param min_samples [Integer]
     #   Number of valid values there should be in the window before the expression
     #   is evaluated. valid values = `length - null_count`
-    # @param parallel [Boolean]
-    #   Run in parallel. Don't do this in a group by or another operation that
-    #   already has much parallelization.
     #
     # @return [Expr]
     #
@@ -6819,9 +7883,9 @@ module Polars
     #   # │ -15    │
     #   # │ -24    │
     #   # └────────┘
-    def cumulative_eval(expr, min_periods: 1, parallel: false)
-      _from_rbexpr(
-        _rbexpr.cumulative_eval(expr._rbexpr, min_periods, parallel)
+    def cumulative_eval(expr, min_samples: 1)
+      wrap_expr(
+        _rbexpr.cumulative_eval(expr._rbexpr, min_samples)
       )
     end
 
@@ -6831,6 +7895,8 @@ module Polars
     #
     # @param descending [Boolean]
     #   Whether the `Series` order is descending.
+    # @param nulls_last [Boolean]
+    #   Whether the nulls are at the end.
     #
     # @return [Expr]
     #
@@ -6850,12 +7916,16 @@ module Polars
     #   # ╞════════╡
     #   # │ 3      │
     #   # └────────┘
-    def set_sorted(descending: false)
-      _from_rbexpr(_rbexpr.set_sorted_flag(descending))
+    def set_sorted(descending: false, nulls_last: false)
+      wrap_expr(_rbexpr.set_sorted_flag(descending, nulls_last))
     end
 
     # Aggregate to list.
     #
+    # @param maintain_order [Boolean]
+    #   Whether to preserve the order of elements in the list. Setting this
+    #   to `false` can improve performance, especially within `group_by`.
+    #
     # @return [Expr]
     #
     # @example
@@ -6875,55 +7945,85 @@ module Polars
     #   # ╞═══════════╪═══════════╡
     #   # │ [1, 2, 3] ┆ [4, 5, 6] │
     #   # └───────────┴───────────┘
-    def implode
-      _from_rbexpr(_rbexpr.implode)
+    def implode(maintain_order: true)
+      wrap_expr(_rbexpr.implode(maintain_order))
     end
 
-    # Shrink numeric columns to the minimal required datatype.
+    # Bin values into buckets and count their occurrences.
+    #
+    # @note
+    #   This functionality is considered **unstable**. It may be changed
+    #   at any point without it being considered a breaking change.
     #
-    # Shrink to the dtype needed to fit the extrema of this `Series`.
-    # This can be used to reduce memory pressure.
+    # @param bins [Object]
+    #   Bin edges. If nil given, we determine the edges based on the data.
+    # @param bin_count [Integer]
+    #   If `bins` is not provided, `bin_count` uniform bins are created that fully
+    #   encompass the data.
+    # @param include_category [Boolean]
+    #   Include a column that shows the intervals as categories.
+    # @param include_breakpoint [Boolean]
+    #   Include a column that indicates the upper breakpoint.
     #
     # @return [Expr]
     #
     # @example
-    #   Polars::DataFrame.new(
-    #     {
-    #       "a" => [1, 2, 3],
-    #       "b" => [1, 2, 2 << 32],
-    #       "c" => [-1, 2, 1 << 30],
-    #       "d" => [-112, 2, 112],
-    #       "e" => [-112, 2, 129],
-    #       "f" => ["a", "b", "c"],
-    #       "g" => [0.1, 1.32, 0.12],
-    #       "h" => [true, nil, false]
-    #     }
-    #   ).select(Polars.all.shrink_dtype)
-    #   # =>
-    #   # shape: (3, 8)
-    #   # ┌─────┬────────────┬────────────┬──────┬──────┬─────┬──────┬───────┐
-    #   # │ a   ┆ b          ┆ c          ┆ d    ┆ e    ┆ f   ┆ g    ┆ h     │
-    #   # │ --- ┆ ---        ┆ ---        ┆ ---  ┆ ---  ┆ --- ┆ ---  ┆ ---   │
-    #   # │ i8  ┆ i64        ┆ i32        ┆ i8   ┆ i16  ┆ str ┆ f32  ┆ bool  │
-    #   # ╞═════╪════════════╪════════════╪══════╪══════╪═════╪══════╪═══════╡
-    #   # │ 1   ┆ 1          ┆ -1         ┆ -112 ┆ -112 ┆ a   ┆ 0.1  ┆ true  │
-    #   # │ 2   ┆ 2          ┆ 2          ┆ 2    ┆ 2    ┆ b   ┆ 1.32 ┆ null  │
-    #   # │ 3   ┆ 8589934592 ┆ 1073741824 ┆ 112  ┆ 129  ┆ c   ┆ 0.12 ┆ false │
-    #   # └─────┴────────────┴────────────┴──────┴──────┴─────┴──────┴───────┘
-    def shrink_dtype
-      _from_rbexpr(_rbexpr.shrink_dtype)
+    #   df = Polars::DataFrame.new({"a" => [1, 3, 8, 8, 2, 1, 3]})
+    #   df.select(Polars.col("a").hist(bins: [1, 2, 3]))
+    #   # =>
+    #   # shape: (2, 1)
+    #   # ┌─────┐
+    #   # │ a   │
+    #   # │ --- │
+    #   # │ u32 │
+    #   # ╞═════╡
+    #   # │ 3   │
+    #   # │ 2   │
+    #   # └─────┘
+    #
+    # @example
+    #   df.select(
+    #     Polars.col("a").hist(
+    #       bins: [1, 2, 3], include_breakpoint: true, include_category: true
+    #     )
+    #   )
+    #   # =>
+    #   # shape: (2, 1)
+    #   # ┌──────────────────────┐
+    #   # │ a                    │
+    #   # │ ---                  │
+    #   # │ struct[3]            │
+    #   # ╞══════════════════════╡
+    #   # │ {2.0,"[1.0, 2.0]",3} │
+    #   # │ {3.0,"(2.0, 3.0]",2} │
+    #   # └──────────────────────┘
+    def hist(
+      bins: nil,
+      bin_count: nil,
+      include_category: false,
+      include_breakpoint: false
+    )
+      if !bins.nil?
+        if bins.is_a?(::Array)
+          bins = Polars::Series.new(bins)
+        end
+        bins = Utils.parse_into_expression(bins)
+      end
+      wrap_expr(
+        _rbexpr.hist(bins, bin_count, include_category, include_breakpoint)
+      )
     end
 
     # Replace values by different values.
     #
     # @param old [Object]
-    #   Value or sequence of values to replace.
-    #   Accepts expression input. Sequences are parsed as Series,
+    #   Value or array of values to replace.
+    #   Accepts expression input. Arrays are parsed as Series,
     #   other non-expression inputs are parsed as literals.
     #   Also accepts a mapping of values to their replacement.
     # @param new [Object]
-    #   Value or sequence of values to replace by.
-    #   Accepts expression input. Sequences are parsed as Series,
+    #   Value or array of values to replace by.
+    #   Accepts expression input. Arrays 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]
@@ -6952,7 +8052,7 @@ module Polars
     #   # │ 3   ┆ 3        │
     #   # └─────┴──────────┘
     #
-    # @example Replace multiple values by passing sequences to the `old` and `new` parameters.
+    # @example Replace multiple values by passing arrays to the `old` and `new` parameters.
     #   df.with_columns(replaced: Polars.col("a").replace([2, 3], [100, 200]))
     #   # =>
     #   # shape: (4, 2)
@@ -7070,7 +8170,7 @@ module Polars
       old = Utils.parse_into_expression(old, str_as_lit: true)
       new = Utils.parse_into_expression(new, str_as_lit: true)
 
-      result = _from_rbexpr(_rbexpr.replace(old, new))
+      result = wrap_expr(_rbexpr.replace(old, new))
 
       if !return_dtype.nil?
         result = result.cast(return_dtype)
@@ -7082,14 +8182,14 @@ module Polars
     # Replace all values by different values.
     #
     # @param old [Object]
-    #   Value or sequence of values to replace.
-    #   Accepts expression input. Sequences are parsed as Series,
+    #   Value or array of values to replace.
+    #   Accepts expression input. Arrays 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))`.
+    #   `replace_all(old: Series.new(mapping.keys), new: Series.new(mapping.values))`.
     # @param new [Object]
-    #   Value or sequence of values to replace by.
-    #   Accepts expression input. Sequences are parsed as Series,
+    #   Value or array of values to replace by.
+    #   Accepts expression input. Arrays 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]
@@ -7105,7 +8205,7 @@ module Polars
     # @note
     #   The global string cache must be enabled when replacing categorical values.
     #
-    # @example Replace values by passing sequences to the `old` and `new` parameters.
+    # @example Replace values by passing arrays 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])
@@ -7222,11 +8322,161 @@ module Polars
 
       default = default.eql?(NO_DEFAULT) ? nil : Utils.parse_into_expression(default, str_as_lit: true)
 
-      _from_rbexpr(
+      wrap_expr(
         _rbexpr.replace_strict(old, new, default, return_dtype)
       )
     end
 
+    # Evaluate the number of set bits.
+    #
+    # @return [Expr]
+    def bitwise_count_ones
+      wrap_expr(_rbexpr.bitwise_count_ones)
+    end
+
+    # Evaluate the number of unset bits.
+    #
+    # @return [Expr]
+    def bitwise_count_zeros
+      wrap_expr(_rbexpr.bitwise_count_zeros)
+    end
+
+    # Evaluate the number most-significant set bits before seeing an unset bit.
+    #
+    # @return [Expr]
+    def bitwise_leading_ones
+      wrap_expr(_rbexpr.bitwise_leading_ones)
+    end
+
+    # Evaluate the number most-significant unset bits before seeing a set bit.
+    #
+    # @return [Expr]
+    def bitwise_leading_zeros
+      wrap_expr(_rbexpr.bitwise_leading_zeros)
+    end
+
+    # Evaluate the number least-significant set bits before seeing an unset bit.
+    #
+    # @return [Expr]
+    def bitwise_trailing_ones
+      wrap_expr(_rbexpr.bitwise_trailing_ones)
+    end
+
+    # Evaluate the number least-significant unset bits before seeing a set bit.
+    #
+    # @return [Expr]
+    def bitwise_trailing_zeros
+      wrap_expr(_rbexpr.bitwise_trailing_zeros)
+    end
+
+    # Perform an aggregation of bitwise ANDs.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"n" => [-1, 0, 1]})
+    #   df.select(Polars.col("n").bitwise_and)
+    #   # =>
+    #   # shape: (1, 1)
+    #   # ┌─────┐
+    #   # │ n   │
+    #   # │ --- │
+    #   # │ i64 │
+    #   # ╞═════╡
+    #   # │ 0   │
+    #   # └─────┘
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {"grouper" => ["a", "a", "a", "b", "b"], "n" => [-1, 0, 1, -1, 1]}
+    #   )
+    #   df.group_by("grouper", maintain_order: true).agg(Polars.col("n").bitwise_and)
+    #   # =>
+    #   # shape: (2, 2)
+    #   # ┌─────────┬─────┐
+    #   # │ grouper ┆ n   │
+    #   # │ ---     ┆ --- │
+    #   # │ str     ┆ i64 │
+    #   # ╞═════════╪═════╡
+    #   # │ a       ┆ 0   │
+    #   # │ b       ┆ 1   │
+    #   # └─────────┴─────┘
+    def bitwise_and
+      wrap_expr(_rbexpr.bitwise_and)
+    end
+
+    # Perform an aggregation of bitwise ORs.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"n" => [-1, 0, 1]})
+    #   df.select(Polars.col("n").bitwise_or)
+    #   # =>
+    #   # shape: (1, 1)
+    #   # ┌─────┐
+    #   # │ n   │
+    #   # │ --- │
+    #   # │ i64 │
+    #   # ╞═════╡
+    #   # │ -1  │
+    #   # └─────┘
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {"grouper" => ["a", "a", "a", "b", "b"], "n" => [-1, 0, 1, -1, 1]}
+    #   )
+    #   df.group_by("grouper", maintain_order: true).agg(Polars.col("n").bitwise_or)
+    #   # =>
+    #   # shape: (2, 2)
+    #   # ┌─────────┬─────┐
+    #   # │ grouper ┆ n   │
+    #   # │ ---     ┆ --- │
+    #   # │ str     ┆ i64 │
+    #   # ╞═════════╪═════╡
+    #   # │ a       ┆ -1  │
+    #   # │ b       ┆ -1  │
+    #   # └─────────┴─────┘
+    def bitwise_or
+      wrap_expr(_rbexpr.bitwise_or)
+    end
+
+    # Perform an aggregation of bitwise XORs.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"n" => [-1, 0, 1]})
+    #   df.select(Polars.col("n").bitwise_xor)
+    #   # =>
+    #   # shape: (1, 1)
+    #   # ┌─────┐
+    #   # │ n   │
+    #   # │ --- │
+    #   # │ i64 │
+    #   # ╞═════╡
+    #   # │ -2  │
+    #   # └─────┘
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {"grouper" => ["a", "a", "a", "b", "b"], "n" => [-1, 0, 1, -1, 1]}
+    #   )
+    #   df.group_by("grouper", maintain_order: true).agg(Polars.col("n").bitwise_xor)
+    #   # =>
+    #   # shape: (2, 2)
+    #   # ┌─────────┬─────┐
+    #   # │ grouper ┆ n   │
+    #   # │ ---     ┆ --- │
+    #   # │ str     ┆ i64 │
+    #   # ╞═════════╪═════╡
+    #   # │ a       ┆ -2  │
+    #   # │ b       ┆ -2  │
+    #   # └─────────┴─────┘
+    def bitwise_xor
+      wrap_expr(_rbexpr.bitwise_xor)
+    end
+
     # Create an object namespace of all list related methods.
     #
     # @return [ListExpr]
@@ -7290,9 +8540,16 @@ module Polars
       StructExpr.new(self)
     end
 
+    # Create an object namespace of all extension type related expressions.
+    #
+    # @return [ExtensionExpr]
+    def ext
+      ExtensionExpr.new(self)
+    end
+
     private
 
-    def _from_rbexpr(expr)
+    def wrap_expr(expr)
       Utils.wrap_expr(expr)
     end
 
@@ -7337,19 +8594,6 @@ module Polars
       alpha
     end
 
-    def _prepare_rolling_window_args(window_size, min_periods)
-      if window_size.is_a?(Integer)
-        if min_periods.nil?
-          min_periods = window_size
-        end
-        window_size = "#{window_size}i"
-      end
-      if min_periods.nil?
-        min_periods = 1
-      end
-      [window_size, min_periods]
-    end
-
     def _prepare_rolling_by_window_args(window_size)
       window_size
     end