polars-df 0.8.0-x86_64-linux → 0.10.0-x86_64-linux

data/lib/polars/expr.rb

@@ -1,6 +1,9 @@
 module Polars
   # Expressions that can be used in various contexts.
   class Expr
+    # @private
+    NO_DEFAULT = Object.new
+
     # @private
     attr_accessor :_rbexpr
 
@@ -23,112 +26,106 @@ module Polars
     #
     # @return [Expr]
     def ^(other)
-      wrap_expr(_rbexpr._xor(_to_rbexpr(other)))
+      _from_rbexpr(_rbexpr._xor(_to_rbexpr(other)))
     end
 
     # Bitwise AND.
     #
     # @return [Expr]
     def &(other)
-      wrap_expr(_rbexpr._and(_to_rbexpr(other)))
+      _from_rbexpr(_rbexpr._and(_to_rbexpr(other)))
     end
 
     # Bitwise OR.
     #
     # @return [Expr]
     def |(other)
-      wrap_expr(_rbexpr._or(_to_rbexpr(other)))
+      _from_rbexpr(_rbexpr._or(_to_rbexpr(other)))
     end
 
     # Performs addition.
     #
     # @return [Expr]
     def +(other)
-      wrap_expr(_rbexpr + _to_rbexpr(other))
+      _from_rbexpr(_rbexpr + _to_rbexpr(other))
     end
 
     # Performs subtraction.
     #
     # @return [Expr]
     def -(other)
-      wrap_expr(_rbexpr - _to_rbexpr(other))
+      _from_rbexpr(_rbexpr - _to_rbexpr(other))
     end
 
     # Performs multiplication.
     #
     # @return [Expr]
     def *(other)
-      wrap_expr(_rbexpr * _to_rbexpr(other))
+      _from_rbexpr(_rbexpr * _to_rbexpr(other))
     end
 
     # Performs division.
     #
     # @return [Expr]
     def /(other)
-      wrap_expr(_rbexpr / _to_rbexpr(other))
-    end
-
-    # Performs floor division.
-    #
-    # @return [Expr]
-    def floordiv(other)
-      wrap_expr(_rbexpr.floordiv(_to_rbexpr(other)))
+      _from_rbexpr(_rbexpr / _to_rbexpr(other))
     end
 
     # Returns the modulo.
     #
     # @return [Expr]
     def %(other)
-      wrap_expr(_rbexpr % _to_rbexpr(other))
+      _from_rbexpr(_rbexpr % _to_rbexpr(other))
     end
 
     # Raises to the power of exponent.
     #
     # @return [Expr]
     def **(power)
-      pow(power)
+      exponent = Utils.expr_to_lit_or_expr(power)
+      _from_rbexpr(_rbexpr.pow(exponent._rbexpr))
     end
 
     # Greater than or equal.
     #
     # @return [Expr]
     def >=(other)
-      wrap_expr(_rbexpr.gt_eq(_to_expr(other)._rbexpr))
+      _from_rbexpr(_rbexpr.gt_eq(_to_expr(other)._rbexpr))
     end
 
     # Less than or equal.
     #
     # @return [Expr]
     def <=(other)
-      wrap_expr(_rbexpr.lt_eq(_to_expr(other)._rbexpr))
+      _from_rbexpr(_rbexpr.lt_eq(_to_expr(other)._rbexpr))
     end
 
     # Equal.
     #
     # @return [Expr]
     def ==(other)
-      wrap_expr(_rbexpr.eq(_to_expr(other)._rbexpr))
+      _from_rbexpr(_rbexpr.eq(_to_expr(other)._rbexpr))
     end
 
     # Not equal.
     #
     # @return [Expr]
     def !=(other)
-      wrap_expr(_rbexpr.neq(_to_expr(other)._rbexpr))
+      _from_rbexpr(_rbexpr.neq(_to_expr(other)._rbexpr))
     end
 
     # Less than.
     #
     # @return [Expr]
     def <(other)
-      wrap_expr(_rbexpr.lt(_to_expr(other)._rbexpr))
+      _from_rbexpr(_rbexpr.lt(_to_expr(other)._rbexpr))
     end
 
     # Greater than.
     #
     # @return [Expr]
     def >(other)
-      wrap_expr(_rbexpr.gt(_to_expr(other)._rbexpr))
+      _from_rbexpr(_rbexpr.gt(_to_expr(other)._rbexpr))
     end
 
     # Performs boolean not.
@@ -142,7 +139,7 @@ module Polars
     #
     # @return [Expr]
     def -@
-      Utils.lit(0) - self
+      _from_rbexpr(_rbexpr.neg)
     end
 
     # Cast to physical representation of the logical dtype.
@@ -179,7 +176,7 @@ module Polars
     #   # │ a    ┆ 0             │
     #   # └──────┴───────────────┘
     def to_physical
-      wrap_expr(_rbexpr.to_physical)
+      _from_rbexpr(_rbexpr.to_physical)
     end
 
     # Check if any boolean value in a Boolean column is `true`.
@@ -199,7 +196,7 @@ module Polars
     #   # │ true ┆ false │
     #   # └──────┴───────┘
     def any(drop_nulls: true)
-      wrap_expr(_rbexpr.any(drop_nulls))
+      _from_rbexpr(_rbexpr.any(drop_nulls))
     end
 
     # Check if all boolean values in a Boolean column are `true`.
@@ -224,7 +221,7 @@ module Polars
     #   # │ true ┆ false ┆ false │
     #   # └──────┴───────┴───────┘
     def all(drop_nulls: true)
-      wrap_expr(_rbexpr.all(drop_nulls))
+      _from_rbexpr(_rbexpr.all(drop_nulls))
     end
 
     # Compute the square root of the elements.
@@ -290,7 +287,7 @@ module Polars
     #   # │ 54.59815 │
     #   # └──────────┘
     def exp
-      wrap_expr(_rbexpr.exp)
+      _from_rbexpr(_rbexpr.exp)
     end
 
     # Rename the output of an expression.
@@ -325,7 +322,7 @@ module Polars
     #   # │ 3   ┆ null │
     #   # └─────┴──────┘
     def alias(name)
-      wrap_expr(_rbexpr._alias(name))
+      _from_rbexpr(_rbexpr._alias(name))
     end
 
     # TODO support symbols for exclude
@@ -368,10 +365,10 @@ module Polars
     def exclude(columns)
       if columns.is_a?(::String)
         columns = [columns]
-        return wrap_expr(_rbexpr.exclude(columns))
+        return _from_rbexpr(_rbexpr.exclude(columns))
       elsif !columns.is_a?(::Array)
         columns = [columns]
-        return wrap_expr(_rbexpr.exclude_dtype(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) }
@@ -379,9 +376,9 @@ module Polars
       end
 
       if columns[0].is_a?(::String)
-        wrap_expr(_rbexpr.exclude(columns))
+        _from_rbexpr(_rbexpr.exclude(columns))
       else
-        wrap_expr(_rbexpr.exclude_dtype(columns))
+        _from_rbexpr(_rbexpr.exclude_dtype(columns))
       end
     end
 
@@ -490,8 +487,9 @@ module Polars
     #   # │ true  │
     #   # └───────┘
     def is_not
-      wrap_expr(_rbexpr.is_not)
+      _from_rbexpr(_rbexpr.not_)
     end
+    alias_method :not_, :is_not
 
     # Returns a boolean Series indicating which values are null.
     #
@@ -519,7 +517,7 @@ module Polars
     #   # │ 5    ┆ 5.0 ┆ false    ┆ false    │
     #   # └──────┴─────┴──────────┴──────────┘
     def is_null
-      wrap_expr(_rbexpr.is_null)
+      _from_rbexpr(_rbexpr.is_null)
     end
 
     # Returns a boolean Series indicating which values are not null.
@@ -548,7 +546,7 @@ module Polars
     #   # │ 5    ┆ 5.0 ┆ true       ┆ true       │
     #   # └──────┴─────┴────────────┴────────────┘
     def is_not_null
-      wrap_expr(_rbexpr.is_not_null)
+      _from_rbexpr(_rbexpr.is_not_null)
     end
 
     # Returns a boolean Series indicating which values are finite.
@@ -574,7 +572,7 @@ module Polars
     #   # │ true ┆ false │
     #   # └──────┴───────┘
     def is_finite
-      wrap_expr(_rbexpr.is_finite)
+      _from_rbexpr(_rbexpr.is_finite)
     end
 
     # Returns a boolean Series indicating which values are infinite.
@@ -600,7 +598,7 @@ module Polars
     #   # │ false ┆ true  │
     #   # └───────┴───────┘
     def is_infinite
-      wrap_expr(_rbexpr.is_infinite)
+      _from_rbexpr(_rbexpr.is_infinite)
     end
 
     # Returns a boolean Series indicating which values are NaN.
@@ -633,7 +631,7 @@ module Polars
     #   # │ 5    ┆ 5.0 ┆ false   │
     #   # └──────┴─────┴─────────┘
     def is_nan
-      wrap_expr(_rbexpr.is_nan)
+      _from_rbexpr(_rbexpr.is_nan)
     end
 
     # Returns a boolean Series indicating which values are not NaN.
@@ -666,7 +664,7 @@ module Polars
     #   # │ 5    ┆ 5.0 ┆ true         │
     #   # └──────┴─────┴──────────────┘
     def is_not_nan
-      wrap_expr(_rbexpr.is_not_nan)
+      _from_rbexpr(_rbexpr.is_not_nan)
     end
 
     # Get the group indexes of the group by operation.
@@ -701,7 +699,7 @@ module Polars
     #   # │ two   ┆ [3, 4, 5] │
     #   # └───────┴───────────┘
     def agg_groups
-      wrap_expr(_rbexpr.agg_groups)
+      _from_rbexpr(_rbexpr.agg_groups)
     end
 
     # Count the number of values in this expression.
@@ -718,12 +716,10 @@ module Polars
     #   # │ --- ┆ --- │
     #   # │ u32 ┆ u32 │
     #   # ╞═════╪═════╡
-    #   # │ 3   ┆ 3   │
+    #   # │ 3   ┆ 2   │
     #   # └─────┴─────┘
     def count
-      warn "`Expr#count` will exclude null values in 0.9.0. Use `Expr#length` instead."
-      # wrap_expr(_rbexpr.count)
-      wrap_expr(_rbexpr.len)
+      _from_rbexpr(_rbexpr.count)
     end
 
     # Count the number of values in this expression.
