polars-df 0.7.0-x86_64-darwin → 0.9.0-x86_64-darwin

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
@@ -366,22 +363,22 @@ module Polars
     #   # │ 3   ┆ 1.5  │
     #   # └─────┴──────┘
     def exclude(columns)
-      if columns.is_a?(String)
+      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) }
+      if !columns.all? { |a| a.is_a?(::String) } || !columns.all? { |a| Utils.is_polars_dtype(a) }
         raise ArgumentError, "input should be all string or all DataType"
       end
 
-      if columns[0].is_a?(String)
-        wrap_expr(_rbexpr.exclude(columns))
+      if columns[0].is_a?(::String)
+        _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,16 +716,14 @@ module Polars
     #   # │ --- ┆ --- │
     #   # │ u32 ┆ u32 │
     #   # ╞═════╪═════╡
-    #   # │ 3   ┆ 3   │
+    #   # │ 3   ┆ 2   │
     #   # └─────┴─────┘
     def count
-      wrap_expr(_rbexpr.count)
+      _from_rbexpr(_rbexpr.count)
     end
 
     # Count the number of values in this expression.
     #
-    # Alias for {#count}.
-    #
     # @return [Expr]
     #
     # @example
@@ -743,8 +739,9 @@ module Polars
     #   # │ 3   ┆ 3   │
     #   # └─────┴─────┘
     def len
-      count
+      _from_rbexpr(_rbexpr.len)
     end
+    alias_method :length, :len
 
     # Get a slice of this expression.
     #
@@ -781,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.
@@ -815,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.
@@ -840,7 +837,7 @@ module Polars
     #   # │ 2      │
     #   # └────────┘
     def rechunk
-      wrap_expr(_rbexpr.rechunk)
+      _from_rbexpr(_rbexpr.rechunk)
     end
 
     # Drop null values.
@@ -867,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.
@@ -894,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.
@@ -929,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
 
@@ -965,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
 
@@ -997,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
 
@@ -1029,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
 
@@ -1043,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
 
@@ -1089,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.
@@ -1114,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.
@@ -1140,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.
@@ -1169,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).
@@ -1197,7 +1194,7 @@ module Polars
     #   # │ 1   ┆ 2   │
     #   # └─────┴─────┘
     def mode
-      wrap_expr(_rbexpr.mode)
+      _from_rbexpr(_rbexpr.mode)
     end
 
     # Cast between data types.
@@ -1236,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.
@@ -1311,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.
@@ -1350,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.
@@ -1389,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.
@@ -1420,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.
@@ -1444,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.
@@ -1468,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.
@@ -1502,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.
@@ -1556,7 +1553,7 @@ module Polars
       end
       by = Utils.selection_to_rbexpr_list(by)
 
-      wrap_expr(_rbexpr.sort_by(by, reverse))
+      _from_rbexpr(_rbexpr.sort_by(by, reverse))
     end
 
     # Take values by index.
@@ -1597,7 +1594,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
 
@@ -1630,7 +1627,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.
@@ -1733,9 +1730,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
 
@@ -1764,7 +1761,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.
@@ -1794,7 +1791,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.
@@ -1824,14 +1821,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.
@@ -1854,7 +1851,7 @@ module Polars
     #   # │ 1.0 │
     #   # └─────┘
     def std(ddof: 1)
-      wrap_expr(_rbexpr.std(ddof))
+      _from_rbexpr(_rbexpr.std(ddof))
     end
 
     # Get variance.
@@ -1877,7 +1874,7 @@ module Polars
     #   # │ 1.0 │
     #   # └─────┘
     def var(ddof: 1)
-      wrap_expr(_rbexpr.var(ddof))
+      _from_rbexpr(_rbexpr.var(ddof))
     end
 
     # Get maximum value.
@@ -1897,7 +1894,7 @@ module Polars
     #   # │ 1.0 │
     #   # └─────┘
     def max
-      wrap_expr(_rbexpr.max)
+      _from_rbexpr(_rbexpr.max)
     end
 
     # Get minimum value.
@@ -1917,7 +1914,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.
@@ -1937,7 +1934,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.
@@ -1957,7 +1954,7 @@ module Polars
     #   # │ NaN │
     #   # └─────┘
     def nan_min
