polars-df 0.6.0-arm64-darwin → 0.7.0-arm64-darwin

data/lib/polars/expr.rb

@@ -131,6 +131,13 @@ module Polars
       wrap_expr(_rbexpr.gt(_to_expr(other)._rbexpr))
     end
 
+    # Performs boolean not.
+    #
+    # @return [Expr]
+    def !
+      is_not
+    end
+
     # Performs negation.
     #
     # @return [Expr]
@@ -191,8 +198,8 @@ module Polars
     #   # ╞══════╪═══════╡
     #   # │ true ┆ false │
     #   # └──────┴───────┘
-    def any
-      wrap_expr(_rbexpr.any)
+    def any(drop_nulls: true)
+      wrap_expr(_rbexpr.any(drop_nulls))
     end
 
     # Check if all boolean values in a Boolean column are `true`.
@@ -216,8 +223,8 @@ module Polars
     #   # ╞══════╪═══════╪═══════╡
     #   # │ true ┆ false ┆ false │
     #   # └──────┴───────┴───────┘
-    def all
-      wrap_expr(_rbexpr.all)
+    def all(drop_nulls: true)
+      wrap_expr(_rbexpr.all(drop_nulls))
     end
 
     # Compute the square root of the elements.
@@ -401,21 +408,21 @@ module Polars
     #   # │ 18  ┆ 4   │
     #   # └─────┴─────┘
     def keep_name
-      wrap_expr(_rbexpr.keep_name)
+      name.keep
     end
 
     # Add a prefix to the root column name of the expression.
     #
     # @return [Expr]
     def prefix(prefix)
-      wrap_expr(_rbexpr.prefix(prefix))
+      name.prefix(prefix)
     end
 
     # Add a suffix to the root column name of the expression.
     #
     # @return [Expr]
     def suffix(suffix)
-      wrap_expr(_rbexpr.suffix(suffix))
+      name.suffix(suffix)
     end
 
     # Rename the output of an expression by mapping a function over the root name.
@@ -443,7 +450,7 @@ module Polars
     #   # │ 1         ┆ 3         │
     #   # └───────────┴───────────┘
     def map_alias(&f)
-      Utils.wrap_expr(_rbexpr.map_alias(f))
+      name.map(&f)
     end
 
     # Negate a boolean expression.
@@ -682,7 +689,7 @@ module Polars
     #       "value" => [94, 95, 96, 97, 97, 99]
     #     }
     #   )
-    #   df.groupby("group", maintain_order: true).agg(Polars.col("value").agg_groups)
+    #   df.group_by("group", maintain_order: true).agg(Polars.col("value").agg_groups)
     #   # =>
     #   # shape: (2, 2)
     #   # ┌───────┬───────────┐
@@ -905,8 +912,8 @@ module Polars
     #   df = Polars::DataFrame.new({"a" => [1, 2, 3, 4]})
     #   df.select(
     #     [
-    #       Polars.col("a").cumsum,
-    #       Polars.col("a").cumsum(reverse: true).alias("a_reverse")
+    #       Polars.col("a").cum_sum,
+    #       Polars.col("a").cum_sum(reverse: true).alias("a_reverse")
     #     ]
     #   )
     #   # =>
@@ -921,9 +928,10 @@ module Polars
     #   # │ 6   ┆ 7         │
     #   # │ 10  ┆ 4         │
     #   # └─────┴───────────┘
-    def cumsum(reverse: false)
-      wrap_expr(_rbexpr.cumsum(reverse))
+    def cum_sum(reverse: false)
+      wrap_expr(_rbexpr.cum_sum(reverse))
     end
+    alias_method :cumsum, :cum_sum
 
     # Get an array with the cumulative product computed at every element.
     #
@@ -940,8 +948,8 @@ module Polars
     #   df = Polars::DataFrame.new({"a" => [1, 2, 3, 4]})
     #   df.select(
     #     [
-    #       Polars.col("a").cumprod,
-    #       Polars.col("a").cumprod(reverse: true).alias("a_reverse")
+    #       Polars.col("a").cum_prod,
+    #       Polars.col("a").cum_prod(reverse: true).alias("a_reverse")
     #     ]
     #   )
     #   # =>
@@ -956,9 +964,10 @@ module Polars
     #   # │ 6   ┆ 12        │
     #   # │ 24  ┆ 4         │
     #   # └─────┴───────────┘