@@ -743,7 +739,7 @@ module Polars
     #   # │ 3   ┆ 3   │
     #   # └─────┴─────┘
     def len
-      wrap_expr(_rbexpr.len)
+      _from_rbexpr(_rbexpr.len)
     end
     alias_method :length, :len
 
@@ -782,7 +778,7 @@ module Polars
       if !length.is_a?(Expr)
         length = Polars.lit(length)
       end
-      wrap_expr(_rbexpr.slice(offset._rbexpr, length._rbexpr))
+      _from_rbexpr(_rbexpr.slice(offset._rbexpr, length._rbexpr))
     end
 
     # Append expressions.
@@ -816,7 +812,7 @@ module Polars
     #   # └─────┴──────┘
     def append(other, upcast: true)
       other = Utils.expr_to_lit_or_expr(other)
-      wrap_expr(_rbexpr.append(other._rbexpr, upcast))
+      _from_rbexpr(_rbexpr.append(other._rbexpr, upcast))
     end
 
     # Create a single chunk of memory for this Series.
@@ -841,7 +837,7 @@ module Polars
     #   # │ 2      │
     #   # └────────┘
     def rechunk
-      wrap_expr(_rbexpr.rechunk)
+      _from_rbexpr(_rbexpr.rechunk)
     end
 
     # Drop null values.
@@ -868,7 +864,7 @@ module Polars
     #   # │ NaN │
     #   # └─────┘
     def drop_nulls
-      wrap_expr(_rbexpr.drop_nulls)
+      _from_rbexpr(_rbexpr.drop_nulls)
     end
 
     # Drop floating point NaN values.
@@ -895,7 +891,7 @@ module Polars
     #   # │ 4.0  │
     #   # └──────┘
     def drop_nans
-      wrap_expr(_rbexpr.drop_nans)
+      _from_rbexpr(_rbexpr.drop_nans)
     end
 
     # Get an array with the cumulative sum computed at every element.
@@ -930,7 +926,7 @@ module Polars
     #   # │ 10  ┆ 4         │
     #   # └─────┴───────────┘
     def cum_sum(reverse: false)
-      wrap_expr(_rbexpr.cum_sum(reverse))
+      _from_rbexpr(_rbexpr.cum_sum(reverse))
     end
     alias_method :cumsum, :cum_sum
 
@@ -966,7 +962,7 @@ module Polars
     #   # │ 24  ┆ 4         │
     #   # └─────┴───────────┘
     def cum_prod(reverse: false)
-      wrap_expr(_rbexpr.cum_prod(reverse))
+      _from_rbexpr(_rbexpr.cum_prod(reverse))
     end
     alias_method :cumprod, :cum_prod
 
@@ -998,7 +994,7 @@ module Polars
     #   # │ 1   ┆ 4         │
     #   # └─────┴───────────┘
     def cum_min(reverse: false)
-      wrap_expr(_rbexpr.cum_min(reverse))
+      _from_rbexpr(_rbexpr.cum_min(reverse))
     end
     alias_method :cummin, :cum_min
 
@@ -1030,7 +1026,7 @@ module Polars
     #   # │ 4   ┆ 4         │
     #   # └─────┴───────────┘
     def cum_max(reverse: false)
-      wrap_expr(_rbexpr.cum_max(reverse))
+      _from_rbexpr(_rbexpr.cum_max(reverse))
     end
     alias_method :cummax, :cum_max
 
@@ -1044,27 +1040,27 @@ module Polars
     # @return [Expr]
     #
     # @example
-    #   df = Polars::DataFrame.new({"a" => [1, 2, 3, 4]})
-    #   df.select(
+    #   df = Polars::DataFrame.new({"a" => ["x", "k", nil, "d"]})
+    #   df.with_columns(
     #     [
-    #       Polars.col("a").cum_count,
-    #       Polars.col("a").cum_count(reverse: true).alias("a_reverse")
+    #       Polars.col("a").cum_count.alias("cum_count"),
+    #       Polars.col("a").cum_count(reverse: true).alias("cum_count_reverse")
     #     ]
     #   )
     #   # =>
-    #   # shape: (4, 2)
-    #   # ┌─────┬───────────┐
-    #   # │ a   ┆ a_reverse │
-    #   # │ --- ┆ ---       │
-    #   # │ u32 ┆ u32       │
-    #   # ╞═════╪═══════════╡
-    #   # │ 0   ┆ 3         │
-    #   # │ 1   ┆ 2         │
-    #   # │ 2   ┆ 1         │
-    #   # │ 3   ┆ 0         │
-    #   # └─────┴───────────┘
+    #   # shape: (4, 3)
+    #   # ┌──────┬───────────┬───────────────────┐
+    #   # │ a    ┆ cum_count ┆ cum_count_reverse │
+    #   # │ ---  ┆ ---       ┆ ---               │
+    #   # │ str  ┆ u32       ┆ u32               │
+    #   # ╞══════╪═══════════╪═══════════════════╡
+    #   # │ x    ┆ 1         ┆ 3                 │
+    #   # │ k    ┆ 2         ┆ 2                 │
+    #   # │ null ┆ 2         ┆ 1                 │
+    #   # │ d    ┆ 3         ┆ 1                 │
+    #   # └──────┴───────────┴───────────────────┘
     def cum_count(reverse: false)
-      wrap_expr(_rbexpr.cum_count(reverse))
+      _from_rbexpr(_rbexpr.cum_count(reverse))
     end
     alias_method :cumcount, :cum_count
 
@@ -1090,7 +1086,7 @@ module Polars
     #   # │ 1.0 │
     #   # └─────┘
     def floor
-      wrap_expr(_rbexpr.floor)
+      _from_rbexpr(_rbexpr.floor)
     end
 
     # Rounds up to the nearest integer value.
@@ -1115,7 +1111,7 @@ module Polars
     #   # │ 2.0 │
     #   # └─────┘
     def ceil
-      wrap_expr(_rbexpr.ceil)
+      _from_rbexpr(_rbexpr.ceil)
     end
 
     # Round underlying floating point data by `decimals` digits.
@@ -1141,7 +1137,7 @@ module Polars
     #   # │ 1.2 │
     #   # └─────┘
     def round(decimals = 0)
-      wrap_expr(_rbexpr.round(decimals))
+      _from_rbexpr(_rbexpr.round(decimals))
     end
 
     # Compute the dot/inner product between two Expressions.
@@ -1170,7 +1166,7 @@ module Polars
     #   # └─────┘
     def dot(other)
       other = Utils.expr_to_lit_or_expr(other, str_to_lit: false)
-      wrap_expr(_rbexpr.dot(other._rbexpr))
+      _from_rbexpr(_rbexpr.dot(other._rbexpr))
     end
 
     # Compute the most occurring value(s).
@@ -1198,7 +1194,7 @@ module Polars
     #   # │ 1   ┆ 2   │
     #   # └─────┴─────┘
     def mode
-      wrap_expr(_rbexpr.mode)
+      _from_rbexpr(_rbexpr.mode)
     end
 
     # Cast between data types.
@@ -1237,7 +1233,7 @@ module Polars
     #   # └─────┴─────┘
     def cast(dtype, strict: true)
       dtype = Utils.rb_type_to_dtype(dtype)
-      wrap_expr(_rbexpr.cast(dtype, strict))
+      _from_rbexpr(_rbexpr.cast(dtype, strict))
     end
 
     # Sort this column. In projection/ selection context the whole column is sorted.
@@ -1312,7 +1308,7 @@ module Polars
     #   # │ one   ┆ [1, 2, 98] │
     #   # └───────┴────────────┘
     def sort(reverse: false, nulls_last: false)
-      wrap_expr(_rbexpr.sort_with(reverse, nulls_last))
+      _from_rbexpr(_rbexpr.sort_with(reverse, nulls_last))
     end
 
     # Return the `k` largest elements.
@@ -1351,7 +1347,7 @@ module Polars
     #   # └───────┴──────────┘
     def top_k(k: 5)
       k = Utils.parse_as_expression(k)
-      wrap_expr(_rbexpr.top_k(k))
+      _from_rbexpr(_rbexpr.top_k(k))
     end
 
     # Return the `k` smallest elements.
@@ -1390,7 +1386,7 @@ module Polars
     #   # └───────┴──────────┘
     def bottom_k(k: 5)
       k = Utils.parse_as_expression(k)
-      wrap_expr(_rbexpr.bottom_k(k))
+      _from_rbexpr(_rbexpr.bottom_k(k))
     end
 
     # Get the index values that would sort this column.
@@ -1421,7 +1417,7 @@ module Polars
     #   # │ 2   │
     #   # └─────┘
     def arg_sort(reverse: false, nulls_last: false)
-      wrap_expr(_rbexpr.arg_sort(reverse, nulls_last))
+      _from_rbexpr(_rbexpr.arg_sort(reverse, nulls_last))
     end
 
     # Get the index of the maximal value.
@@ -1445,7 +1441,7 @@ module Polars
     #   # │ 2   │
     #   # └─────┘
     def arg_max
-      wrap_expr(_rbexpr.arg_max)
+      _from_rbexpr(_rbexpr.arg_max)
     end
 
     # Get the index of the minimal value.
@@ -1469,7 +1465,7 @@ module Polars
     #   # │ 1   │
     #   # └─────┘
     def arg_min
-      wrap_expr(_rbexpr.arg_min)
+      _from_rbexpr(_rbexpr.arg_min)
     end
 
     # Find indices where elements should be inserted to maintain order.
@@ -1503,7 +1499,7 @@ module Polars
     #   # └──────┴───────┴─────┘
     def search_sorted(element, side: "any")
       element = Utils.expr_to_lit_or_expr(element, str_to_lit: false)
-      wrap_expr(_rbexpr.search_sorted(element._rbexpr, side))
+      _from_rbexpr(_rbexpr.search_sorted(element._rbexpr, side))
     end
 
     # Sort this column by the ordering of another column, or multiple other columns.
@@ -1548,16 +1544,14 @@ module Polars
     #   # │ one   │
     #   # │ two   │
     #   # └───────┘
-    def sort_by(by, reverse: false)
-      if !by.is_a?(::Array)
-        by = [by]
-      end
+    def sort_by(by, *more_by, reverse: false, nulls_last: false, multithreaded: true, maintain_order: false)
+      by = Utils.parse_as_list_of_expressions(by, *more_by)
       if !reverse.is_a?(::Array)
         reverse = [reverse]
