polars-df 0.21.0-aarch64-linux-musl → 0.22.0-aarch64-linux-musl

data/lib/polars/expr.rb

@@ -26,56 +26,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 +86,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,12 +137,47 @@ module Polars
     def !
       is_not
     end
+    alias_method :~, :!
 
     # Performs negation.
     #
     # @return [Expr]
     def -@
-      _from_rbexpr(_rbexpr.neg)
+      wrap_expr(_rbexpr.neg)
+    end
+
+    # 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.
+    #
+    # @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.
@@ -176,7 +214,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`.
@@ -196,7 +234,7 @@ module Polars
     #   # │ true ┆ false │
     #   # └──────┴───────┘
     def any(drop_nulls: true)
-      _from_rbexpr(_rbexpr.any(drop_nulls))
+      wrap_expr(_rbexpr.any(drop_nulls))
     end
 
     # Check if all boolean values in a Boolean column are `true`.
@@ -221,7 +259,33 @@ module Polars
     #   # │ true ┆ false ┆ false │
     #   # └──────┴───────┴───────┘
     def all(drop_nulls: true)
-      _from_rbexpr(_rbexpr.all(drop_nulls))
+      wrap_expr(_rbexpr.all(drop_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 +307,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 +373,7 @@ module Polars
     #   # │ 54.59815 │
     #   # └──────────┘
     def exp
-      _from_rbexpr(_rbexpr.exp)
+      wrap_expr(_rbexpr.exp)
     end
 
     # Rename the output of an expression.
@@ -322,11 +408,9 @@ 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
@@ -510,7 +594,7 @@ module Polars
     #   # │ true  │
     #   # └───────┘
     def is_not
-      _from_rbexpr(_rbexpr.not_)
+      wrap_expr(_rbexpr.not_)
     end
     alias_method :not_, :is_not
 
@@ -540,7 +624,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.
@@ -569,7 +653,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.
@@ -595,7 +679,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.
@@ -621,7 +705,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.
@@ -654,7 +738,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.
@@ -687,7 +771,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.
@@ -722,7 +806,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.
@@ -742,7 +826,7 @@ module Polars
     #   # │ 3   ┆ 2   │
     #   # └─────┴─────┘
     def count
-      _from_rbexpr(_rbexpr.count)
+      wrap_expr(_rbexpr.count)
     end
 
     # Count the number of values in this expression.
@@ -762,7 +846,7 @@ module Polars
     #   # │ 3   ┆ 3   │
     #   # └─────┴─────┘
     def len
-      _from_rbexpr(_rbexpr.len)
+      wrap_expr(_rbexpr.len)
     end
     alias_method :length, :len
 
@@ -801,7 +885,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.
@@ -835,7 +919,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.
@@ -860,7 +944,7 @@ module Polars
     #   # │ 2      │
     #   # └────────┘
     def rechunk
-      _from_rbexpr(_rbexpr.rechunk)
+      wrap_expr(_rbexpr.rechunk)
     end
 
     # Drop null values.
@@ -887,7 +971,7 @@ module Polars
     #   # │ NaN │
     #   # └─────┘
     def drop_nulls
-      _from_rbexpr(_rbexpr.drop_nulls)
+      wrap_expr(_rbexpr.drop_nulls)
     end
 
     # Drop floating point NaN values.
@@ -914,7 +998,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.
@@ -949,7 +1033,7 @@ 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
 
@@ -985,7 +1069,7 @@ 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
 
@@ -1017,7 +1101,7 @@ 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
 
@@ -1049,7 +1133,7 @@ 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
 
@@ -1083,7 +1167,7 @@ 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
 
@@ -1109,7 +1193,7 @@ module Polars
     #   # │ 1.0 │
     #   # └─────┘
     def floor
-      _from_rbexpr(_rbexpr.floor)
+      wrap_expr(_rbexpr.floor)
     end
 
     # Rounds up to the nearest integer value.
@@ -1134,7 +1218,7 @@ module Polars
     #   # │ 2.0 │
     #   # └─────┘
     def ceil
-      _from_rbexpr(_rbexpr.ceil)
+      wrap_expr(_rbexpr.ceil)
     end
 
     # Round underlying floating point data by `decimals` digits.
@@ -1167,7 +1251,32 @@ module Polars
     #   # │ 1.2 │
     #   # └─────┘
     def round(decimals = 0, mode: "half_to_even")
-      _from_rbexpr(_rbexpr.round(decimals, mode))
+      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
 
     # Compute the dot/inner product between two Expressions.
@@ -1196,7 +1305,7 @@ 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).
@@ -1224,7 +1333,7 @@ module Polars
     #   # │ 1   ┆ 2   │
     #   # └─────┴─────┘
     def mode
-      _from_rbexpr(_rbexpr.mode)
+      wrap_expr(_rbexpr.mode)
     end
 
     # Cast between data types.
@@ -1263,7 +1372,7 @@ module Polars
     #   # └─────┴─────┘
     def cast(dtype, strict: true)
       dtype = Utils.rb_type_to_dtype(dtype)
-      _from_rbexpr(_rbexpr.cast(dtype, strict))
+      wrap_expr(_rbexpr.cast(dtype, strict))
     end
 
     # Sort this column. In projection/ selection context the whole column is sorted.
@@ -1338,7 +1447,7 @@ module Polars
     #   # │ one   ┆ [1, 2, 98] │
     #   # └───────┴────────────┘
     def sort(reverse: false, nulls_last: false)
-      _from_rbexpr(_rbexpr.sort_with(reverse, nulls_last))
+      wrap_expr(_rbexpr.sort_with(reverse, nulls_last))
     end
 
     # Return the `k` largest elements.
@@ -1377,7 +1486,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 a sequence 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.
@@ -1416,7 +1631,113 @@ 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 a sequence 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.
@@ -1447,7 +1768,7 @@ module Polars
     #   # │ 2   │
     #   # └─────┘
     def arg_sort(reverse: false, nulls_last: false)
-      _from_rbexpr(_rbexpr.arg_sort(reverse, nulls_last))
+      wrap_expr(_rbexpr.arg_sort(reverse, nulls_last))
     end
 
     # Get the index of the maximal value.
@@ -1471,7 +1792,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.
@@ -1495,7 +1816,37 @@ 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.
@@ -1536,7 +1887,7 @@ module Polars
     #   # └──────┴───────┴─────┘
     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, descending))
+      wrap_expr(_rbexpr.search_sorted(element, side, descending))
     end
 
     # Sort this column by the ordering of another column, or multiple other columns.
@@ -1594,7 +1945,7 @@ module Polars
       by = Utils.parse_into_list_of_expressions(by, *more_by)
       reverse = Utils.extend_bool(reverse, by.length, "reverse", "by")
       nulls_last = Utils.extend_bool(nulls_last, by.length, "nulls_last", "by")
-      _from_rbexpr(
+      wrap_expr(
         _rbexpr.sort_by(
           by, reverse, nulls_last, multithreaded, maintain_order
         )
@@ -1639,7 +1990,7 @@ module Polars
       else
         indices_lit = Utils.parse_into_expression(indices, str_as_lit: false)
       end
-      _from_rbexpr(_rbexpr.gather(indices_lit))
+      wrap_expr(_rbexpr.gather(indices_lit))
     end
     alias_method :take, :gather
 
@@ -1677,7 +2028,7 @@ module Polars
     #   # └───────┴───────┘
     def get(index)
       index_lit = Utils.parse_into_expression(index)
-      _from_rbexpr(_rbexpr.get(index_lit))
+      wrap_expr(_rbexpr.get(index_lit))
     end
 
     # Shift the values by a given period.
@@ -1709,7 +2060,7 @@ 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.
@@ -1812,9 +2163,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
 
@@ -1843,7 +2194,7 @@ module Polars
     #   # └──────┴──────┘
     def fill_nan(fill_value)
       fill_value = Utils.parse_into_expression(fill_value, str_as_lit: true)
-      _from_rbexpr(_rbexpr.fill_nan(fill_value))
+      wrap_expr(_rbexpr.fill_nan(fill_value))
     end
 
     # Fill missing values with the latest seen values.
@@ -1939,7 +2290,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.
@@ -1962,7 +2313,7 @@ module Polars
     #   # │ 1.0 │
     #   # └─────┘
     def std(ddof: 1)
-      _from_rbexpr(_rbexpr.std(ddof))
+      wrap_expr(_rbexpr.std(ddof))
     end
 
     # Get variance.
@@ -1985,7 +2336,7 @@ module Polars
     #   # │ 1.0 │
     #   # └─────┘
     def var(ddof: 1)
-      _from_rbexpr(_rbexpr.var(ddof))
+      wrap_expr(_rbexpr.var(ddof))
     end
 
     # Get maximum value.
@@ -2005,7 +2356,7 @@ module Polars
     #   # │ 1.0 │
     #   # └─────┘
     def max
-      _from_rbexpr(_rbexpr.max)
+      wrap_expr(_rbexpr.max)
     end
 
     # Get minimum value.
@@ -2025,7 +2376,7 @@ module Polars
     #   # │ -1.0 │
     #   # └──────┘
     def min
-      _from_rbexpr(_rbexpr.min)
+      wrap_expr(_rbexpr.min)
     end
 
     # Get maximum value, but propagate/poison encountered NaN values.
@@ -2045,7 +2396,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.
@@ -2065,7 +2416,7 @@ module Polars
     #   # │ NaN │
     #   # └─────┘
     def nan_min
-      _from_rbexpr(_rbexpr.nan_min)
+      wrap_expr(_rbexpr.nan_min)
     end
 
     # Get sum value.
@@ -2089,7 +2440,7 @@ module Polars
     #   # │ 0   │
     #   # └─────┘
     def sum
-      _from_rbexpr(_rbexpr.sum)
+      wrap_expr(_rbexpr.sum)
     end
 
     # Get mean value.
@@ -2109,7 +2460,7 @@ module Polars
     #   # │ 0.0 │
     #   # └─────┘
     def mean
-      _from_rbexpr(_rbexpr.mean)
+      wrap_expr(_rbexpr.mean)
     end
 
     # Get median value using linear interpolation.
@@ -2129,7 +2480,7 @@ module Polars
     #   # │ 0.0 │
     #   # └─────┘
     def median
-      _from_rbexpr(_rbexpr.median)
+      wrap_expr(_rbexpr.median)
     end
 
     # Compute the product of an expression.
@@ -2149,7 +2500,7 @@ module Polars
     #   # │ 6   │
     #   # └─────┘
     def product
-      _from_rbexpr(_rbexpr.product)
+      wrap_expr(_rbexpr.product)
     end
 
     # Count unique values.
@@ -2169,7 +2520,7 @@ module Polars
     #   # │ 2   │
     #   # └─────┘
     def n_unique
-      _from_rbexpr(_rbexpr.n_unique)
+      wrap_expr(_rbexpr.n_unique)
     end
 
     # Approx count unique values.
@@ -2191,7 +2542,7 @@ 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
 
@@ -2217,7 +2568,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.
@@ -2257,7 +2634,7 @@ module Polars
     #   # │ 1   │
     #   # └─────┘
     def arg_unique
-      _from_rbexpr(_rbexpr.arg_unique)
+      wrap_expr(_rbexpr.arg_unique)
     end
 
     # Get unique values of this expression.
@@ -2282,9 +2659,9 @@ 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
 
@@ -2305,7 +2682,7 @@ module Polars
     #   # │ 1   │
     #   # └─────┘
     def first
-      _from_rbexpr(_rbexpr.first)
+      wrap_expr(_rbexpr.first)
     end
 
     # Get the last value.
@@ -2325,7 +2702,7 @@ module Polars
     #   # │ 2   │
     #   # └─────┘
     def last
-      _from_rbexpr(_rbexpr.last)
+      wrap_expr(_rbexpr.last)
     end
 
     # Apply window function over a subgroup.
@@ -2389,7 +2766,110 @@ module Polars
     #   # └────────┘
     def over(expr)
       rbexprs = Utils.parse_into_list_of_expressions(expr)
-      _from_rbexpr(_rbexpr.over(rbexprs))
+      wrap_expr(_rbexpr.over(rbexprs))
+    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"
+    )
+      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, period, offset, closed))
     end
 
     # Get mask of unique values.
@@ -2411,7 +2891,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.
@@ -2439,10 +2919,34 @@ module Polars
     #   # │ 5   ┆ true     │
     #   # └─────┴──────────┘
     def is_first_distinct
-      _from_rbexpr(_rbexpr.is_first_distinct)
+      wrap_expr(_rbexpr.is_first_distinct)
     end
     alias_method :is_first, :is_first_distinct
 
+    # 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
+
     # Get mask of duplicated values.
     #
     # @return [Expr]
@@ -2462,7 +2966,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.
@@ -2486,7 +2990,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.
@@ -2510,7 +3014,7 @@ module Polars
     #   # │ false │
     #   # └───────┘
     def peak_min
-      _from_rbexpr(_rbexpr.peak_min)
+      wrap_expr(_rbexpr.peak_min)
     end
 
     # Get quantile value.
@@ -2584,7 +3088,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.
@@ -2640,7 +3144,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.
@@ -2731,7 +3235,7 @@ module Polars
         )
       end
 
-      _from_rbexpr(rbexpr)
+      wrap_expr(rbexpr)
     end
 
     # Get the lengths of runs of identical values.
@@ -2756,7 +3260,7 @@ module Polars
     #   # │ 2   ┆ 3     │
     #   # └─────┴───────┘
     def rle
-      _from_rbexpr(_rbexpr.rle)
+      wrap_expr(_rbexpr.rle)
     end
 
     # Map values to run IDs.
@@ -2784,7 +3288,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.
@@ -2823,7 +3327,7 @@ module Polars
     #   # │ g2        ┆ 0   ┆ 3   │
     #   # └───────────┴─────┴─────┘
     def filter(predicate)
-      _from_rbexpr(_rbexpr.filter(predicate._rbexpr))
+      wrap_expr(_rbexpr.filter(predicate._rbexpr))
     end
 
     # Filter a single column.
@@ -2904,7 +3408,7 @@ module Polars
     #   if !return_dtype.nil?
     #     return_dtype = Utils.rb_type_to_dtype(return_dtype)
     #   end
-    #   _from_rbexpr(
+    #   wrap_expr(
     #     _rbexpr.map_batches(
     #       # TODO _map_batches_wrapper
     #       f,
@@ -3036,7 +3540,7 @@ module Polars
     #  # │ b     ┆ [2, 3, 4] │
     #  # └───────┴───────────┘
     def flatten
-      _from_rbexpr(_rbexpr.explode)
+      wrap_expr(_rbexpr.explode)
     end
 
     # Explode a list or utf8 Series.
@@ -3063,7 +3567,7 @@ module Polars
     #   # │ 6   │
     #   # └─────┘
     def explode
-      _from_rbexpr(_rbexpr.explode)
+      wrap_expr(_rbexpr.explode)
     end
 
     # Take every nth value in the Series and return as a new Series.
@@ -3085,7 +3589,7 @@ 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
 
@@ -3111,7 +3615,7 @@ module Polars
     #   # │ 3   │
     #   # └─────┘
     def head(n = 10)
-      _from_rbexpr(_rbexpr.head(n))
+      wrap_expr(_rbexpr.head(n))
     end
 
     # Get the last `n` rows.
@@ -3136,7 +3640,7 @@ module Polars
     #   # │ 7   │
     #   # └─────┘
     def tail(n = 10)
-      _from_rbexpr(_rbexpr.tail(n))
+      wrap_expr(_rbexpr.tail(n))
     end
 
     # Get the first `n` rows.
@@ -3166,6 +3670,89 @@ module Polars
       head(n)
     end
 
+    # Method equivalent of bitwise "and" 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("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: (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]
@@ -3198,7 +3785,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 `eq` where null values are propagated.
     #
@@ -3234,7 +3821,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`.
@@ -3402,7 +3989,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.
     #