-    def cumprod(reverse: false)
-      wrap_expr(_rbexpr.cumprod(reverse))
+    def cum_prod(reverse: false)
+      wrap_expr(_rbexpr.cum_prod(reverse))
     end
+    alias_method :cumprod, :cum_prod
 
     # Get an array with the cumulative min computed at every element.
     #
@@ -971,8 +980,8 @@ module Polars
     #   df = Polars::DataFrame.new({"a" => [1, 2, 3, 4]})
     #   df.select(
     #     [
-    #       Polars.col("a").cummin,
-    #       Polars.col("a").cummin(reverse: true).alias("a_reverse")
+    #       Polars.col("a").cum_min,
+    #       Polars.col("a").cum_min(reverse: true).alias("a_reverse")
     #     ]
     #   )
     #   # =>
@@ -987,9 +996,10 @@ module Polars
     #   # │ 1   ┆ 3         │
     #   # │ 1   ┆ 4         │
     #   # └─────┴───────────┘
-    def cummin(reverse: false)
-      wrap_expr(_rbexpr.cummin(reverse))
+    def cum_min(reverse: false)
+      wrap_expr(_rbexpr.cum_min(reverse))
     end
+    alias_method :cummin, :cum_min
 
     # Get an array with the cumulative max computed at every element.
     #
@@ -1002,8 +1012,8 @@ module Polars
     #   df = Polars::DataFrame.new({"a" => [1, 2, 3, 4]})
     #   df.select(
     #     [
-    #       Polars.col("a").cummax,
-    #       Polars.col("a").cummax(reverse: true).alias("a_reverse")
+    #       Polars.col("a").cum_max,
+    #       Polars.col("a").cum_max(reverse: true).alias("a_reverse")
     #     ]
     #   )
     #   # =>
@@ -1018,9 +1028,10 @@ module Polars
     #   # │ 3   ┆ 4         │
     #   # │ 4   ┆ 4         │
     #   # └─────┴───────────┘
-    def cummax(reverse: false)
-      wrap_expr(_rbexpr.cummax(reverse))
+    def cum_max(reverse: false)
+      wrap_expr(_rbexpr.cum_max(reverse))
     end
+    alias_method :cummax, :cum_max
 
     # Get an array with the cumulative count computed at every element.
     #
@@ -1035,8 +1046,8 @@ module Polars
     #   df = Polars::DataFrame.new({"a" => [1, 2, 3, 4]})
     #   df.select(
     #     [
-    #       Polars.col("a").cumcount,
-    #       Polars.col("a").cumcount(reverse: true).alias("a_reverse")
+    #       Polars.col("a").cum_count,
+    #       Polars.col("a").cum_count(reverse: true).alias("a_reverse")
     #     ]
     #   )
     #   # =>
@@ -1051,9 +1062,10 @@ module Polars
     #   # │ 2   ┆ 1         │
     #   # │ 3   ┆ 0         │
     #   # └─────┴───────────┘
-    def cumcount(reverse: false)
-      wrap_expr(_rbexpr.cumcount(reverse))
+    def cum_count(reverse: false)
+      wrap_expr(_rbexpr.cum_count(reverse))
     end
+    alias_method :cumcount, :cum_count
 
     # Rounds down to the nearest integer value.
     #
@@ -1229,7 +1241,7 @@ module Polars
 
     # Sort this column. In projection/ selection context the whole column is sorted.
     #
-    # If used in a groupby context, the groups are sorted.
+    # If used in a group by context, the groups are sorted.
     #
     # @param reverse [Boolean]
     #   false -> order from small to large.
@@ -1287,7 +1299,7 @@ module Polars
     #   # └───────┘
     #
     # @example
-    #   df.groupby("group").agg(Polars.col("value").sort)
+    #   df.group_by("group").agg(Polars.col("value").sort)
     #   # =>
     #   # shape: (2, 2)
     #   # ┌───────┬────────────┐
@@ -1337,6 +1349,7 @@ module Polars
     #   # │ 2     ┆ 98       │
     #   # └───────┴──────────┘
     def top_k(k: 5)
+      k = Utils.parse_as_expression(k)
       wrap_expr(_rbexpr.top_k(k))
     end
 