+      elsif by.length != reverse.length
+        raise ArgumentError, "the length of `reverse` (#{reverse.length}) does not match the length of `by` (#{by.length})"
       end
-      by = Utils.selection_to_rbexpr_list(by)
-
-      wrap_expr(_rbexpr.sort_by(by, reverse))
+      _from_rbexpr(_rbexpr.sort_by(by, reverse, nulls_last, multithreaded, maintain_order))
     end
 
     # Take values by index.
@@ -1598,7 +1592,7 @@ module Polars
       else
         indices_lit = Utils.expr_to_lit_or_expr(indices, str_to_lit: false)
       end
-      wrap_expr(_rbexpr.gather(indices_lit._rbexpr))
+      _from_rbexpr(_rbexpr.gather(indices_lit._rbexpr))
     end
     alias_method :take, :gather
 
@@ -1631,7 +1625,7 @@ module Polars
         fill_value = Utils.parse_as_expression(fill_value, str_as_lit: true)
       end
       n = Utils.parse_as_expression(n)
-      wrap_expr(_rbexpr.shift(n, fill_value))
+      _from_rbexpr(_rbexpr.shift(n, fill_value))
     end
 
     # Shift the values by a given period and fill the resulting null values.
@@ -1734,9 +1728,9 @@ module Polars
 
       if !value.nil?
         value = Utils.expr_to_lit_or_expr(value, str_to_lit: true)
-        wrap_expr(_rbexpr.fill_null(value._rbexpr))
+        _from_rbexpr(_rbexpr.fill_null(value._rbexpr))
       else
-        wrap_expr(_rbexpr.fill_null_with_strategy(strategy, limit))
+        _from_rbexpr(_rbexpr.fill_null_with_strategy(strategy, limit))
       end
     end
 
@@ -1765,7 +1759,7 @@ module Polars
     #   # └──────┴──────┘
     def fill_nan(fill_value)
       fill_value = Utils.expr_to_lit_or_expr(fill_value, str_to_lit: true)
-      wrap_expr(_rbexpr.fill_nan(fill_value._rbexpr))
+      _from_rbexpr(_rbexpr.fill_nan(fill_value._rbexpr))
     end
 
     # Fill missing values with the latest seen values.
@@ -1795,7 +1789,7 @@ module Polars
     #   # │ 2   ┆ 6   │
     #   # └─────┴─────┘
     def forward_fill(limit: nil)
-      wrap_expr(_rbexpr.forward_fill(limit))
+      _from_rbexpr(_rbexpr.forward_fill(limit))
     end
 
     # Fill missing values with the next to be seen values.
@@ -1825,14 +1819,14 @@ module Polars
     #   # │ null ┆ 6   │
     #   # └──────┴─────┘
     def backward_fill(limit: nil)
-      wrap_expr(_rbexpr.backward_fill(limit))
+      _from_rbexpr(_rbexpr.backward_fill(limit))
     end
 
     # Reverse the selection.
     #
     # @return [Expr]
     def reverse
-      wrap_expr(_rbexpr.reverse)
+      _from_rbexpr(_rbexpr.reverse)
     end
 
     # Get standard deviation.
@@ -1855,7 +1849,7 @@ module Polars
     #   # │ 1.0 │
     #   # └─────┘
     def std(ddof: 1)
-      wrap_expr(_rbexpr.std(ddof))
+      _from_rbexpr(_rbexpr.std(ddof))
     end
 
     # Get variance.
@@ -1878,7 +1872,7 @@ module Polars
     #   # │ 1.0 │
     #   # └─────┘
     def var(ddof: 1)
-      wrap_expr(_rbexpr.var(ddof))
+      _from_rbexpr(_rbexpr.var(ddof))
     end
 
     # Get maximum value.
@@ -1898,7 +1892,7 @@ module Polars
     #   # │ 1.0 │
     #   # └─────┘
     def max
-      wrap_expr(_rbexpr.max)
+      _from_rbexpr(_rbexpr.max)
     end
 
     # Get minimum value.
@@ -1918,7 +1912,7 @@ module Polars
     #   # │ -1.0 │
     #   # └──────┘
     def min
-      wrap_expr(_rbexpr.min)
+      _from_rbexpr(_rbexpr.min)
     end
 
     # Get maximum value, but propagate/poison encountered NaN values.
@@ -1938,7 +1932,7 @@ module Polars
     #   # │ NaN │
     #   # └─────┘
     def nan_max
-      wrap_expr(_rbexpr.nan_max)
+      _from_rbexpr(_rbexpr.nan_max)
     end
 
     # Get minimum value, but propagate/poison encountered NaN values.
@@ -1958,7 +1952,7 @@ module Polars
     #   # │ NaN │
     #   # └─────┘
     def nan_min
-      wrap_expr(_rbexpr.nan_min)
+      _from_rbexpr(_rbexpr.nan_min)
     end
 
     # Get sum value.
@@ -1982,7 +1976,7 @@ module Polars
     #   # │ 0   │
     #   # └─────┘
     def sum
-      wrap_expr(_rbexpr.sum)
+      _from_rbexpr(_rbexpr.sum)
     end
 
     # Get mean value.
@@ -2002,7 +1996,7 @@ module Polars
     #   # │ 0.0 │
     #   # └─────┘
     def mean
-      wrap_expr(_rbexpr.mean)
+      _from_rbexpr(_rbexpr.mean)
     end
 
     # Get median value using linear interpolation.
@@ -2022,7 +2016,7 @@ module Polars
     #   # │ 0.0 │
     #   # └─────┘
     def median
-      wrap_expr(_rbexpr.median)
+      _from_rbexpr(_rbexpr.median)
     end
 
     # Compute the product of an expression.
@@ -2042,7 +2036,7 @@ module Polars
     #   # │ 6   │
     #   # └─────┘
     def product
-      wrap_expr(_rbexpr.product)
+      _from_rbexpr(_rbexpr.product)
     end
 
     # Count unique values.
@@ -2062,7 +2056,7 @@ module Polars
     #   # │ 2   │
     #   # └─────┘
     def n_unique
-      wrap_expr(_rbexpr.n_unique)
+      _from_rbexpr(_rbexpr.n_unique)
     end
 
     # Approx count unique values.
@@ -2073,7 +2067,7 @@ module Polars
     #
     # @example
     #   df = Polars::DataFrame.new({"a" => [1, 1, 2]})
-    #   df.select(Polars.col("a").approx_unique)
+    #   df.select(Polars.col("a").approx_n_unique)
     #   # =>
     #   # shape: (1, 1)
     #   # ┌─────┐
@@ -2083,9 +2077,10 @@ module Polars
     #   # ╞═════╡
     #   # │ 2   │
     #   # └─────┘
-    def approx_unique
-      wrap_expr(_rbexpr.approx_n_unique)
+    def approx_n_unique
+      _from_rbexpr(_rbexpr.approx_n_unique)
     end
+    alias_method :approx_unique, :approx_n_unique
 
     # Count null values.
     #
@@ -2109,7 +2104,7 @@ module Polars
     #   # │ 2   ┆ 0   │
     #   # └─────┴─────┘
     def null_count
-      wrap_expr(_rbexpr.null_count)
+      _from_rbexpr(_rbexpr.null_count)
     end
 
     # Get index of first unique value.
@@ -2149,7 +2144,7 @@ module Polars
     #   # │ 1   │
     #   # └─────┘
     def arg_unique
-      wrap_expr(_rbexpr.arg_unique)
+      _from_rbexpr(_rbexpr.arg_unique)
     end
 
     # Get unique values of this expression.
@@ -2174,9 +2169,9 @@ module Polars
     #   # └─────┘
     def unique(maintain_order: false)
       if maintain_order
-        wrap_expr(_rbexpr.unique_stable)
+        _from_rbexpr(_rbexpr.unique_stable)
       else
-        wrap_expr(_rbexpr.unique)
+        _from_rbexpr(_rbexpr.unique)
       end
     end
 
@@ -2197,7 +2192,7 @@ module Polars
     #   # │ 1   │
     #   # └─────┘
     def first
-      wrap_expr(_rbexpr.first)
+      _from_rbexpr(_rbexpr.first)
     end
 
     # Get the last value.
@@ -2217,7 +2212,7 @@ module Polars
     #   # │ 2   │
     #   # └─────┘
     def last
-      wrap_expr(_rbexpr.last)
+      _from_rbexpr(_rbexpr.last)
     end
 
     # Apply window function over a subgroup.
@@ -2281,7 +2276,7 @@ module Polars
     #   # └────────┘
     def over(expr)
       rbexprs = Utils.selection_to_rbexpr_list(expr)
-      wrap_expr(_rbexpr.over(rbexprs))
+      _from_rbexpr(_rbexpr.over(rbexprs))
     end
 
     # Get mask of unique values.
@@ -2303,7 +2298,7 @@ module Polars
     #   # │ true  │
     #   # └───────┘
     def is_unique
-      wrap_expr(_rbexpr.is_unique)
+      _from_rbexpr(_rbexpr.is_unique)
     end
 
     # Get a mask of the first unique value.
@@ -2331,7 +2326,7 @@ module Polars
     #   # │ 5   ┆ true     │
     #   # └─────┴──────────┘
     def is_first_distinct
-      wrap_expr(_rbexpr.is_first_distinct)
+      _from_rbexpr(_rbexpr.is_first_distinct)
     end
     alias_method :is_first, :is_first_distinct
 
@@ -2354,7 +2349,7 @@ module Polars
     #   # │ false │
     #   # └───────┘
     def is_duplicated
-      wrap_expr(_rbexpr.is_duplicated)
+      _from_rbexpr(_rbexpr.is_duplicated)
     end
 
     # Get a boolean mask of the local maximum peaks.
@@ -2378,7 +2373,7 @@ module Polars
     #   # │ true  │
     #   # └───────┘
     def peak_max
-      wrap_expr(_rbexpr.peak_max)
+      _from_rbexpr(_rbexpr.peak_max)
     end
 
     # Get a boolean mask of the local minimum peaks.
@@ -2402,7 +2397,7 @@ module Polars
     #   # │ false │
     #   # └───────┘
     def peak_min