@@ -3438,7 +4025,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`.
@@ -3515,7 +4102,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`.
@@ -3741,7 +4328,7 @@ module Polars
     #   # └───────────┴──────────────────┴──────────┘
     def is_in(other, nulls_equal: false)
       other = Utils.parse_into_expression(other)
-      _from_rbexpr(_rbexpr.is_in(other, nulls_equal))
+      wrap_expr(_rbexpr.is_in(other, nulls_equal))
     end
     alias_method :in?, :is_in
 
@@ -3777,7 +4364,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,11 +4437,48 @@ 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: 1e-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`.
@@ -3894,7 +4518,7 @@ module Polars
       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.
@@ -3928,7 +4552,7 @@ module Polars
     #   # │ 2             ┆ 2        │
     #   # └───────────────┴──────────┘
     def reinterpret(signed: false)
-      _from_rbexpr(_rbexpr.reinterpret(signed))
+      wrap_expr(_rbexpr.reinterpret(signed))
     end
 
     # Print the value that this expression evaluates to and pass on the value.
@@ -3991,7 +4615,7 @@ 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.
@@ -4022,7 +4646,7 @@ module Polars
     #   # └──────┴─────┴────────────────┘
     def interpolate_by(by)
       by = Utils.parse_into_expression(by)
-      _from_rbexpr(_rbexpr.interpolate_by(by))
+      wrap_expr(_rbexpr.interpolate_by(by))
     end
 
     # Apply a rolling min based on another column.
@@ -4123,7 +4747,7 @@ module Polars
     )
       window_size = _prepare_rolling_by_window_args(window_size)
       by = Utils.parse_into_expression(by)
-      _from_rbexpr(
+      wrap_expr(
         _rbexpr.rolling_min_by(by, window_size, min_periods, closed)
       )
     end
@@ -4252,7 +4876,7 @@ module Polars
     )
       window_size = _prepare_rolling_by_window_args(window_size)
       by = Utils.parse_into_expression(by)
-      _from_rbexpr(
+      wrap_expr(
         _rbexpr.rolling_max_by(by, window_size, min_periods, closed)
       )
     end
@@ -4383,7 +5007,7 @@ module Polars
     )
       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,
@@ -4517,7 +5141,7 @@ module Polars
     )
       window_size = _prepare_rolling_by_window_args(window_size)
       by = Utils.parse_into_expression(by)
-      _from_rbexpr(
+      wrap_expr(
         _rbexpr.rolling_sum_by(by, window_size, min_periods, closed)
       )
     end
@@ -4649,7 +5273,7 @@ module Polars
     )
       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,
@@ -4787,7 +5411,7 @@ module Polars
     )
       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,
@@ -4898,7 +5522,7 @@ module Polars
     )
       window_size = _prepare_rolling_by_window_args(window_size)
       by = Utils.parse_into_expression(by)
-      _from_rbexpr(
+      wrap_expr(
         _rbexpr.rolling_median_by(by, window_size, min_periods, closed)
       )
     end
@@ -5009,7 +5633,7 @@ module Polars
     )
       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,
@@ -5050,7 +5674,7 @@ module Polars
     #   elementwise with the values in the window.
     # @param min_periods [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
     #
@@ -5092,7 +5716,7 @@ module Polars
       min_periods: nil,
       center: false
     )
-      _from_rbexpr(
+      wrap_expr(
         _rbexpr.rolling_min(
           window_size, weights, min_periods, center
         )
@@ -5128,7 +5752,7 @@ module Polars
     #   elementwise with the values in the window.
     # @param min_periods [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
     #
@@ -5170,7 +5794,7 @@ module Polars
       min_periods: nil,
       center: false
     )
-      _from_rbexpr(
+      wrap_expr(
         _rbexpr.rolling_max(
           window_size, weights, min_periods, center
         )
@@ -5206,7 +5830,7 @@ module Polars
     #   elementwise with the values in the window.
     # @param min_periods [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
     #
@@ -5248,7 +5872,7 @@ module Polars
       min_periods: nil,
       center: false
     )
-      _from_rbexpr(
+      wrap_expr(
         _rbexpr.rolling_mean(
           window_size, weights, min_periods, center
         )
@@ -5284,7 +5908,7 @@ module Polars
     #   elementwise with the values in the window.
     # @param min_periods [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
     #
@@ -5326,7 +5950,7 @@ module Polars
       min_periods: nil,
       center: false
     )
-      _from_rbexpr(
+      wrap_expr(
         _rbexpr.rolling_sum(
           window_size, weights, min_periods, center
         )
@@ -5362,7 +5986,7 @@ module Polars
     #   elementwise with the values in the window.
     # @param min_periods [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]
@@ -5407,7 +6031,7 @@ module Polars
       center: false,
       ddof: 1
     )
-      _from_rbexpr(
+      wrap_expr(
         _rbexpr.rolling_std(
           window_size, weights, min_periods, center, ddof
         )
@@ -5443,7 +6067,7 @@ module Polars
     #   elementwise with the values in the window.
     # @param min_periods [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]
@@ -5488,7 +6112,7 @@ module Polars
       center: false,
       ddof: 1
     )
-      _from_rbexpr(
+      wrap_expr(
         _rbexpr.rolling_var(
           window_size, weights, min_periods, center, ddof
         )
@@ -5520,7 +6144,7 @@ module Polars
     #   elementwise with the values in the window.
     # @param min_periods [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
     #
@@ -5562,7 +6186,7 @@ module Polars
       min_periods: nil,
       center: false
     )
-      _from_rbexpr(
+      wrap_expr(
         _rbexpr.rolling_median(
           window_size, weights, min_periods, center
         )
@@ -5598,7 +6222,7 @@ module Polars
     #   elementwise with the values in the window.
     # @param min_periods [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
     #
@@ -5642,7 +6266,7 @@ module Polars
       min_periods: nil,
       center: false
     )
-      _from_rbexpr(
+      wrap_expr(
         _rbexpr.rolling_quantile(
           quantile, interpolation, window_size, weights, min_periods, center
         )
@@ -5706,7 +6330,7 @@ module Polars
     #   if min_periods.nil?
     #     min_periods = window_size
     #   end
-    #   _from_rbexpr(
+    #   wrap_expr(
     #     _rbexpr.rolling_apply(
     #       function, window_size, weights, min_periods, center
     #     )
@@ -5743,7 +6367,64 @@ module Polars
     #   # │ 0.47033  │
     #   # └──────────┘
     def rolling_skew(window_size, bias: true, min_samples: nil, center: false)
-      _from_rbexpr(_rbexpr.rolling_skew(window_size, bias, min_samples, center))
+      wrap_expr(_rbexpr.rolling_skew(window_size, bias, min_samples, center))
+    end
+
+    # Compute a rolling kurtosis.
+    #
+    # @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 absolute values.
@@ -5770,7 +6451,7 @@ module Polars
     #   # │ 2.0 │
     #   # └─────┘
     def abs
-      _from_rbexpr(_rbexpr.abs)
+      wrap_expr(_rbexpr.abs)
     end
 
     # Get the index values that would sort this column.
@@ -5867,7 +6548,7 @@ module Polars
     #   # │ 5   │
     #   # └─────┘
     def rank(method: "average", reverse: false, seed: nil)
-      _from_rbexpr(_rbexpr.rank(method, reverse, seed))
+      wrap_expr(_rbexpr.rank(method, reverse, seed))
     end
 
     # Calculate the n-th discrete difference.
@@ -5899,7 +6580,7 @@ module Polars
     #   # └──────┘
     def diff(n: 1, null_behavior: "ignore")
       n = Utils.parse_into_expression(n)
-      _from_rbexpr(_rbexpr.diff(n, null_behavior))
+      wrap_expr(_rbexpr.diff(n, null_behavior))
     end
 
     # Computes percentage change between values.
@@ -5936,7 +6617,7 @@ module Polars
     #   # └──────┴────────────┘
     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.
@@ -5965,7 +6646,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.
@@ -5997,7 +6678,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.
@@ -6034,7 +6715,7 @@ module Polars
       if !upper_bound.nil?
         upper_bound = Utils.parse_into_expression(upper_bound)
       end
-      _from_rbexpr(_rbexpr.clip(lower_bound, upper_bound))
+      wrap_expr(_rbexpr.clip(lower_bound, upper_bound))
     end
 
     # Clip (limit) the values in an array to a `min` boundary.
@@ -6119,7 +6800,7 @@ module Polars
     #   # │ -9223372036854775808 │
     #   # └──────────────────────┘
     def lower_bound
-      _from_rbexpr(_rbexpr.lower_bound)
+      wrap_expr(_rbexpr.lower_bound)
     end
 
     # Calculate the upper bound.
@@ -6142,7 +6823,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.
@@ -6166,7 +6847,7 @@ module Polars
     #   # │ null │
     #   # └──────┘
     def sign
-      _from_rbexpr(_rbexpr.sign)
+      wrap_expr(_rbexpr.sign)
     end
 
     # Compute the element-wise value for the sine.
@@ -6186,7 +6867,7 @@ module Polars
     #   # │ 0.0 │
     #   # └─────┘
     def sin
-      _from_rbexpr(_rbexpr.sin)
+      wrap_expr(_rbexpr.sin)
     end
 
     # Compute the element-wise value for the cosine.
@@ -6206,7 +6887,7 @@ module Polars
     #   # │ 1.0 │
     #   # └─────┘
     def cos
-      _from_rbexpr(_rbexpr.cos)
+      wrap_expr(_rbexpr.cos)
     end
 
     # Compute the element-wise value for the tangent.
@@ -6226,7 +6907,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.
@@ -6246,7 +6947,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.
@@ -6266,7 +6967,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.
@@ -6286,7 +6987,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.
@@ -6306,7 +7007,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.
@@ -6326,7 +7027,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.
@@ -6346,7 +7047,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.
@@ -6366,7 +7067,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.
@@ -6386,7 +7087,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.
@@ -6406,7 +7107,63 @@ 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.
@@ -6452,13 +7209,13 @@ module Polars
     #   # │ 9   │
     #   # └─────┘
     def reshape(dims)
-      _from_rbexpr(_rbexpr.reshape(dims))
+      wrap_expr(_rbexpr.reshape(dims))
     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]
@@ -6481,7 +7238,7 @@ module Polars
       if seed.nil?
         seed = rand(10000)
       end
-      _from_rbexpr(_rbexpr.shuffle(seed))
+      wrap_expr(_rbexpr.shuffle(seed))
     end
 
     # Sample from this expression.
@@ -6493,7 +7250,7 @@ module Polars
     # @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`.