@@ -1375,6 +1388,7 @@ module Polars
     #   # │ 2     ┆ 98       │
     #   # └───────┴──────────┘
     def bottom_k(k: 5)
+      k = Utils.parse_as_expression(k)
       wrap_expr(_rbexpr.bottom_k(k))
     end
 
@@ -1494,7 +1508,7 @@ module Polars
     # Sort this column by the ordering of another column, or multiple other columns.
     #
     # In projection/ selection context the whole column is sorted.
-    # If used in a groupby context, the groups are sorted.
+    # If used in a group by context, the groups are sorted.
     #
     # @param by [Object]
     #   The column(s) used for sorting.
@@ -1566,30 +1580,33 @@ module Polars
     #       "value" => [1, 98, 2, 3, 99, 4]
     #     }
     #   )
-    #   df.groupby("group", maintain_order: true).agg(Polars.col("value").take(1))
+    #   df.group_by("group", maintain_order: true).agg(Polars.col("value").take([2, 1]))
     #   # =>
     #   # shape: (2, 2)
-    #   # ┌───────┬───────┐
-    #   # │ group ┆ value │
-    #   # │ ---   ┆ ---   │
-    #   # │ str   ┆ i64   │
-    #   # ╞═══════╪═══════╡
-    #   # │ one   ┆ 98    │
-    #   # │ two   ┆ 99    │
-    #   # └───────┴───────┘
-    def take(indices)
+    #   # ┌───────┬───────────┐
+    #   # │ group ┆ value     │
+    #   # │ ---   ┆ ---       │
+    #   # │ str   ┆ list[i64] │
+    #   # ╞═══════╪═══════════╡
+    #   # │ one   ┆ [2, 98]   │
+    #   # │ two   ┆ [4, 99]   │
+    #   # └───────┴───────────┘
+    def gather(indices)
       if indices.is_a?(::Array)
         indices_lit = Polars.lit(Series.new("", indices, dtype: :u32))
       else
         indices_lit = Utils.expr_to_lit_or_expr(indices, str_to_lit: false)
       end
-      wrap_expr(_rbexpr.take(indices_lit._rbexpr))
+      wrap_expr(_rbexpr.gather(indices_lit._rbexpr))
     end
+    alias_method :take, :gather
 
     # Shift the values by a given period.
     #
-    # @param periods [Integer]
+    # @param n [Integer]
     #   Number of places to shift (may be negative).
+    # @param fill_value [Object]
+    #   Fill the resulting null values with this value.
     #
     # @return [Expr]
     #
@@ -1608,8 +1625,12 @@ module Polars
     #   # │ 2    │
     #   # │ 3    │
     #   # └──────┘
-    def shift(periods = 1)
-      wrap_expr(_rbexpr.shift(periods))
+    def shift(n = 1, fill_value: nil)
+      if !fill_value.nil?
+        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))
     end
 
     # Shift the values by a given period and fill the resulting null values.
@@ -1637,8 +1658,7 @@ module Polars
     #   # │ 3   │
     #   # └─────┘
     def shift_and_fill(periods, fill_value)
-      fill_value = Utils.expr_to_lit_or_expr(fill_value, str_to_lit: true)
-      wrap_expr(_rbexpr.shift_and_fill(periods, fill_value._rbexpr))
+      shift(periods, fill_value: fill_value)
     end
 
     # Fill null values using the specified value or strategy.
@@ -2063,7 +2083,7 @@ module Polars
     #   # │ 2   │
     #   # └─────┘
     def approx_unique
-      wrap_expr(_rbexpr.approx_unique)
+      wrap_expr(_rbexpr.approx_n_unique)
     end
 
     # Count null values.
@@ -2201,7 +2221,7 @@ module Polars
 
     # Apply window function over a subgroup.
     #
-    # This is similar to a groupby + aggregation + self join.
+    # This is similar to a group by + aggregation + self join.
     # Or similar to [window functions in Postgres](https://www.postgresql.org/docs/current/tutorial-window.html).
     #
     # @param expr [Object]
@@ -2309,9 +2329,10 @@ module Polars
     #   # │ 1   ┆ false    │
     #   # │ 5   ┆ true     │
     #   # └─────┴──────────┘
-    def is_first
-      wrap_expr(_rbexpr.is_first)
+    def is_first_distinct
+      wrap_expr(_rbexpr.is_first_distinct)
     end