-      wrap_expr(_rbexpr.peak_min)
+      _from_rbexpr(_rbexpr.peak_min)
     end
 
     # Get quantile value.
@@ -2476,7 +2471,7 @@ module Polars
     #   # └─────┘
     def quantile(quantile, interpolation: "nearest")
       quantile = Utils.expr_to_lit_or_expr(quantile, str_to_lit: false)
-      wrap_expr(_rbexpr.quantile(quantile._rbexpr, interpolation))
+      _from_rbexpr(_rbexpr.quantile(quantile._rbexpr, interpolation))
     end
 
     # Bin continuous values into discrete categories.
@@ -2532,7 +2527,7 @@ module Polars
     #   # │ 2   ┆ inf  ┆ (1, inf]   │
     #   # └─────┴──────┴────────────┘
     def cut(breaks, labels: nil, left_closed: false, include_breaks: false)
-      wrap_expr(_rbexpr.cut(breaks, labels, left_closed, include_breaks))
+      _from_rbexpr(_rbexpr.cut(breaks, labels, left_closed, include_breaks))
     end
 
     # Bin continuous values into discrete categories based on their quantiles.
@@ -2623,7 +2618,7 @@ module Polars
         )
       end
 
-      wrap_expr(rbexpr)
+      _from_rbexpr(rbexpr)
     end
 
     # Get the lengths of runs of identical values.
@@ -2648,7 +2643,7 @@ module Polars
     #   # │ 2       ┆ 3      │
     #   # └─────────┴────────┘
     def rle
-      wrap_expr(_rbexpr.rle)
+      _from_rbexpr(_rbexpr.rle)
     end
 
     # Map values to run IDs.
@@ -2676,7 +2671,7 @@ module Polars
     #   # │ 1   ┆ y    ┆ 2   ┆ 3    │
     #   # └─────┴──────┴─────┴──────┘
     def rle_id
-      wrap_expr(_rbexpr.rle_id)
+      _from_rbexpr(_rbexpr.rle_id)
     end
 
     # Filter a single column.
@@ -2715,7 +2710,7 @@ module Polars
     #   # │ g2        ┆ 0   ┆ 3   │
     #   # └───────────┴─────┴─────┘
     def filter(predicate)
-      wrap_expr(_rbexpr.filter(predicate._rbexpr))
+      _from_rbexpr(_rbexpr.filter(predicate._rbexpr))
     end
 
     # Filter a single column.
@@ -2793,7 +2788,7 @@ module Polars
     #   if !return_dtype.nil?
     #     return_dtype = Utils.rb_type_to_dtype(return_dtype)
     #   end
-    #   wrap_expr(_rbexpr.map(f, return_dtype, agg_list))
+    #   _from_rbexpr(_rbexpr.map(f, return_dtype, agg_list))
     # end
 
     # Apply a custom/user-defined function (UDF) in a GroupBy or Projection context.
@@ -2904,7 +2899,7 @@ module Polars
     #  # │ b     ┆ [2, 3, 4] │
     #  # └───────┴───────────┘
     def flatten
-      wrap_expr(_rbexpr.explode)
+      _from_rbexpr(_rbexpr.explode)
     end
 
     # Explode a list or utf8 Series.
@@ -2931,7 +2926,7 @@ module Polars
     #   # │ 6   │
     #   # └─────┘
     def explode
-      wrap_expr(_rbexpr.explode)
+      _from_rbexpr(_rbexpr.explode)
     end
 
     # Take every nth value in the Series and return as a new Series.
@@ -2953,7 +2948,7 @@ module Polars
     #   # │ 7   │
     #   # └─────┘
     def gather_every(n, offset = 0)
-      wrap_expr(_rbexpr.gather_every(n, offset))
+      _from_rbexpr(_rbexpr.gather_every(n, offset))
     end
     alias_method :take_every, :gather_every
 
@@ -2979,7 +2974,7 @@ module Polars
     #   # │ 3   │
     #   # └─────┘
     def head(n = 10)
-      wrap_expr(_rbexpr.head(n))
+      _from_rbexpr(_rbexpr.head(n))
     end
 
     # Get the last `n` rows.
@@ -3004,7 +2999,7 @@ module Polars
     #   # │ 7   │
     #   # └─────┘
     def tail(n = 10)
-      wrap_expr(_rbexpr.tail(n))
+      _from_rbexpr(_rbexpr.tail(n))
     end
 
     # Get the first `n` rows.
@@ -3019,28 +3014,552 @@ module Polars
       head(n)
     end
 
-    # Raise expression to the power of exponent.
+    # 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`.
+    #
+    # This differs from default `eq` where null values are propagated.
+    #
+    # @param other [Object]
+    #   A literal or expression value to compare with.
     #
     # @return [Expr]
     #
     # @example