-      wrap_expr(_rbexpr.nan_min)
+      _from_rbexpr(_rbexpr.nan_min)
     end
 
     # Get sum value.
@@ -1981,7 +1978,7 @@ module Polars
     #   # │ 0   │
     #   # └─────┘
     def sum
-      wrap_expr(_rbexpr.sum)
+      _from_rbexpr(_rbexpr.sum)
     end
 
     # Get mean value.
@@ -2001,7 +1998,7 @@ module Polars
     #   # │ 0.0 │
     #   # └─────┘
     def mean
-      wrap_expr(_rbexpr.mean)
+      _from_rbexpr(_rbexpr.mean)
     end
 
     # Get median value using linear interpolation.
@@ -2021,7 +2018,7 @@ module Polars
     #   # │ 0.0 │
     #   # └─────┘
     def median
-      wrap_expr(_rbexpr.median)
+      _from_rbexpr(_rbexpr.median)
     end
 
     # Compute the product of an expression.
@@ -2041,7 +2038,7 @@ module Polars
     #   # │ 6   │
     #   # └─────┘
     def product
-      wrap_expr(_rbexpr.product)
+      _from_rbexpr(_rbexpr.product)
     end
 
     # Count unique values.
@@ -2061,7 +2058,7 @@ module Polars
     #   # │ 2   │
     #   # └─────┘
     def n_unique
-      wrap_expr(_rbexpr.n_unique)
+      _from_rbexpr(_rbexpr.n_unique)
     end
 
     # Approx count unique values.
@@ -2072,7 +2069,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)
     #   # ┌─────┐
@@ -2082,9 +2079,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.
     #
@@ -2108,7 +2106,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.
@@ -2148,7 +2146,7 @@ module Polars
     #   # │ 1   │
     #   # └─────┘
     def arg_unique
-      wrap_expr(_rbexpr.arg_unique)
+      _from_rbexpr(_rbexpr.arg_unique)
     end
 
     # Get unique values of this expression.
@@ -2173,9 +2171,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
 
@@ -2196,7 +2194,7 @@ module Polars
     #   # │ 1   │
     #   # └─────┘
     def first
-      wrap_expr(_rbexpr.first)
+      _from_rbexpr(_rbexpr.first)
     end
 
     # Get the last value.
@@ -2216,7 +2214,7 @@ module Polars
     #   # │ 2   │
     #   # └─────┘
     def last
-      wrap_expr(_rbexpr.last)
+      _from_rbexpr(_rbexpr.last)
     end
 
     # Apply window function over a subgroup.
@@ -2280,7 +2278,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.
@@ -2302,7 +2300,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.
@@ -2330,7 +2328,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
 
@@ -2353,7 +2351,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.
@@ -2377,7 +2375,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.
@@ -2401,7 +2399,7 @@ module Polars
     #   # │ false │
     #   # └───────┘
     def peak_min
-      wrap_expr(_rbexpr.peak_min)
+      _from_rbexpr(_rbexpr.peak_min)
     end
 
     # Get quantile value.
@@ -2423,7 +2421,7 @@ module Polars
     #   # │ --- │
     #   # │ f64 │
     #   # ╞═════╡
-    #   # │ 1.0 │
+    #   # │ 2.0 │
     #   # └─────┘
     #
     # @example