+    alias_method :is_first, :is_first_distinct
 
     # Get mask of duplicated values.
     #
@@ -2335,6 +2356,54 @@ module Polars
       wrap_expr(_rbexpr.is_duplicated)
     end
 
+    # Get a boolean mask of the local maximum peaks.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"a" => [1, 2, 3, 4, 5]})
+    #   df.select(Polars.col("a").peak_max)
+    #   # =>
+    #   # shape: (5, 1)
+    #   # ┌───────┐
+    #   # │ a     │
+    #   # │ ---   │
+    #   # │ bool  │
+    #   # ╞═══════╡
+    #   # │ false │
+    #   # │ false │
+    #   # │ false │
+    #   # │ false │
+    #   # │ true  │
+    #   # └───────┘
+    def peak_max
+      wrap_expr(_rbexpr.peak_max)
+    end
+
+    # Get a boolean mask of the local minimum peaks.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"a" => [4, 1, 3, 2, 5]})
+    #   df.select(Polars.col("a").peak_min)
+    #   # =>
+    #   # shape: (5, 1)
+    #   # ┌───────┐
+    #   # │ a     │
+    #   # │ ---   │
+    #   # │ bool  │
+    #   # ╞═══════╡
+    #   # │ false │
+    #   # │ true  │
+    #   # │ false │
+    #   # │ true  │
+    #   # │ false │
+    #   # └───────┘
+    def peak_min
+      wrap_expr(_rbexpr.peak_min)
+    end
+
     # Get quantile value.
     #
     # @param quantile [Float]
@@ -2427,7 +2496,7 @@ module Polars
     #     }
     #   )
     #   (
-    #     df.groupby("group_col").agg(
+    #     df.group_by("group_col").agg(
     #       [
     #         Polars.col("b").filter(Polars.col("b") < 2).sum.alias("lt"),
     #         Polars.col("b").filter(Polars.col("b") >= 2).sum.alias("gte")
@@ -2465,7 +2534,7 @@ module Polars
     #     }
     #   )
     #   (
-    #     df.groupby("group_col").agg(
+    #     df.group_by("group_col").agg(
     #       [
     #         Polars.col("b").where(Polars.col("b") < 2).sum.alias("lt"),
     #         Polars.col("b").where(Polars.col("b") >= 2).sum.alias("gte")
@@ -2583,7 +2652,7 @@ module Polars
     #
     # @example In a GroupBy context the function is applied by group:
     #   df.lazy
-    #     .groupby("b", maintain_order: true)
+    #     .group_by("b", maintain_order: true)
     #     .agg(
     #       [
     #         Polars.col("a").apply { |x| x.sum }
@@ -2622,7 +2691,7 @@ module Polars
     #      "values" => [[1, 2], [2, 3], [4]]
     #    }
     #  )
-    #  df.groupby("group").agg(Polars.col("values").flatten)
+    #  df.group_by("group").agg(Polars.col("values").flatten)
     #  # =>
     #  # shape: (2, 2)
     #  # ┌───────┬───────────┐
@@ -2670,7 +2739,7 @@ module Polars
     #
     # @example
     #   df = Polars::DataFrame.new({"foo" => [1, 2, 3, 4, 5, 6, 7, 8, 9]})
-    #   df.select(Polars.col("foo").take_every(3))
+    #   df.select(Polars.col("foo").gather_every(3))
     #   # =>
     #   # shape: (3, 1)
     #   # ┌─────┐
@@ -2682,9 +2751,10 @@ module Polars
     #   # │ 4   │
     #   # │ 7   │
     #   # └─────┘
-    def take_every(n)
-      wrap_expr(_rbexpr.take_every(n))
+    def gather_every(n)
+      wrap_expr(_rbexpr.gather_every(n))
     end
+    alias_method :take_every, :gather_every
 
     # Get the first `n` rows.
     #
@@ -3057,11 +3127,11 @@ module Polars
     #   # ┌─────┬─────┐
     #   # │ a   ┆ b   │
     #   # │ --- ┆ --- │
-    #   # │ i64 ┆ f64 │
+    #   # │ f64 ┆ f64 │
     #   # ╞═════╪═════╡