-    #   df = Polars::DataFrame.new({"foo" => [1, 2, 3, 4]})
-    #   df.select(Polars.col("foo").pow(3))
+    #   df = Polars::DataFrame.new(
+    #     data={
+    #       "x" => [1.0, 2.0, Float::NAN, 4.0, nil, nil],
+    #       "y" => [2.0, 2.0, Float::NAN, 4.0, 5.0, nil]
+    #     }
+    #   )
+    #   df.with_columns(
+    #     Polars.col("x").eq(Polars.col("y")).alias("x eq y"),
+    #     Polars.col("x").eq_missing(Polars.col("y")).alias("x eq_missing y")
+    #   )
+    #   # =>
+    #   # shape: (6, 4)
+    #   # ┌──────┬──────┬────────┬────────────────┐
+    #   # │ x    ┆ y    ┆ x eq y ┆ x eq_missing y │
+    #   # │ ---  ┆ ---  ┆ ---    ┆ ---            │
+    #   # │ f64  ┆ f64  ┆ bool   ┆ bool           │
+    #   # ╞══════╪══════╪════════╪════════════════╡
+    #   # │ 1.0  ┆ 2.0  ┆ false  ┆ false          │
+    #   # │ 2.0  ┆ 2.0  ┆ true   ┆ true           │
+    #   # │ NaN  ┆ NaN  ┆ true   ┆ true           │
+    #   # │ 4.0  ┆ 4.0  ┆ true   ┆ true           │
+    #   # │ null ┆ 5.0  ┆ null   ┆ false          │
+    #   # │ null ┆ null ┆ null   ┆ true           │
+    #   # └──────┴──────┴────────┴────────────────┘
+    def eq_missing(other)
+      other = Utils.parse_as_expression(other, str_as_lit: true)
+      _from_rbexpr(_rbexpr.eq_missing(other))
+    end
+
+    # Method equivalent of "greater than or equal" operator `expr >= other`.
+    #
+    # @param other [Object]
+    #     A literal or expression value to compare with.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "x" => [5.0, 4.0, Float::NAN, 2.0],
+    #       "y" => [5.0, 3.0, Float::NAN, 1.0]
+    #     }
+    #   )
+    #   df.with_columns(
+    #     Polars.col("x").ge(Polars.col("y")).alias("x >= y")
+    #   )
+    #   # =>
+    #   # shape: (4, 3)
+    #   # ┌─────┬─────┬────────┐
+    #   # │ x   ┆ y   ┆ x >= y │
+    #   # │ --- ┆ --- ┆ ---    │
+    #   # │ f64 ┆ f64 ┆ bool   │
+    #   # ╞═════╪═════╪════════╡
+    #   # │ 5.0 ┆ 5.0 ┆ true   │
+    #   # │ 4.0 ┆ 3.0 ┆ true   │
+    #   # │ NaN ┆ NaN ┆ true   │
+    #   # │ 2.0 ┆ 1.0 ┆ true   │
+    #   # └─────┴─────┴────────┘
+    def ge(other)
+      self >= other
+    end
+
+    # Method equivalent of "greater than" operator `expr > other`.
+    #
+    # @param other [Object]
+    #   A literal or expression value to compare with.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "x" => [5.0, 4.0, Float::NAN, 2.0],
+    #       "y" => [5.0, 3.0, Float::NAN, 1.0]
+    #     }
+    #   )
+    #   df.with_columns(
+    #       Polars.col("x").gt(Polars.col("y")).alias("x > y")
+    #   )
+    #   # =>
+    #   # shape: (4, 3)
+    #   # ┌─────┬─────┬───────┐
+    #   # │ x   ┆ y   ┆ x > y │
+    #   # │ --- ┆ --- ┆ ---   │
+    #   # │ f64 ┆ f64 ┆ bool  │
+    #   # ╞═════╪═════╪═══════╡
+    #   # │ 5.0 ┆ 5.0 ┆ false │
+    #   # │ 4.0 ┆ 3.0 ┆ true  │
+    #   # │ NaN ┆ NaN ┆ false │
+    #   # │ 2.0 ┆ 1.0 ┆ true  │
+    #   # └─────┴─────┴───────┘
+    def gt(other)
+      self > other
+    end
+
+    # Method equivalent of "less than or equal" operator `expr <= other`.
+    #
+    # @param other [Object]
+    #   A literal or expression value to compare with.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "x" => [5.0, 4.0, Float::NAN, 0.5],
+    #       "y" => [5.0, 3.5, Float::NAN, 2.0]
+    #     }
+    #   )
+    #   df.with_columns(
+    #     Polars.col("x").le(Polars.col("y")).alias("x <= y")
+    #   )
+    #   # =>
+    #   # shape: (4, 3)
+    #   # ┌─────┬─────┬────────┐
+    #   # │ x   ┆ y   ┆ x <= y │
+    #   # │ --- ┆ --- ┆ ---    │
+    #   # │ f64 ┆ f64 ┆ bool   │
+    #   # ╞═════╪═════╪════════╡
+    #   # │ 5.0 ┆ 5.0 ┆ true   │
+    #   # │ 4.0 ┆ 3.5 ┆ false  │
+    #   # │ NaN ┆ NaN ┆ true   │
+    #   # │ 0.5 ┆ 2.0 ┆ true   │
+    #   # └─────┴─────┴────────┘
+    def le(other)
+      self <= other
+    end
+
+    # Method equivalent of "less than" 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, 3.0],
+    #       "y" => [2.0, 2.0, Float::NAN, 4.0]
+    #     }
+    #   )
+    #   df.with_columns(
+    #     Polars.col("x").lt(Polars.col("y")).alias("x < y"),
+    #   )
+    #   # =>
+    #   # shape: (4, 3)
+    #   # ┌─────┬─────┬───────┐
+    #   # │ x   ┆ y   ┆ x < y │
+    #   # │ --- ┆ --- ┆ ---   │
+    #   # │ f64 ┆ f64 ┆ bool  │
+    #   # ╞═════╪═════╪═══════╡
+    #   # │ 1.0 ┆ 2.0 ┆ true  │
+    #   # │ 2.0 ┆ 2.0 ┆ false │
+    #   # │ NaN ┆ NaN ┆ false │
+    #   # │ 3.0 ┆ 4.0 ┆ true  │
+    #   # └─────┴─────┴───────┘
+    def lt(other)
+      self < other
+    end
+
+    # Method equivalent of inequality 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").ne(Polars.col("y")).alias("x != y"),
+    #   )
+    #   # =>
+    #   # shape: (4, 3)
+    #   # ┌─────┬─────┬────────┐
+    #   # │ x   ┆ y   ┆ x != y │
+    #   # │ --- ┆ --- ┆ ---    │
+    #   # │ f64 ┆ f64 ┆ bool   │
+    #   # ╞═════╪═════╪════════╡
+    #   # │ 1.0 ┆ 2.0 ┆ true   │
+    #   # │ 2.0 ┆ 2.0 ┆ false  │
+    #   # │ NaN ┆ NaN ┆ false  │
+    #   # │ 4.0 ┆ 4.0 ┆ false  │
+    #   # └─────┴─────┴────────┘
+    def ne(other)
+      self != other
+    end
+
+    # Method equivalent of equality operator `expr != other` where `None == None`.
+    #
+    # This differs from default `ne` where null values are propagated.
+    #
+    # @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, nil, nil],
+    #       "y" => [2.0, 2.0, Float::NAN, 4.0, 5.0, nil]
+    #     }
+    #   )
+    #   df.with_columns(
+    #     Polars.col("x").ne(Polars.col("y")).alias("x ne y"),
+    #     Polars.col("x").ne_missing(Polars.col("y")).alias("x ne_missing y")
+    #   )
+    #   # =>
+    #   # shape: (6, 4)
+    #   # ┌──────┬──────┬────────┬────────────────┐
+    #   # │ x    ┆ y    ┆ x ne y ┆ x ne_missing y │
+    #   # │ ---  ┆ ---  ┆ ---    ┆ ---            │
+    #   # │ f64  ┆ f64  ┆ bool   ┆ bool           │
+    #   # ╞══════╪══════╪════════╪════════════════╡
+    #   # │ 1.0  ┆ 2.0  ┆ true   ┆ true           │
+    #   # │ 2.0  ┆ 2.0  ┆ false  ┆ false          │
+    #   # │ NaN  ┆ NaN  ┆ false  ┆ false          │
+    #   # │ 4.0  ┆ 4.0  ┆ false  ┆ false          │
+    #   # │ null ┆ 5.0  ┆ null   ┆ true           │
+    #   # │ null ┆ null ┆ null   ┆ false          │
+    #   # └──────┴──────┴────────┴────────────────┘
+    def ne_missing(other)
+      other = Utils.parse_as_expression(other, str_as_lit: true)
+      _from_rbexpr(_rbexpr.neq_missing(other))
+    end
+
+    # Method equivalent of addition operator `expr + other`.
+    #
+    # @param other [Object]
+    #   numeric or string value; accepts expression input.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"x" => [1, 2, 3, 4, 5]})
+    #   df.with_columns(
+    #     Polars.col("x").add(2).alias("x+int"),
+    #     Polars.col("x").add(Polars.col("x").cum_prod).alias("x+expr")
+    #   )
+    #   # =>
+    #   # shape: (5, 3)
+    #   # ┌─────┬───────┬────────┐
+    #   # │ x   ┆ x+int ┆ x+expr │
+    #   # │ --- ┆ ---   ┆ ---    │
+    #   # │ i64 ┆ i64   ┆ i64    │
+    #   # ╞═════╪═══════╪════════╡
+    #   # │ 1   ┆ 3     ┆ 2      │
+    #   # │ 2   ┆ 4     ┆ 4      │
+    #   # │ 3   ┆ 5     ┆ 9      │
+    #   # │ 4   ┆ 6     ┆ 28     │
+    #   # │ 5   ┆ 7     ┆ 125    │
+    #   # └─────┴───────┴────────┘
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {"x" => ["a", "d", "g"], "y": ["b", "e", "h"], "z": ["c", "f", "i"]}
+    #   )
+    #   df.with_columns(Polars.col("x").add(Polars.col("y")).add(Polars.col("z")).alias("xyz"))
+    #   # =>
+    #   # shape: (3, 4)
+    #   # ┌─────┬─────┬─────┬─────┐
+    #   # │ x   ┆ y   ┆ z   ┆ xyz │
+    #   # │ --- ┆ --- ┆ --- ┆ --- │
+    #   # │ str ┆ str ┆ str ┆ str │
+    #   # ╞═════╪═════╪═════╪═════╡
+    #   # │ a   ┆ b   ┆ c   ┆ abc │
+    #   # │ d   ┆ e   ┆ f   ┆ def │
+    #   # │ g   ┆ h   ┆ i   ┆ ghi │
+    #   # └─────┴─────┴─────┴─────┘
+    def add(other)
+      self + other
+    end
+
+    # Method equivalent of integer division operator `expr // other`.
+    #
+    # @param other [Object]
+    #   Numeric literal or expression value.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"x" => [1, 2, 3, 4, 5]})
+    #   df.with_columns(
+    #     Polars.col("x").truediv(2).alias("x/2"),
+    #     Polars.col("x").floordiv(2).alias("x//2")
+    #   )
+    #   # =>
+    #   # shape: (5, 3)
+    #   # ┌─────┬─────┬──────┐
+    #   # │ x   ┆ x/2 ┆ x//2 │
+    #   # │ --- ┆ --- ┆ ---  │
+    #   # │ i64 ┆ f64 ┆ i64  │
+    #   # ╞═════╪═════╪══════╡
+    #   # │ 1   ┆ 0.5 ┆ 0    │
+    #   # │ 2   ┆ 1.0 ┆ 1    │
+    #   # │ 3   ┆ 1.5 ┆ 1    │
+    #   # │ 4   ┆ 2.0 ┆ 2    │
+    #   # │ 5   ┆ 2.5 ┆ 2    │
+    #   # └─────┴─────┴──────┘
+    def floordiv(other)
+      _from_rbexpr(_rbexpr.floordiv(_to_rbexpr(other)))
+    end
+
+    # Method equivalent of modulus operator `expr % other`.
+    #
+    # @param other [Object]
+    #   Numeric literal or expression value.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"x" => [0, 1, 2, 3, 4]})
+    #   df.with_columns(Polars.col("x").mod(2).alias("x%2"))
+    #   # =>
+    #   # shape: (5, 2)
+    #   # ┌─────┬─────┐
+    #   # │ x   ┆ x%2 │
+    #   # │ --- ┆ --- │
+    #   # │ i64 ┆ i64 │
+    #   # ╞═════╪═════╡
+    #   # │ 0   ┆ 0   │
+    #   # │ 1   ┆ 1   │
+    #   # │ 2   ┆ 0   │
+    #   # │ 3   ┆ 1   │
+    #   # │ 4   ┆ 0   │
+    #   # └─────┴─────┘
+    def mod(other)
+      self % other
+    end
+
+    # Method equivalent of multiplication operator `expr * other`.
+    #
+    # @param other [Object]
+    #   Numeric literal or expression value.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"x" => [1, 2, 4, 8, 16]})
+    #   df.with_columns(
+    #     Polars.col("x").mul(2).alias("x*2"),
+    #     Polars.col("x").mul(Polars.col("x").log(2)).alias("x * xlog2"),
+    #   )
+    #   # =>
+    #   # shape: (5, 3)
+    #   # ┌─────┬─────┬───────────┐
+    #   # │ x   ┆ x*2 ┆ x * xlog2 │
+    #   # │ --- ┆ --- ┆ ---       │
+    #   # │ i64 ┆ i64 ┆ f64       │
+    #   # ╞═════╪═════╪═══════════╡
+    #   # │ 1   ┆ 2   ┆ 0.0       │
+    #   # │ 2   ┆ 4   ┆ 2.0       │
+    #   # │ 4   ┆ 8   ┆ 8.0       │
+    #   # │ 8   ┆ 16  ┆ 24.0      │
+    #   # │ 16  ┆ 32  ┆ 64.0      │
+    #   # └─────┴─────┴───────────┘
+    def mul(other)
+      self * other
+    end
+
+    # Method equivalent of subtraction operator `expr - other`.
+    #
+    # @param other [Object]
+    #   Numeric literal or expression value.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"x" => [0, 1, 2, 3, 4]})
+    #   df.with_columns(
+    #     Polars.col("x").sub(2).alias("x-2"),
+    #     Polars.col("x").sub(Polars.col("x").cum_sum).alias("x-expr"),
+    #   )
+    #   # =>
+    #   # shape: (5, 3)
+    #   # ┌─────┬─────┬────────┐
+    #   # │ x   ┆ x-2 ┆ x-expr │
+    #   # │ --- ┆ --- ┆ ---    │
+    #   # │ i64 ┆ i64 ┆ i64    │
+    #   # ╞═════╪═════╪════════╡
+    #   # │ 0   ┆ -2  ┆ 0      │
+    #   # │ 1   ┆ -1  ┆ 0      │
+    #   # │ 2   ┆ 0   ┆ -1     │
+    #   # │ 3   ┆ 1   ┆ -3     │
+    #   # │ 4   ┆ 2   ┆ -6     │
+    #   # └─────┴─────┴────────┘
+    def sub(other)
+      self - other
+    end
+
+    # Method equivalent of unary minus operator `-expr`.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"a" => [-1, 0, 2, nil]})
+    #   df.with_columns(Polars.col("a").neg)
     #   # =>
     #   # shape: (4, 1)
     #   # ┌──────┐
-    #   # │ foo  │
+    #   # │ a    │
     #   # │ ---  │
-    #   # │ f64  │
+    #   # │ i64  │
     #   # ╞══════╡
-    #   # │ 1.0  │
-    #   # │ 8.0  │
-    #   # │ 27.0 │
-    #   # │ 64.0 │
+    #   # │ 1    │
+    #   # │ 0    │
+    #   # │ -2   │
+    #   # │ null │
     #   # └──────┘