@@ -6527,14 +7284,14 @@ module Polars
 
       if !n.nil? && frac.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
       end
       frac = Utils.parse_into_expression(frac)
-      _from_rbexpr(
+      wrap_expr(
         _rbexpr.sample_frac(frac, with_replacement, shuffle, seed)
       )
     end
@@ -6567,7 +7324,76 @@ module Polars
       ignore_nulls: true
     )
       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_periods, 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.
@@ -6599,7 +7425,7 @@ module Polars
       ignore_nulls: true
     )
       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_periods, ignore_nulls))
     end
 
     # Exponentially-weighted moving variance.
@@ -6631,7 +7457,7 @@ module Polars
       ignore_nulls: true
     )
       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_periods, ignore_nulls))
     end
 
     # Extend the Series with given number of values.
@@ -6663,7 +7489,7 @@ module Polars
     def extend_constant(value, n)
       value = Utils.parse_into_expression(value, str_as_lit: true)
       n = Utils.parse_into_expression(n)
-      _from_rbexpr(_rbexpr.extend_constant(value, n))
+      wrap_expr(_rbexpr.extend_constant(value, n))
     end
 
     # Count all unique values and create a struct mapping value to count.
@@ -6717,7 +7543,7 @@ module Polars
           name = "count"
         end
       end