-    #   # │ 1   ┆ 1.0 │
-    #   # │ 2   ┆ NaN │
-    #   # │ 3   ┆ 3.0 │
+    #   # │ 1.0 ┆ 1.0 │
+    #   # │ 2.0 ┆ NaN │
+    #   # │ 3.0 ┆ 3.0 │
     #   # └─────┴─────┘
     def interpolate(method: "linear")
       wrap_expr(_rbexpr.interpolate(method))
@@ -3112,7 +3182,7 @@ module Polars
     #
     # @note
     #   If you want to compute multiple aggregation statistics over the same dynamic
-    #   window, consider using `groupby_rolling` this method can cache the window size
+    #   window, consider using `group_by_rolling` this method can cache the window size
     #   computation.
     #
     # @return [Expr]
@@ -3201,7 +3271,7 @@ module Polars
     #
     # @note
     #   If you want to compute multiple aggregation statistics over the same dynamic
-    #   window, consider using `groupby_rolling` this method can cache the window size
+    #   window, consider using `group_by_rolling` this method can cache the window size
     #   computation.
     #
     # @return [Expr]
@@ -3290,7 +3360,7 @@ module Polars
     #
     # @note
     #   If you want to compute multiple aggregation statistics over the same dynamic
-    #   window, consider using `groupby_rolling` this method can cache the window size
+    #   window, consider using `group_by_rolling` this method can cache the window size
     #   computation.
     #
     # @return [Expr]
@@ -3379,7 +3449,7 @@ module Polars
     #
     # @note
     #   If you want to compute multiple aggregation statistics over the same dynamic
-    #   window, consider using `groupby_rolling` this method can cache the window size
+    #   window, consider using `group_by_rolling` this method can cache the window size
     #   computation.
     #
     # @return [Expr]
@@ -3468,7 +3538,7 @@ module Polars
     #
     # @note
     #   If you want to compute multiple aggregation statistics over the same dynamic
-    #   window, consider using `groupby_rolling` this method can cache the window size
+    #   window, consider using `group_by_rolling` this method can cache the window size
     #   computation.
     #
     # @return [Expr]
@@ -3558,7 +3628,7 @@ module Polars
     #
     # @note
     #   If you want to compute multiple aggregation statistics over the same dynamic
-    #   window, consider using `groupby_rolling` this method can cache the window size
+    #   window, consider using `group_by_rolling` this method can cache the window size
     #   computation.
     #
     # @return [Expr]
@@ -3644,7 +3714,7 @@ module Polars
     #
     # @note
     #   If you want to compute multiple aggregation statistics over the same dynamic
-    #   window, consider using `groupby_rolling` this method can cache the window size
+    #   window, consider using `group_by_rolling` this method can cache the window size
     #   computation.
     #
     # @return [Expr]
@@ -3733,7 +3803,7 @@ module Polars
     #
     # @note
     #   If you want to compute multiple aggregation statistics over the same dynamic
-    #   window, consider using `groupby_rolling` this method can cache the window size
+    #   window, consider using `group_by_rolling` this method can cache the window size
     #   computation.
     #
     # @return [Expr]
@@ -3948,7 +4018,7 @@ module Polars
     #   # ┌─────┐
     #   # │ a   │
     #   # │ --- │
-    #   # │ f32 │
+    #   # │ f64 │
     #   # ╞═════╡
     #   # │ 3.0 │
     #   # │ 4.5 │
@@ -4041,6 +4111,7 @@ module Polars
     #   # │ 12   ┆ 0.0        │
     #   # └──────┴────────────┘
     def pct_change(n: 1)
+      n = Utils.parse_as_expression(n)
       wrap_expr(_rbexpr.pct_change(n))
     end
 
@@ -4105,16 +4176,14 @@ module Polars
       wrap_expr(_rbexpr.kurtosis(fisher, bias))
     end
 
-    # Clip (limit) the values in an array to a `min` and `max` boundary.
-    #
-    # Only works for numerical types.
+    # Set values outside the given boundaries to the boundary value.
     #
-    # If you want to clip other dtypes, consider writing a "when, then, otherwise"
-    # expression. See `when` for more information.
+    # Only works for numeric and temporal columns. If you want to clip other data
+    # types, consider writing a `when-then-otherwise` expression.
     #
-    # @param min_val [Numeric]
+    # @param lower_bound [Numeric]
     #   Minimum value.