+    def neg
+      -self
+    end
+
+    # Method equivalent of float division operator `expr / other`.
+    #
+    # @param other [Object]
+    #   Numeric literal or expression value.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {"x" => [-2, -1, 0, 1, 2], "y" => [0.5, 0.0, 0.0, -4.0, -0.5]}
+    #   )
+    #   df.with_columns(
+    #     Polars.col("x").truediv(2).alias("x/2"),
+    #     Polars.col("x").truediv(Polars.col("y")).alias("x/y")
+    #   )
+    #   # =>
+    #   # shape: (5, 4)
+    #   # ┌─────┬──────┬──────┬───────┐
+    #   # │ x   ┆ y    ┆ x/2  ┆ x/y   │
+    #   # │ --- ┆ ---  ┆ ---  ┆ ---   │
+    #   # │ i64 ┆ f64  ┆ f64  ┆ f64   │
+    #   # ╞═════╪══════╪══════╪═══════╡
+    #   # │ -2  ┆ 0.5  ┆ -1.0 ┆ -4.0  │
+    #   # │ -1  ┆ 0.0  ┆ -0.5 ┆ -inf  │
+    #   # │ 0   ┆ 0.0  ┆ 0.0  ┆ NaN   │
+    #   # │ 1   ┆ -4.0 ┆ 0.5  ┆ -0.25 │
+    #   # │ 2   ┆ -0.5 ┆ 1.0  ┆ -4.0  │
+    #   # └─────┴──────┴──────┴───────┘
+    def truediv(other)
+      self / other
+    end
+
+    # Raise expression to the power of exponent.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"x" => [1, 2, 4, 8]})
+    #   df.with_columns(
+    #     Polars.col("x").pow(3).alias("cube"),
+    #     Polars.col("x").pow(Polars.col("x").log(2)).alias("x ** xlog2")
+    #   )
+    #   # =>
+    #   # shape: (4, 3)
+    #   # ┌─────┬──────┬────────────┐
+    #   # │ x   ┆ cube ┆ x ** xlog2 │
+    #   # │ --- ┆ ---  ┆ ---        │
+    #   # │ i64 ┆ i64  ┆ f64        │
+    #   # ╞═════╪══════╪════════════╡
+    #   # │ 1   ┆ 1    ┆ 1.0        │
+    #   # │ 2   ┆ 8    ┆ 2.0        │
+    #   # │ 4   ┆ 64   ┆ 16.0       │
+    #   # │ 8   ┆ 512  ┆ 512.0      │
+    #   # └─────┴──────┴────────────┘
     def pow(exponent)
-      exponent = Utils.expr_to_lit_or_expr(exponent)
-      wrap_expr(_rbexpr.pow(exponent._rbexpr))
+      self**exponent
+    end
+
+    # Method equivalent of bitwise exclusive-or operator `expr ^ other`.
+    #
+    # @param other [Object]
+    #   Integer or boolean value; accepts expression input.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {"x" => [true, false, true, false], "y" => [true, true, false, false]}
+    #   )
+    #   df.with_columns(Polars.col("x").xor(Polars.col("y")).alias("x ^ y"))
+    #   # =>
+    #   # shape: (4, 3)
+    #   # ┌───────┬───────┬───────┐
+    #   # │ x     ┆ y     ┆ x ^ y │
+    #   # │ ---   ┆ ---   ┆ ---   │
+    #   # │ bool  ┆ bool  ┆ bool  │
+    #   # ╞═══════╪═══════╪═══════╡
+    #   # │ true  ┆ true  ┆ false │
+    #   # │ false ┆ true  ┆ true  │
+    #   # │ true  ┆ false ┆ true  │
+    #   # │ false ┆ false ┆ false │
+    #   # └───────┴───────┴───────┘
+    def xor(other)
+      self ^ other
     end
 
     # Check if elements of this expression are present in the other Series.
@@ -3076,7 +3595,7 @@ module Polars
       else
         other = Utils.expr_to_lit_or_expr(other, str_to_lit: false)
       end
-      wrap_expr(_rbexpr.is_in(other._rbexpr))
+      _from_rbexpr(_rbexpr.is_in(other._rbexpr))
     end
     alias_method :in?, :is_in
 
@@ -3112,7 +3631,7 @@ module Polars
     #   # └─────────────────┘
     def repeat_by(by)
       by = Utils.expr_to_lit_or_expr(by, str_to_lit: false)
-      wrap_expr(_rbexpr.repeat_by(by._rbexpr))
+      _from_rbexpr(_rbexpr.repeat_by(by._rbexpr))
     end
 
     # Check if this expression is between start and end.
@@ -3238,7 +3757,7 @@ module Polars
       k1 = seed_1.nil? ? seed : seed_1
       k2 = seed_2.nil? ? seed : seed_2
       k3 = seed_3.nil? ? seed : seed_3
-      wrap_expr(_rbexpr._hash(k0, k1, k2, k3))
+      _from_rbexpr(_rbexpr._hash(k0, k1, k2, k3))
     end
 
     # Reinterpret the underlying bits as a signed/unsigned integer.
@@ -3272,7 +3791,7 @@ module Polars
     #   # │ 2             ┆ 2        │
     #   # └───────────────┴──────────┘
     def reinterpret(signed: false)
-      wrap_expr(_rbexpr.reinterpret(signed))
+      _from_rbexpr(_rbexpr.reinterpret(signed))
     end
 
     # Print the value that this expression evaluates to and pass on the value.
@@ -3335,7 +3854,7 @@ module Polars
     #   # │ 3.0 ┆ 3.0 │
     #   # └─────┴─────┘
     def interpolate(method: "linear")
-      wrap_expr(_rbexpr.interpolate(method))
+      _from_rbexpr(_rbexpr.interpolate(method))
     end
 
     # Apply a rolling min (moving min) over the values in this array.
@@ -3415,12 +3934,12 @@ module Polars
       min_periods: nil,
       center: false,
       by: nil,
-      closed: "left"
+      closed: nil
     )
       window_size, min_periods = _prepare_rolling_window_args(
         window_size, min_periods
       )