@@ -2475,7 +2473,207 @@ 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.
+    #
+    # @param breaks [Array]
+    #   List of unique cut points.
+    # @param labels [Array]
+    #   Names of the categories. The number of labels must be equal to the number
+    #   of cut points plus one.
+    # @param left_closed [Boolean]
+    #   Set the intervals to be left-closed instead of right-closed.
+    # @param include_breaks [Boolean]
+    #   Include a column with the right endpoint of the bin each observation falls
+    #   in. This will change the data type of the output from a
+    #   `Categorical` to a `Struct`.
+    #
+    # @return [Expr]
+    #
+    # @example Divide a column into three categories.
+    #   df = Polars::DataFrame.new({"foo" => [-2, -1, 0, 1, 2]})
+    #   df.with_columns(
+    #     Polars.col("foo").cut([-1, 1], labels: ["a", "b", "c"]).alias("cut")
+    #   )
+    #   # =>
+    #   # shape: (5, 2)
+    #   # ┌─────┬─────┐
+    #   # │ foo ┆ cut │
+    #   # │ --- ┆ --- │
+    #   # │ i64 ┆ cat │
+    #   # ╞═════╪═════╡
+    #   # │ -2  ┆ a   │
+    #   # │ -1  ┆ a   │
+    #   # │ 0   ┆ b   │
+    #   # │ 1   ┆ b   │
+    #   # │ 2   ┆ c   │
+    #   # └─────┴─────┘
+    #
+    # @example Add both the category and the breakpoint.
+    #   df.with_columns(
+    #     Polars.col("foo").cut([-1, 1], include_breaks: true).alias("cut")
+    #   ).unnest("cut")
+    #   # =>
+    #   # shape: (5, 3)
+    #   # ┌─────┬──────┬────────────┐
+    #   # │ foo ┆ brk  ┆ foo_bin    │
+    #   # │ --- ┆ ---  ┆ ---        │
+    #   # │ i64 ┆ f64  ┆ cat        │
+    #   # ╞═════╪══════╪════════════╡
+    #   # │ -2  ┆ -1.0 ┆ (-inf, -1] │
+    #   # │ -1  ┆ -1.0 ┆ (-inf, -1] │
+    #   # │ 0   ┆ 1.0  ┆ (-1, 1]    │
+    #   # │ 1   ┆ 1.0  ┆ (-1, 1]    │
+    #   # │ 2   ┆ inf  ┆ (1, inf]   │
+    #   # └─────┴──────┴────────────┘
+    def cut(breaks, labels: nil, left_closed: false, include_breaks: false)
+      _from_rbexpr(_rbexpr.cut(breaks, labels, left_closed, include_breaks))
+    end
+
+    # Bin continuous values into discrete categories based on their quantiles.
+    #
+    # @param quantiles [Array]
+    #   Either a list of quantile probabilities between 0 and 1 or a positive
+    #   integer determining the number of bins with uniform probability.
+    # @param labels [Array]
+    #   Names of the categories. The number of labels must be equal to the number
+    #   of categories.
+    # @param left_closed [Boolean]
+    #   Set the intervals to be left-closed instead of right-closed.
+    # @param allow_duplicates [Boolean]
+    #   If set to `true`, duplicates in the resulting quantiles are dropped,
+    #   rather than raising a `DuplicateError`. This can happen even with unique
+    #   probabilities, depending on the data.
+    # @param include_breaks [Boolean]
+    #   Include a column with the right endpoint of the bin each observation falls
+    #   in. This will change the data type of the output from a
+    #   `Categorical` to a `Struct`.
+    #
+    # @return [Expr]
+    #
+    # @example Divide a column into three categories according to pre-defined quantile probabilities.
+    #   df = Polars::DataFrame.new({"foo" => [-2, -1, 0, 1, 2]})
+    #   df.with_columns(
+    #     Polars.col("foo").qcut([0.25, 0.75], labels: ["a", "b", "c"]).alias("qcut")
+    #   )
+    #   # =>
+    #   # shape: (5, 2)
+    #   # ┌─────┬──────┐
+    #   # │ foo ┆ qcut │
+    #   # │ --- ┆ ---  │
+    #   # │ i64 ┆ cat  │
+    #   # ╞═════╪══════╡
+    #   # │ -2  ┆ a    │
+    #   # │ -1  ┆ a    │
+    #   # │ 0   ┆ b    │
+    #   # │ 1   ┆ b    │
+    #   # │ 2   ┆ c    │
+    #   # └─────┴──────┘
+    #
+    # @example Divide a column into two categories using uniform quantile probabilities.
+    #   df.with_columns(
+    #     Polars.col("foo")
+    #       .qcut(2, labels: ["low", "high"], left_closed: true)
+    #       .alias("qcut")
+    #   )
+    #   # =>
+    #   # shape: (5, 2)
+    #   # ┌─────┬──────┐
+    #   # │ foo ┆ qcut │
+    #   # │ --- ┆ ---  │
+    #   # │ i64 ┆ cat  │
+    #   # ╞═════╪══════╡
+    #   # │ -2  ┆ low  │
+    #   # │ -1  ┆ low  │
+    #   # │ 0   ┆ high │
+    #   # │ 1   ┆ high │
+    #   # │ 2   ┆ high │
+    #   # └─────┴──────┘
+    #
+    # @example Add both the category and the breakpoint.
+    #   df.with_columns(
+    #     Polars.col("foo").qcut([0.25, 0.75], include_breaks: true).alias("qcut")
+    #   ).unnest("qcut")
+    #   # =>
+    #   # shape: (5, 3)
+    #   # ┌─────┬──────┬────────────┐
+    #   # │ foo ┆ brk  ┆ foo_bin    │
+    #   # │ --- ┆ ---  ┆ ---        │
+    #   # │ i64 ┆ f64  ┆ cat        │
+    #   # ╞═════╪══════╪════════════╡
+    #   # │ -2  ┆ -1.0 ┆ (-inf, -1] │
+    #   # │ -1  ┆ -1.0 ┆ (-inf, -1] │
+    #   # │ 0   ┆ 1.0  ┆ (-1, 1]    │
+    #   # │ 1   ┆ 1.0  ┆ (-1, 1]    │
+    #   # │ 2   ┆ inf  ┆ (1, inf]   │
+    #   # └─────┴──────┴────────────┘
+    def qcut(quantiles, labels: nil, left_closed: false, allow_duplicates: false, include_breaks: false)
+      if quantiles.is_a?(Integer)
+        rbexpr = _rbexpr.qcut_uniform(
+          quantiles, labels, left_closed, allow_duplicates, include_breaks
+        )
+      else
+        rbexpr = _rbexpr.qcut(
+          quantiles, labels, left_closed, allow_duplicates, include_breaks
+        )
+      end
+
+      _from_rbexpr(rbexpr)
+    end
+
+    # Get the lengths of runs of identical values.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(Polars::Series.new("s", [1, 1, 2, 1, nil, 1, 3, 3]))
+    #   df.select(Polars.col("s").rle).unnest("s")
+    #   # =>
+    #   # shape: (6, 2)
+    #   # ┌─────────┬────────┐
+    #   # │ lengths ┆ values │
+    #   # │ ---     ┆ ---    │
+    #   # │ i32     ┆ i64    │
+    #   # ╞═════════╪════════╡
+    #   # │ 2       ┆ 1      │
+    #   # │ 1       ┆ 2      │
+    #   # │ 1       ┆ 1      │
+    #   # │ 1       ┆ null   │
+    #   # │ 1       ┆ 1      │
+    #   # │ 2       ┆ 3      │
+    #   # └─────────┴────────┘
+    def rle
+      _from_rbexpr(_rbexpr.rle)
+    end
+
+    # Map values to run IDs.
+    #
+    # Similar to RLE, but it maps each value to an ID corresponding to the run into
+    # which it falls. This is especially useful when you want to define groups by
+    # runs of identical values rather than the values themselves.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"a" => [1, 2, 1, 1, 1], "b" => ["x", "x", nil, "y", "y"]})
+    #   df.with_columns([Polars.col("a").rle_id.alias("a_r"), Polars.struct(["a", "b"]).rle_id.alias("ab_r")])
+    #   # =>
+    #   # shape: (5, 4)
+    #   # ┌─────┬──────┬─────┬──────┐
+    #   # │ a   ┆ b    ┆ a_r ┆ ab_r │
+    #   # │ --- ┆ ---  ┆ --- ┆ ---  │
+    #   # │ i64 ┆ str  ┆ u32 ┆ u32  │
+    #   # ╞═════╪══════╪═════╪══════╡
+    #   # │ 1   ┆ x    ┆ 0   ┆ 0    │
+    #   # │ 2   ┆ x    ┆ 1   ┆ 1    │
+    #   # │ 1   ┆ null ┆ 2   ┆ 2    │
+    #   # │ 1   ┆ y    ┆ 2   ┆ 3    │
+    #   # │ 1   ┆ y    ┆ 2   ┆ 3    │
+    #   # └─────┴──────┴─────┴──────┘
+    def rle_id
+      _from_rbexpr(_rbexpr.rle_id)
     end
 
     # Filter a single column.