-    # @param max_val [Numeric]
+    # @param upper_bound [Numeric]
     #   Maximum value.
     #
     # @return [Expr]
@@ -4134,8 +4203,14 @@ module Polars
     #   # │ null ┆ null        │
     #   # │ 50   ┆ 10          │
     #   # └──────┴─────────────┘
-    def clip(min_val, max_val)
-      wrap_expr(_rbexpr.clip(min_val, max_val))
+    def clip(lower_bound, upper_bound)
+      if !lower_bound.nil?
+        lower_bound = Utils.parse_as_expression(lower_bound, str_as_lit: true)
+      end
+      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))
     end
 
     # Clip (limit) the values in an array to a `min` boundary.
@@ -4145,7 +4220,7 @@ module Polars
     # If you want to clip other dtypes, consider writing a "when, then, otherwise"
     # expression. See `when` for more information.
     #
-    # @param min_val [Numeric]
+    # @param lower_bound [Numeric]
     #   Minimum value.
     #
     # @return [Expr]
@@ -4165,8 +4240,8 @@ module Polars
     #   # │ null ┆ null        │
     #   # │ 50   ┆ 50          │
     #   # └──────┴─────────────┘
-    def clip_min(min_val)
-      wrap_expr(_rbexpr.clip_min(min_val))
+    def clip_min(lower_bound)
+      clip(lower_bound, nil)
     end
 
     # Clip (limit) the values in an array to a `max` boundary.
@@ -4176,7 +4251,7 @@ module Polars
     # If you want to clip other dtypes, consider writing a "when, then, otherwise"
     # expression. See `when` for more information.
     #
-    # @param max_val [Numeric]
+    # @param upper_bound [Numeric]
     #   Maximum value.
     #
     # @return [Expr]
@@ -4196,8 +4271,8 @@ module Polars
     #   # │ null ┆ null        │
     #   # │ 50   ┆ 0           │
     #   # └──────┴─────────────┘
-    def clip_max(max_val)
-      wrap_expr(_rbexpr.clip_max(max_val))
+    def clip_max(upper_bound)
+      clip(nil, upper_bound)
     end
 
     # Calculate the lower bound.
@@ -4558,11 +4633,11 @@ module Polars
     #   # │ 1   │
     #   # │ 3   │
     #   # └─────┘
-    def shuffle(seed: nil, fixed_seed: false)
+    def shuffle(seed: nil)
       if seed.nil?
         seed = rand(10000)
       end
-      wrap_expr(_rbexpr.shuffle(seed, fixed_seed))
+      wrap_expr(_rbexpr.shuffle(seed))
     end
 
     # Sample from this expression.
@@ -4600,22 +4675,23 @@ module Polars
       with_replacement: true,
       shuffle: false,
       seed: nil,
-      n: nil,
-      fixed_seed: false
+      n: nil
     )
       if !n.nil? && !frac.nil?
         raise ArgumentError, "cannot specify both `n` and `frac`"
       end
 
       if !n.nil? && frac.nil?
-        return wrap_expr(_rbexpr.sample_n(n, with_replacement, shuffle, seed, fixed_seed))
+        n = Utils.parse_as_expression(n)
+        return wrap_expr(_rbexpr.sample_n(n, with_replacement, shuffle, seed))
       end
 
       if frac.nil?
         frac = 1.0
       end
+      frac = Utils.parse_as_expression(frac)
       wrap_expr(
-        _rbexpr.sample_frac(frac, with_replacement, shuffle, seed, fixed_seed)
+        _rbexpr.sample_frac(frac, with_replacement, shuffle, seed)
       )
     end
 
@@ -4885,7 +4961,7 @@ module Polars
     #   Number of valid values there should be in the window before the expression
     #   is evaluated. valid values = `length - null_count`
     # @param parallel [Boolean]
-    #   Run in parallel. Don't do this in a groupby or another operation that
+    #   Run in parallel. Don't do this in a group by or another operation that
     #   already has much parallelization.
     #
     # @return [Expr]
@@ -5057,6 +5133,13 @@ module Polars
       MetaExpr.new(self)
     end
 
+    # Create an object namespace of all expressions that modify expression names.
+    #
+    # @return [NameExpr]
+    def name
+      NameExpr.new(self)
+    end
+
     # Create an object namespace of all string related methods.
     #
     # @return [StringExpr]