-      _from_rbexpr(
+      wrap_expr(
         _rbexpr.value_counts(sort, parallel, name, normalize)
       )
     end
@@ -6752,7 +7578,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.
@@ -6777,7 +7603,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.
@@ -6816,7 +7667,7 @@ module Polars
     #   # │ -6.754888 │
     #   # └───────────┘
     def entropy(base: 2, normalize: true)
-      _from_rbexpr(_rbexpr.entropy(base, normalize))
+      wrap_expr(_rbexpr.entropy(base, normalize))
     end
 
     # Run an expression over a sliding window that increases `1` slot every iteration.
@@ -6860,7 +7711,7 @@ module Polars
     #   # │ -24    │
     #   # └────────┘
     def cumulative_eval(expr, min_periods: 1)
-      _from_rbexpr(
+      wrap_expr(
         _rbexpr.cumulative_eval(expr._rbexpr, min_periods)
       )
     end
@@ -6891,7 +7742,7 @@ module Polars
     #   # │ 3      │
     #   # └────────┘
     def set_sorted(descending: false)
-      _from_rbexpr(_rbexpr.set_sorted_flag(descending))
+      wrap_expr(_rbexpr.set_sorted_flag(descending))
     end
 
     # Aggregate to list.
@@ -6916,7 +7767,7 @@ module Polars
     #   # │ [1, 2, 3] ┆ [4, 5, 6] │
     #   # └───────────┴───────────┘
     def implode
-      _from_rbexpr(_rbexpr.implode)
+      wrap_expr(_rbexpr.implode)
     end
 
     # Shrink numeric columns to the minimal required datatype.
@@ -6925,33 +7776,74 @@ module Polars
     # This can be used to reduce memory pressure.
     #
     # @return [Expr]
+    def shrink_dtype
+      warn "`Expr.shrink_dtype` is deprecated and is a no-op; use `Series.shrink_dtype` instead."
+      self
+    end
+
+    # 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.
+    #
+    # @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.
@@ -7110,7 +8002,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)
@@ -7262,11 +8154,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]
@@ -7332,7 +8374,7 @@ module Polars
 
     private
 
-    def _from_rbexpr(expr)
+    def wrap_expr(expr)
       Utils.wrap_expr(expr)
     end