@@ -2514,7 +2712,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.
@@ -2592,7 +2790,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.
@@ -2703,7 +2901,7 @@ module Polars
     #  # │ b     ┆ [2, 3, 4] │
     #  # └───────┴───────────┘
     def flatten
-      wrap_expr(_rbexpr.explode)
+      _from_rbexpr(_rbexpr.explode)
     end
 
     # Explode a list or utf8 Series.
@@ -2730,7 +2928,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.
@@ -2751,8 +2949,8 @@ module Polars
     #   # │ 4   │
     #   # │ 7   │
     #   # └─────┘
-    def gather_every(n)
-      wrap_expr(_rbexpr.gather_every(n))
+    def gather_every(n, offset = 0)
+      _from_rbexpr(_rbexpr.gather_every(n, offset))
     end
     alias_method :take_every, :gather_every
 
@@ -2778,7 +2976,7 @@ module Polars
     #   # │ 3   │
     #   # └─────┘
     def head(n = 10)
-      wrap_expr(_rbexpr.head(n))
+      _from_rbexpr(_rbexpr.head(n))
     end
 
     # Get the last `n` rows.
@@ -2803,7 +3001,7 @@ module Polars
     #   # │ 7   │
     #   # └─────┘
     def tail(n = 10)
-      wrap_expr(_rbexpr.tail(n))
+      _from_rbexpr(_rbexpr.tail(n))
     end
 
     # Get the first `n` rows.