-      wrap_expr(
+      _from_rbexpr(
         _rbexpr.rolling_min(
           window_size, weights, min_periods, center, by, closed
         )
@@ -3504,12 +4023,12 @@ module Polars
       min_periods: nil,
       center: false,
       by: nil,
-      closed: "left"
+      closed: nil
     )
       window_size, min_periods = _prepare_rolling_window_args(
         window_size, min_periods
       )
-      wrap_expr(
+      _from_rbexpr(
         _rbexpr.rolling_max(
           window_size, weights, min_periods, center, by, closed
         )
@@ -3593,12 +4112,12 @@ module Polars
       min_periods: nil,
       center: false,
       by: nil,
-      closed: "left"
+      closed: nil
     )
       window_size, min_periods = _prepare_rolling_window_args(
         window_size, min_periods
       )
-      wrap_expr(
+      _from_rbexpr(
         _rbexpr.rolling_mean(
           window_size, weights, min_periods, center, by, closed
         )
@@ -3682,12 +4201,12 @@ module Polars
       min_periods: nil,
       center: false,
       by: nil,
-      closed: "left"
+      closed: nil
     )
       window_size, min_periods = _prepare_rolling_window_args(
         window_size, min_periods
       )
-      wrap_expr(
+      _from_rbexpr(
         _rbexpr.rolling_sum(
           window_size, weights, min_periods, center, by, closed
         )
@@ -3771,14 +4290,14 @@ module Polars
       min_periods: nil,
       center: false,
       by: nil,
-      closed: "left",
+      closed: nil,
       ddof: 1,
       warn_if_unsorted: true
     )
       window_size, min_periods = _prepare_rolling_window_args(
         window_size, min_periods
       )
-      wrap_expr(
+      _from_rbexpr(
         _rbexpr.rolling_std(
           window_size, weights, min_periods, center, by, closed, ddof, warn_if_unsorted
         )
@@ -3862,14 +4381,14 @@ module Polars
       min_periods: nil,
       center: false,
       by: nil,
-      closed: "left",
+      closed: nil,
       ddof: 1,
       warn_if_unsorted: true
     )
       window_size, min_periods = _prepare_rolling_window_args(
         window_size, min_periods
       )
-      wrap_expr(
+      _from_rbexpr(
         _rbexpr.rolling_var(
           window_size, weights, min_periods, center, by, closed, ddof, warn_if_unsorted
         )
@@ -3949,13 +4468,13 @@ module Polars
       min_periods: nil,
       center: false,
       by: nil,
-      closed: "left",
+      closed: nil,
       warn_if_unsorted: true
     )
       window_size, min_periods = _prepare_rolling_window_args(
         window_size, min_periods
       )
-      wrap_expr(
+      _from_rbexpr(
         _rbexpr.rolling_median(
           window_size, weights, min_periods, center, by, closed, warn_if_unsorted
         )
@@ -4041,13 +4560,13 @@ module Polars
       min_periods: nil,
       center: false,
       by: nil,
-      closed: "left",
+      closed: nil,
       warn_if_unsorted: true
     )
       window_size, min_periods = _prepare_rolling_window_args(
         window_size, min_periods
       )
-      wrap_expr(
+      _from_rbexpr(
         _rbexpr.rolling_quantile(
           quantile, interpolation, window_size, weights, min_periods, center, by, closed, warn_if_unsorted
         )
@@ -4111,7 +4630,7 @@ module Polars
     #   if min_periods.nil?
     #     min_periods = window_size
     #   end
-    #   wrap_expr(
+    #   _from_rbexpr(
     #     _rbexpr.rolling_apply(
     #       function, window_size, weights, min_periods, center
     #     )
@@ -4127,7 +4646,7 @@ module Polars
     #
     # @return [Expr]
     def rolling_skew(window_size, bias: true)
-      wrap_expr(_rbexpr.rolling_skew(window_size, bias))
+      _from_rbexpr(_rbexpr.rolling_skew(window_size, bias))
     end
 
     # Compute absolute values.
@@ -4154,7 +4673,7 @@ module Polars
     #   # │ 2.0 │
     #   # └─────┘
     def abs
-      wrap_expr(_rbexpr.abs)
+      _from_rbexpr(_rbexpr.abs)
     end
 
     # Get the index values that would sort this column.
@@ -4212,6 +4731,8 @@ module Polars
     #     on the order that the values occur in the Series.
     # @param reverse [Boolean]
     #   Reverse the operation.
+    # @param seed [Integer]
+    #   If `method: "random"`, use this as seed.
     #
     # @return [Expr]
     #
@@ -4249,7 +4770,7 @@ module Polars
     #   # │ 5   │
     #   # └─────┘
     def rank(method: "average", reverse: false, seed: nil)
-      wrap_expr(_rbexpr.rank(method, reverse, seed))
+      _from_rbexpr(_rbexpr.rank(method, reverse, seed))
     end
 
     # Calculate the n-th discrete difference.
@@ -4280,7 +4801,7 @@ module Polars
     #   # │ 20   │
     #   # └──────┘
     def diff(n: 1, null_behavior: "ignore")
-      wrap_expr(_rbexpr.diff(n, null_behavior))
+      _from_rbexpr(_rbexpr.diff(n, null_behavior))
     end
 
     # Computes percentage change between values.
@@ -4317,7 +4838,7 @@ module Polars
     #   # └──────┴────────────┘
     def pct_change(n: 1)
       n = Utils.parse_as_expression(n)
-      wrap_expr(_rbexpr.pct_change(n))
+      _from_rbexpr(_rbexpr.pct_change(n))
     end
 
     # Compute the sample skewness of a data set.
@@ -4346,7 +4867,7 @@ module Polars
     #   # │ 0.343622 │
     #   # └──────────┘
     def skew(bias: true)
-      wrap_expr(_rbexpr.skew(bias))
+      _from_rbexpr(_rbexpr.skew(bias))
     end
 
     # Compute the kurtosis (Fisher or Pearson) of a dataset.
@@ -4378,7 +4899,7 @@ module Polars
     #   # │ -1.153061 │
     #   # └───────────┘
     def kurtosis(fisher: true, bias: true)
-      wrap_expr(_rbexpr.kurtosis(fisher, bias))
+      _from_rbexpr(_rbexpr.kurtosis(fisher, bias))
     end
 
     # Set values outside the given boundaries to the boundary value.
@@ -4415,7 +4936,7 @@ module Polars
       if !upper_bound.nil?
         upper_bound = Utils.parse_as_expression(upper_bound, str_as_lit: true)
       end
-      wrap_expr(_rbexpr.clip(lower_bound, upper_bound))
+      _from_rbexpr(_rbexpr.clip(lower_bound, upper_bound))
     end
 
     # Clip (limit) the values in an array to a `min` boundary.
@@ -4500,7 +5021,7 @@ module Polars
     #   # │ -9223372036854775808 │
     #   # └──────────────────────┘
     def lower_bound
-      wrap_expr(_rbexpr.lower_bound)
+      _from_rbexpr(_rbexpr.lower_bound)
     end
 
     # Calculate the upper bound.
@@ -4523,7 +5044,7 @@ module Polars
     #   # │ 9223372036854775807 │
     #   # └─────────────────────┘
     def upper_bound
-      wrap_expr(_rbexpr.upper_bound)
+      _from_rbexpr(_rbexpr.upper_bound)
     end
 
     # Compute the element-wise indication of the sign.
@@ -4547,7 +5068,7 @@ module Polars
     #   # │ null │
     #   # └──────┘
     def sign
-      wrap_expr(_rbexpr.sign)
+      _from_rbexpr(_rbexpr.sign)
     end
 
     # Compute the element-wise value for the sine.
@@ -4567,7 +5088,7 @@ module Polars
     #   # │ 0.0 │
     #   # └─────┘
     def sin
-      wrap_expr(_rbexpr.sin)
+      _from_rbexpr(_rbexpr.sin)
     end
 
     # Compute the element-wise value for the cosine.
@@ -4587,7 +5108,7 @@ module Polars
     #   # │ 1.0 │
     #   # └─────┘
     def cos
-      wrap_expr(_rbexpr.cos)
+      _from_rbexpr(_rbexpr.cos)
     end
 
     # Compute the element-wise value for the tangent.
@@ -4607,7 +5128,7 @@ module Polars
     #   # │ 1.557408 │
     #   # └──────────┘
     def tan
-      wrap_expr(_rbexpr.tan)
+      _from_rbexpr(_rbexpr.tan)
     end
 
     # Compute the element-wise value for the inverse sine.
@@ -4627,7 +5148,7 @@ module Polars
     #   # │ 1.570796 │
     #   # └──────────┘
     def arcsin
-      wrap_expr(_rbexpr.arcsin)
+      _from_rbexpr(_rbexpr.arcsin)
     end
 
     # Compute the element-wise value for the inverse cosine.
@@ -4647,7 +5168,7 @@ module Polars
     #   # │ 1.570796 │
     #   # └──────────┘
     def arccos
-      wrap_expr(_rbexpr.arccos)
+      _from_rbexpr(_rbexpr.arccos)
     end
 
     # Compute the element-wise value for the inverse tangent.
@@ -4667,7 +5188,7 @@ module Polars
     #   # │ 0.785398 │
     #   # └──────────┘
     def arctan
-      wrap_expr(_rbexpr.arctan)
+      _from_rbexpr(_rbexpr.arctan)
     end
 
     # Compute the element-wise value for the hyperbolic sine.
@@ -4687,7 +5208,7 @@ module Polars
     #   # │ 1.175201 │
     #   # └──────────┘
     def sinh
-      wrap_expr(_rbexpr.sinh)
+      _from_rbexpr(_rbexpr.sinh)
     end
 
     # Compute the element-wise value for the hyperbolic cosine.
@@ -4707,7 +5228,7 @@ module Polars
     #   # │ 1.543081 │
     #   # └──────────┘
     def cosh
-      wrap_expr(_rbexpr.cosh)
+      _from_rbexpr(_rbexpr.cosh)
     end
 
     # Compute the element-wise value for the hyperbolic tangent.
@@ -4727,7 +5248,7 @@ module Polars
     #   # │ 0.761594 │
     #   # └──────────┘
     def tanh
-      wrap_expr(_rbexpr.tanh)
+      _from_rbexpr(_rbexpr.tanh)
     end
 
     # Compute the element-wise value for the inverse hyperbolic sine.
@@ -4747,7 +5268,7 @@ module Polars
     #   # │ 0.881374 │
     #   # └──────────┘
     def arcsinh
-      wrap_expr(_rbexpr.arcsinh)
+      _from_rbexpr(_rbexpr.arcsinh)
     end
 
     # Compute the element-wise value for the inverse hyperbolic cosine.
@@ -4767,7 +5288,7 @@ module Polars
     #   # │ 0.0 │
     #   # └─────┘
     def arccosh
-      wrap_expr(_rbexpr.arccosh)
+      _from_rbexpr(_rbexpr.arccosh)
     end
 
     # Compute the element-wise value for the inverse hyperbolic tangent.
@@ -4787,7 +5308,7 @@ module Polars
     #   # │ inf │
     #   # └─────┘
     def arctanh
-      wrap_expr(_rbexpr.arctanh)
+      _from_rbexpr(_rbexpr.arctanh)
     end
 
     # Reshape this Expr to a flat Series or a Series of Lists.
@@ -4813,7 +5334,7 @@ module Polars
     #   # │ [7, 8, 9] │
     #   # └───────────┘
     def reshape(dims)
-      wrap_expr(_rbexpr.reshape(dims))
+      _from_rbexpr(_rbexpr.reshape(dims))
     end
 
     # Shuffle the contents of this expr.
@@ -4842,7 +5363,7 @@ module Polars
       if seed.nil?
         seed = rand(10000)
       end
-      wrap_expr(_rbexpr.shuffle(seed))
+      _from_rbexpr(_rbexpr.shuffle(seed))
     end
 
     # Sample from this expression.
@@ -4888,14 +5409,14 @@ module Polars
 
       if !n.nil? && frac.nil?
         n = Utils.parse_as_expression(n)
-        return wrap_expr(_rbexpr.sample_n(n, with_replacement, shuffle, seed))
+        return _from_rbexpr(_rbexpr.sample_n(n, with_replacement, shuffle, seed))
       end
 
       if frac.nil?
         frac = 1.0
       end
       frac = Utils.parse_as_expression(frac)
-      wrap_expr(
+      _from_rbexpr(
         _rbexpr.sample_frac(frac, with_replacement, shuffle, seed)
       )
     end
@@ -4928,7 +5449,7 @@ module Polars
       ignore_nulls: true
     )
       alpha = _prepare_alpha(com, span, half_life, alpha)
-      wrap_expr(_rbexpr.ewm_mean(alpha, adjust, min_periods, ignore_nulls))
+      _from_rbexpr(_rbexpr.ewm_mean(alpha, adjust, min_periods, ignore_nulls))
     end
 
     # Exponentially-weighted moving standard deviation.
@@ -4960,7 +5481,7 @@ module Polars
       ignore_nulls: true
     )
       alpha = _prepare_alpha(com, span, half_life, alpha)
-      wrap_expr(_rbexpr.ewm_std(alpha, adjust, bias, min_periods, ignore_nulls))
+      _from_rbexpr(_rbexpr.ewm_std(alpha, adjust, bias, min_periods, ignore_nulls))
     end
 
     # Exponentially-weighted moving variance.
@@ -4992,7 +5513,7 @@ module Polars
       ignore_nulls: true
     )
       alpha = _prepare_alpha(com, span, half_life, alpha)
-      wrap_expr(_rbexpr.ewm_var(alpha, adjust, bias, min_periods, ignore_nulls))
+      _from_rbexpr(_rbexpr.ewm_var(alpha, adjust, bias, min_periods, ignore_nulls))
     end
 
     # Extend the Series with given number of values.
@@ -5022,7 +5543,7 @@ module Polars
     #   # │ 99     │
     #   # └────────┘
     def extend_constant(value, n)
-      wrap_expr(_rbexpr.extend_constant(value, n))
+      _from_rbexpr(_rbexpr.extend_constant(value, n))
     end
 
     # Count all unique values and create a struct mapping value to count.
@@ -5058,7 +5579,7 @@ module Polars
     #   # │ {"a",1}   │
     #   # └───────────┘
     def value_counts(multithreaded: false, sort: false)
-      wrap_expr(_rbexpr.value_counts(multithreaded, sort))
+      _from_rbexpr(_rbexpr.value_counts(multithreaded, sort))
     end
 
     # Return a count of the unique values in the order of appearance.
@@ -5091,7 +5612,7 @@ module Polars
     #   # │ 3   │
     #   # └─────┘
     def unique_counts
-      wrap_expr(_rbexpr.unique_counts)
+      _from_rbexpr(_rbexpr.unique_counts)
     end
 
     # Compute the logarithm to a given base.
@@ -5116,7 +5637,7 @@ module Polars
     #   # │ 1.584963 │
     #   # └──────────┘
     def log(base = Math::E)
-      wrap_expr(_rbexpr.log(base))
+      _from_rbexpr(_rbexpr.log(base))
     end
 
     # Computes the entropy.
@@ -5155,7 +5676,7 @@ module Polars
     #   # │ -6.754888 │
     #   # └───────────┘
     def entropy(base: 2, normalize: true)
-      wrap_expr(_rbexpr.entropy(base, normalize))
+      _from_rbexpr(_rbexpr.entropy(base, normalize))
     end
 
     # Run an expression over a sliding window that increases `1` slot every iteration.
@@ -5193,16 +5714,16 @@ module Polars
     #   # ┌────────┐
     #   # │ values │
     #   # │ ---    │
-    #   # │ f64    │
+    #   # │ i64    │
     #   # ╞════════╡
-    #   # │ 0.0    │
-    #   # │ -3.0   │
-    #   # │ -8.0   │
-    #   # │ -15.0  │
-    #   # │ -24.0  │
+    #   # │ 0      │
+    #   # │ -3     │
+    #   # │ -8     │
+    #   # │ -15    │
+    #   # │ -24    │
     #   # └────────┘
     def cumulative_eval(expr, min_periods: 1, parallel: false)
-      wrap_expr(
+      _from_rbexpr(
         _rbexpr.cumulative_eval(expr._rbexpr, min_periods, parallel)
       )
     end
@@ -5233,7 +5754,7 @@ module Polars
     #   # │ 3      │
     #   # └────────┘
     def set_sorted(descending: false)
-      wrap_expr(_rbexpr.set_sorted_flag(descending))
+      _from_rbexpr(_rbexpr.set_sorted_flag(descending))
     end
 
     # Aggregate to list.
@@ -5258,7 +5779,7 @@ module Polars
     #   # │ [1, 2, 3] ┆ [4, 5, 6] │
     #   # └───────────┴───────────┘
     def implode
-      wrap_expr(_rbexpr.implode)
+      _from_rbexpr(_rbexpr.implode)
     end
 
     # Shrink numeric columns to the minimal required datatype.
@@ -5293,7 +5814,169 @@ module Polars
     #   # │ 3   ┆ 8589934592 ┆ 1073741824 ┆ 112  ┆ 129  ┆ c   ┆ 0.12 ┆ false │
     #   # └─────┴────────────┴────────────┴──────┴──────┴─────┴──────┴───────┘
     def shrink_dtype
-      wrap_expr(_rbexpr.shrink_dtype)
+      _from_rbexpr(_rbexpr.shrink_dtype)
+    end
+
+    # Replace values by different values.
+    #
+    # @param old [Object]
+    #   Value or sequence of values to replace.
+    #   Accepts expression input. Sequences are parsed as Series,
+    #   other non-expression inputs are parsed as literals.
+    #   Also accepts a mapping of values to their replacement.
+    # @param new [Object]
+    #   Value or sequence of values to replace by.
+    #   Accepts expression input. Sequences are parsed as Series,
+    #   other non-expression inputs are parsed as literals.
+    #   Length must match the length of `old` or have length 1.
+    # @param default [Object]
+    #   Set values that were not replaced to this value.
+    #   Defaults to keeping the original value.
+    #   Accepts expression input. Non-expression inputs are parsed as literals.
+    # @param return_dtype [Object]
+    #   The data type of the resulting expression. If set to `nil` (default),
+    #   the data type is determined automatically based on the other inputs.
+    #
+    # @return [Expr]
+    #
+    # @example Replace a single value by another value. Values that were not replaced remain unchanged.
+    #   df = Polars::DataFrame.new({"a" => [1, 2, 2, 3]})
+    #   df.with_columns(replaced: Polars.col("a").replace(2, 100))
+    #   # =>
+    #   # shape: (4, 2)
+    #   # ┌─────┬──────────┐
+    #   # │ a   ┆ replaced │
+    #   # │ --- ┆ ---      │
+    #   # │ i64 ┆ i64      │
+    #   # ╞═════╪══════════╡
+    #   # │ 1   ┆ 1        │
+    #   # │ 2   ┆ 100      │
+    #   # │ 2   ┆ 100      │
+    #   # │ 3   ┆ 3        │
+    #   # └─────┴──────────┘
+    #
+    # @example Replace multiple values by passing sequences to the `old` and `new` parameters.
+    #   df.with_columns(replaced: Polars.col("a").replace([2, 3], [100, 200]))
+    #   # =>
+    #   # shape: (4, 2)
+    #   # ┌─────┬──────────┐
+    #   # │ a   ┆ replaced │
+    #   # │ --- ┆ ---      │
+    #   # │ i64 ┆ i64      │
+    #   # ╞═════╪══════════╡
+    #   # │ 1   ┆ 1        │
+    #   # │ 2   ┆ 100      │
+    #   # │ 2   ┆ 100      │
+    #   # │ 3   ┆ 200      │
+    #   # └─────┴──────────┘
+    #
+    # @example Passing a mapping with replacements is also supported as syntactic sugar. Specify a default to set all values that were not matched.
+    #   mapping = {2 => 100, 3 => 200}
+    #   df.with_columns(replaced: Polars.col("a").replace(mapping, default: -1))
+    #   # =>
+    #   # shape: (4, 2)
+    #   # ┌─────┬──────────┐
+    #   # │ a   ┆ replaced │
+    #   # │ --- ┆ ---      │
+    #   # │ i64 ┆ i64      │
+    #   # ╞═════╪══════════╡
+    #   # │ 1   ┆ -1       │
+    #   # │ 2   ┆ 100      │
+    #   # │ 2   ┆ 100      │
+    #   # │ 3   ┆ 200      │
+    #   # └─────┴──────────┘
+    #
+    # @example Replacing by values of a different data type sets the return type based on a combination of the `new` data type and either the original data type or the default data type if it was set.
+    #   df = Polars::DataFrame.new({"a" => ["x", "y", "z"]})
+    #   mapping = {"x" => 1, "y" => 2, "z" => 3}
+    #   df.with_columns(replaced: Polars.col("a").replace(mapping))
+    #   # =>
+    #   # shape: (3, 2)
+    #   # ┌─────┬──────────┐
+    #   # │ a   ┆ replaced │
+    #   # │ --- ┆ ---      │
+    #   # │ str ┆ str      │
+    #   # ╞═════╪══════════╡
+    #   # │ x   ┆ 1        │
+    #   # │ y   ┆ 2        │
+    #   # │ z   ┆ 3        │
+    #   # └─────┴──────────┘
+    #
+    # @example
+    #   df.with_columns(replaced: Polars.col("a").replace(mapping, default: nil))
+    #   # =>
+    #   # shape: (3, 2)
+    #   # ┌─────┬──────────┐
+    #   # │ a   ┆ replaced │
+    #   # │ --- ┆ ---      │
+    #   # │ str ┆ i64      │
+    #   # ╞═════╪══════════╡
+    #   # │ x   ┆ 1        │
+    #   # │ y   ┆ 2        │
+    #   # │ z   ┆ 3        │
+    #   # └─────┴──────────┘
+    #
+    # @example Set the `return_dtype` parameter to control the resulting data type directly.
+    #   df.with_columns(
+    #     replaced: Polars.col("a").replace(mapping, return_dtype: Polars::UInt8)
+    #   )
+    #   # =>
+    #   # shape: (3, 2)
+    #   # ┌─────┬──────────┐
+    #   # │ a   ┆ replaced │
+    #   # │ --- ┆ ---      │
+    #   # │ str ┆ u8       │
+    #   # ╞═════╪══════════╡
+    #   # │ x   ┆ 1        │
+    #   # │ y   ┆ 2        │
+    #   # │ z   ┆ 3        │
+    #   # └─────┴──────────┘
+    #
+    # @example Expression input is supported for all parameters.
+    #   df = Polars::DataFrame.new({"a" => [1, 2, 2, 3], "b" => [1.5, 2.5, 5.0, 1.0]})
+    #   df.with_columns(
+    #     replaced: Polars.col("a").replace(
+    #       Polars.col("a").max,
+    #       Polars.col("b").sum,
+    #       default: Polars.col("b")
+    #     )
+    #   )
+    #   # =>
+    #   # shape: (4, 3)
+    #   # ┌─────┬─────┬──────────┐
+    #   # │ a   ┆ b   ┆ replaced │
+    #   # │ --- ┆ --- ┆ ---      │
+    #   # │ i64 ┆ f64 ┆ f64      │
+    #   # ╞═════╪═════╪══════════╡
+    #   # │ 1   ┆ 1.5 ┆ 1.5      │
+    #   # │ 2   ┆ 2.5 ┆ 2.5      │
+    #   # │ 2   ┆ 5.0 ┆ 5.0      │
+    #   # │ 3   ┆ 1.0 ┆ 10.0     │
+    #   # └─────┴─────┴──────────┘
+    def replace(old, new = NO_DEFAULT, default: NO_DEFAULT, return_dtype: nil)
+      if new.eql?(NO_DEFAULT) && old.is_a?(Hash)
+        new = Series.new(old.values)
+        old = Series.new(old.keys)
+      else
+        if old.is_a?(::Array)
+          old = Series.new(old)
+        end
+        if new.is_a?(::Array)
+          new = Series.new(new)
+        end
+      end
+
+      old = Utils.parse_as_expression(old, str_as_lit: true)
+      new = Utils.parse_as_expression(new, str_as_lit: true)
+
+      default =
+        if default.eql?(NO_DEFAULT)
+          nil
+        else
+          Utils.parse_as_expression(default, str_as_lit: true)
+        end
+
+      _from_rbexpr(_rbexpr.replace(old, new, default, return_dtype))
     end
 
     # Create an object namespace of all list related methods.
@@ -5361,7 +6044,7 @@ module Polars
 
     private
 
-    def wrap_expr(expr)
+    def _from_rbexpr(expr)
       Utils.wrap_expr(expr)
     end