@@ -2818,6 +3016,500 @@ module Polars
       head(n)
     end
 
+    # Method equivalent of equality operator `expr == other`.
+    #
+    # @param other [Object]
+    #   A literal or expression value to compare with.
+    #
+    # @return [Expr]
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "x" => [1.0, 2.0, Float::NAN, 4.0],
+    #       "y" => [2.0, 2.0, Float::NAN, 4.0]
+    #     }
+    #   )
+    #   df.with_columns(
+    #     Polars.col("x").eq(Polars.col("y")).alias("x == y")
+    #   )
+    #   # =>
+    #   # shape: (4, 3)
+    #   # ┌─────┬─────┬────────┐
+    #   # │ x   ┆ y   ┆ x == y │
+    #   # │ --- ┆ --- ┆ ---    │
+    #   # │ f64 ┆ f64 ┆ bool   │
+    #   # ╞═════╪═════╪════════╡
+    #   # │ 1.0 ┆ 2.0 ┆ false  │
+    #   # │ 2.0 ┆ 2.0 ┆ true   │
+    #   # │ NaN ┆ NaN ┆ true   │
+    #   # │ 4.0 ┆ 4.0 ┆ true   │
+    #   # └─────┴─────┴────────┘
+    def eq(other)
+      self == other
+    end
+
+    # Method equivalent of equality operator `expr == other` where `None == None`.
+    #
+    # 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(
+    #     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)
+    #   # ┌──────┐
+    #   # │ a    │
+    #   # │ ---  │
+    #   # │ i64  │
+    #   # ╞══════╡
+    #   # │ 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]
@@ -2838,8 +3530,35 @@ module Polars
     #   # │ 64.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.
@@ -2875,7 +3594,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
 
@@ -2911,7 +3630,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.
@@ -3037,7 +3756,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.
@@ -3071,7 +3790,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.
@@ -3134,7 +3853,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.
@@ -3219,7 +3938,7 @@ module Polars
       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
         )
@@ -3308,7 +4027,7 @@ module Polars
       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
         )
@@ -3397,7 +4116,7 @@ module Polars
       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
         )
@@ -3486,7 +4205,7 @@ module Polars
       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
         )
@@ -3571,14 +4290,15 @@ module Polars
       center: false,
       by: nil,
       closed: "left",
-      ddof: 1
+      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
+          window_size, weights, min_periods, center, by, closed, ddof, warn_if_unsorted
         )
       )
     end
@@ -3661,14 +4381,15 @@ module Polars
       center: false,
       by: nil,
       closed: "left",
-      ddof: 1
+      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
+          window_size, weights, min_periods, center, by, closed, ddof, warn_if_unsorted
         )
       )
     end
@@ -3746,14 +4467,15 @@ module Polars
       min_periods: nil,
       center: false,
       by: nil,
-      closed: "left"
+      closed: "left",
+      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
+          window_size, weights, min_periods, center, by, closed, warn_if_unsorted
         )
       )
     end
@@ -3837,14 +4559,15 @@ module Polars
       min_periods: nil,
       center: false,
       by: nil,
-      closed: "left"
+      closed: "left",
+      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
+          quantile, interpolation, window_size, weights, min_periods, center, by, closed, warn_if_unsorted
         )
       )
     end
@@ -3906,7 +4629,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
     #     )
@@ -3922,7 +4645,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.
@@ -3949,7 +4672,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.
@@ -4044,7 +4767,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.
@@ -4075,7 +4798,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.
@@ -4112,7 +4835,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.
@@ -4141,7 +4864,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.
@@ -4173,7 +4896,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.
@@ -4210,7 +4933,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.
@@ -4295,7 +5018,7 @@ module Polars
     #   # │ -9223372036854775808 │
     #   # └──────────────────────┘
     def lower_bound
-      wrap_expr(_rbexpr.lower_bound)
+      _from_rbexpr(_rbexpr.lower_bound)
     end
 
     # Calculate the upper bound.
@@ -4318,7 +5041,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.
@@ -4342,7 +5065,7 @@ module Polars
     #   # │ null │
     #   # └──────┘
     def sign
-      wrap_expr(_rbexpr.sign)
+      _from_rbexpr(_rbexpr.sign)
     end
 
     # Compute the element-wise value for the sine.
@@ -4362,7 +5085,7 @@ module Polars
     #   # │ 0.0 │
     #   # └─────┘
     def sin
-      wrap_expr(_rbexpr.sin)
+      _from_rbexpr(_rbexpr.sin)
     end
 
     # Compute the element-wise value for the cosine.
@@ -4382,7 +5105,7 @@ module Polars
     #   # │ 1.0 │
     #   # └─────┘
     def cos
-      wrap_expr(_rbexpr.cos)
+      _from_rbexpr(_rbexpr.cos)
     end
 
     # Compute the element-wise value for the tangent.
@@ -4402,7 +5125,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.
@@ -4422,7 +5145,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.
@@ -4442,7 +5165,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.
@@ -4462,7 +5185,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.
@@ -4482,7 +5205,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.
@@ -4502,7 +5225,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.
@@ -4522,7 +5245,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.
@@ -4542,7 +5265,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.
@@ -4562,7 +5285,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.
@@ -4582,7 +5305,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.
@@ -4608,7 +5331,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.
@@ -4637,7 +5360,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.
@@ -4683,14 +5406,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
@@ -4723,7 +5446,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.
@@ -4755,7 +5478,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.
@@ -4787,7 +5510,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.
@@ -4817,7 +5540,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.
@@ -4853,7 +5576,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.
@@ -4886,7 +5609,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.
@@ -4911,7 +5634,7 @@ module Polars
     #   # │ 1.584963 │
     #   # └──────────┘
     def log(base = Math::E)
-      wrap_expr(_rbexpr.log(base))
+      _from_rbexpr(_rbexpr.log(base))
     end
 
     # Computes the entropy.
@@ -4950,7 +5673,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.
@@ -4997,7 +5720,7 @@ module Polars
     #   # │ -24.0  │
     #   # └────────┘
     def cumulative_eval(expr, min_periods: 1, parallel: false)
-      wrap_expr(
+      _from_rbexpr(
         _rbexpr.cumulative_eval(expr._rbexpr, min_periods, parallel)
       )
     end
@@ -5028,7 +5751,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.
@@ -5053,7 +5776,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.
@@ -5088,7 +5811,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.
@@ -5156,7 +6041,7 @@ module Polars
 
     private
 
-    def wrap_expr(expr)
+    def _from_rbexpr(expr)
       Utils.wrap_expr(expr)
     end