polars-df 0.19.0-x64-mingw-ucrt → 0.21.0-x64-mingw-ucrt

data/lib/polars/lazy_frame.rb

@@ -234,10 +234,18 @@ module Polars
     #
     # @param by [Object]
     #   Column (expressions) to sort by.
+    # @param more_by [Array]
+    #   Additional columns to sort by, specified as positional arguments.
     # @param reverse [Boolean]
     #   Sort in descending order.
     # @param nulls_last [Boolean]
     #   Place null values last. Can only be used if sorted by a single column.
+    # @param maintain_order [Boolean]
+    #   Whether the order should be maintained if elements are equal.
+    #   Note that if `true` streaming is not possible and performance might be
+    #   worse since this requires a stable search.
+    # @param multithreaded [Boolean]
+    #   Sort using multiple threads.
     #
     # @return [LazyFrame]
     #
@@ -305,6 +313,8 @@ module Polars
     #   Slice pushdown optimization.
     # @param common_subplan_elimination [Boolean]
     #   Will try to cache branching subplans that occur on self-joins or unions.
+    # @param comm_subexpr_elim [Boolean]
+    #   Common subexpressions will be cached and reused.
     # @param allow_streaming [Boolean]
     #   Run parts of the query in a streaming fashion (this is in an alpha state)
     #
@@ -412,6 +422,31 @@ module Polars
     #   Turn off (certain) optimizations.
     # @param slice_pushdown [Boolean]
     #   Slice pushdown optimization.
+    # @param storage_options [String]
+    #   Options that indicate how to connect to a cloud provider.
+    #
+    #   The cloud providers currently supported are AWS, GCP, and Azure.
+    #   See supported keys here:
+    #
+    #   * [aws](https://docs.rs/object_store/latest/object_store/aws/enum.AmazonS3ConfigKey.html)
+    #   * [gcp](https://docs.rs/object_store/latest/object_store/gcp/enum.GoogleConfigKey.html)
+    #   * [azure](https://docs.rs/object_store/latest/object_store/azure/enum.AzureConfigKey.html)
+    #   * Hugging Face (`hf://`): Accepts an API key under the `token` parameter: `{'token': '...'}`, or by setting the `HF_TOKEN` environment variable.
+    #
+    #   If `storage_options` is not provided, Polars will try to infer the
+    #   information from environment variables.
+    # @param retries [Integer]
+    #   Number of retries if accessing a cloud instance fails.
+    # @param sync_on_close ['data', 'all']
+    #   Sync to disk when before closing a file.
+    #
+    #   * `nil` does not sync.
+    #   * `data` syncs the file contents.
+    #   * `all` syncs the file contents and metadata.
+    # @param mkdir [Boolean]
+    #   Recursively create all the directories in the path.
+    # @param lazy [Boolean]
+    #     Wait to start execution until `collect` is called.
     #
     # @return [DataFrame]
     #
@@ -521,6 +556,16 @@ module Polars
     #   Slice pushdown optimization.
     # @param no_optimization [Boolean]
     #   Turn off (certain) optimizations.
+    # @param sync_on_close ['data', 'all']
+    #     Sync to disk when before closing a file.
+    #
+    #     * `nil` does not sync.
+    #     * `data` syncs the file contents.
+    #     * `all` syncs the file contents and metadata.
+    # @param mkdir [Boolean]
+    #     Recursively create all the directories in the path.
+    # @param lazy [Boolean]
+    #     Wait to start execution until `collect` is called.
     #
     # @return [DataFrame]
     #
@@ -614,9 +659,15 @@ module Polars
     #   A format string, with the specifiers defined by the
     #   `chrono <https://docs.rs/chrono/latest/chrono/format/strftime/index.html>`_
     #   Rust crate.
+    # @param float_scientific [Integer]
+    #   Whether to use scientific form always (true), never (false), or
+    #   automatically (nil) for `Float32` and `Float64` datatypes.
     # @param float_precision [Integer]
     #   Number of decimal places to write, applied to both `Float32` and
     #   `Float64` datatypes.
+    # @param decimal_comma [Boolean]
+    #   Use a comma as the decimal separator instead of a point. Floats will be
+    #   encapsulated in quotes if necessary; set the field separator to override.
     # @param null_value [String]
     #   A string representing null values (defaulting to the empty string).
     # @param quote_style ["necessary", "always", "non_numeric", "never"]
@@ -655,6 +706,16 @@ module Polars
     #   Options that indicate how to connect to a cloud provider.
     # @param retries [Integer]
     #   Number of retries if accessing a cloud instance fails.
+    # @param sync_on_close ['data', 'all']
+    #     Sync to disk when before closing a file.
+    #
+    #     * `nil` does not sync.
+    #     * `data` syncs the file contents.
+    #     * `all` syncs the file contents and metadata.
+    # @param mkdir [Boolean]
+    #     Recursively create all the directories in the path.
+    # @param lazy [Boolean]
+    #     Wait to start execution until `collect` is called.
     #
     # @return [DataFrame]
     #
@@ -674,6 +735,7 @@ module Polars
       time_format: nil,
       float_scientific: nil,
       float_precision: nil,
+      decimal_comma: false,
       null_value: nil,
       quote_style: nil,
       maintain_order: true,
@@ -726,6 +788,7 @@ module Polars
         time_format,
         float_scientific,
         float_precision,
+        decimal_comma,
         null_value,
         quote_style,
         storage_options,
@@ -762,6 +825,31 @@ module Polars
     #   Slice pushdown optimization.
     # @param no_optimization [Boolean]
     #   Turn off (certain) optimizations.
+    # @param storage_options [String]
+    #   Options that indicate how to connect to a cloud provider.
+    #
+    #   The cloud providers currently supported are AWS, GCP, and Azure.
+    #   See supported keys here:
+    #
+    #   * [aws](https://docs.rs/object_store/latest/object_store/aws/enum.AmazonS3ConfigKey.html)
+    #   * [gcp](https://docs.rs/object_store/latest/object_store/gcp/enum.GoogleConfigKey.html)
+    #   * [azure](https://docs.rs/object_store/latest/object_store/azure/enum.AzureConfigKey.html)
+    #   * Hugging Face (`hf://`): Accepts an API key under the `token` parameter: `{'token': '...'}`, or by setting the `HF_TOKEN` environment variable.
+    #
+    #   If `storage_options` is not provided, Polars will try to infer the
+    #   information from environment variables.
+    # @param retries [Integer]
+    #   Number of retries if accessing a cloud instance fails.
+    # @param sync_on_close ['data', 'all']
+    #   Sync to disk when before closing a file.
+    #
+    #   * `nil` does not sync.
+    #   * `data` syncs the file contents.
+    #   * `all` syncs the file contents and metadata.
+    # @param mkdir [Boolean]
+    #   Recursively create all the directories in the path.
+    # @param lazy [Boolean]
+    #     Wait to start execution until `collect` is called.
     #
     # @return [DataFrame]
     #
@@ -854,25 +942,6 @@ module Polars
     #
     # @param n_rows [Integer]
     #   Collect n_rows from the data sources.
-    # @param type_coercion [Boolean]
-    #   Run type coercion optimization.
-    # @param predicate_pushdown [Boolean]
-    #   Run predicate pushdown optimization.
-    # @param projection_pushdown [Boolean]
-    #   Run projection pushdown optimization.
-    # @param simplify_expression [Boolean]
-    #   Run simplify expressions optimization.
-    # @param string_cache [Boolean]
-    #   This argument is deprecated. Please set the string cache globally.
-    #   The argument will be ignored
-    # @param no_optimization [Boolean]
-    #   Turn off optimizations.
-    # @param slice_pushdown [Boolean]
-    #   Slice pushdown optimization
-    # @param common_subplan_elimination [Boolean]
-    #   Will try to cache branching subplans that occur on self-joins or unions.
-    # @param allow_streaming [Boolean]
-    #   Run parts of the query in a streaming fashion (this is in an alpha state)
     #
     # @return [DataFrame]
     #
@@ -892,41 +961,11 @@ module Polars
     #   # │ --- ┆ --- ┆ --- │
     #   # │ str ┆ i64 ┆ i64 │
     #   # ╞═════╪═════╪═════╡
-    #   # │ a   ┆ 1   ┆ 6   │
-    #   # │ b   ┆ 2   ┆ 5   │
+    #   # │ a   ┆ 4   ┆ 10  │
+    #   # │ b   ┆ 11  ┆ 10  │
     #   # └─────┴─────┴─────┘
-    def fetch(
-      n_rows = 500,
-      type_coercion: true,
-      predicate_pushdown: true,
-      projection_pushdown: true,
-      simplify_expression: true,
-      string_cache: false,
-      no_optimization: false,
-      slice_pushdown: true,
-      common_subplan_elimination: true,
-      comm_subexpr_elim: true,
-      allow_streaming: false
-    )
-      if no_optimization
-        predicate_pushdown = false
-        projection_pushdown = false
-        slice_pushdown = false
-        common_subplan_elimination = false
-      end
-
-      ldf = _ldf.optimization_toggle(
-        type_coercion,
-        predicate_pushdown,
-        projection_pushdown,
-        simplify_expression,
-        slice_pushdown,
-        common_subplan_elimination,
-        comm_subexpr_elim,
-        allow_streaming,
-        false
-      )
-      Utils.wrap_df(ldf.fetch(n_rows))
+    def fetch(n_rows = 500, **kwargs)
+      head(n_rows).collect(**kwargs)
     end
 
     # Return lazy representation, i.e. itself.
@@ -1058,7 +1097,7 @@ module Polars
     #   # │ null ┆ null ┆ null │
     #   # └──────┴──────┴──────┘
     def clear(n = 0)
-      DataFrame.new(columns: schema).clear(n).lazy
+      DataFrame.new(schema: schema).clear(n).lazy
     end
     alias_method :cleared, :clear
 
@@ -1413,8 +1452,32 @@ module Polars
     #   parallelize
     # @param closed ["right", "left", "both", "none"]
     #   Define whether the temporal window interval is closed or not.
+    # @param label ['left', 'right', 'datapoint']
+    #   Define which label to use for the window:
+    #
+    #   - 'left': lower boundary of the window
+    #   - 'right': upper boundary of the window
+    #   - 'datapoint': the first value of the index column in the given window.
+    #     If you don't need the label to be at one of the boundaries, choose this
+    #     option for maximum performance
     # @param by [Object]
     #   Also group by this column/these columns
+    # @param start_by ['window', 'datapoint', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday']
+    #   The strategy to determine the start of the first window by.
+    #
+    #   * 'window': Start by taking the earliest timestamp, truncating it with
+    #     `every`, and then adding `offset`.
+    #     Note that weekly windows start on Monday.
+    #   * 'datapoint': Start from the first encountered data point.
+    #   * a day of the week (only takes effect if `every` contains `'w'`):
+    #
+    #     * 'monday': Start the window on the Monday before the first data point.
+    #     * 'tuesday': Start the window on the Tuesday before the first data point.
+    #     * ...
+    #     * 'sunday': Start the window on the Sunday before the first data point.
+    #
+    #     The resulting window is then shifted back until the earliest datapoint
+    #     is in or in front of it.
     #
     # @return [DataFrame]
     #
@@ -1652,12 +1715,12 @@ module Polars
     # @param on [String]
     #   Join column of both DataFrames. If set, `left_on` and `right_on` should be
     #   None.
-    # @param by [Object]
-    #   Join on these columns before doing asof join.
     # @param by_left [Object]
     #   Join on these columns before doing asof join.
     # @param by_right [Object]
     #   Join on these columns before doing asof join.
+    # @param by [Object]
+    #   Join on these columns before doing asof join.
     # @param strategy ["backward", "forward"]
     #   Join strategy.
     # @param suffix [String]
@@ -1873,7 +1936,7 @@ module Polars
     #   # └─────────────┴────────────┴────────────┘
     #
     # @example
-    #   pop2.join_asof(gdp2, by: "country", on: "date", strategy: "nearest").collect
+    #   pop2.join_asof(gdp2, by: "country", on: "date", strategy: "nearest", check_sortedness: false).collect
     #   # =>
     #   # shape: (6, 4)
     #   # ┌─────────────┬────────────┬────────────┬──────┐
@@ -2175,6 +2238,9 @@ module Polars
     #
     # @param exprs [Object]
     #   List of Expressions that evaluate to columns.
+    # @param named_exprs [Hash]
+    #   Additional columns to add, specified as keyword arguments.
+    #   The columns will be renamed to the keyword used.
     #
     # @return [LazyFrame]
     #
@@ -2299,6 +2365,9 @@ module Polars
     # @param columns [Object]
     #   - Name of the column that should be removed.
     #   - List of column names.
+    # @param strict [Boolean]
+    #   Validate that all column names exist in the current schema,
+    #   and throw an exception if any do not.
     #
     # @return [LazyFrame]
     #
@@ -2350,9 +2419,18 @@ module Polars
     #   # │ 7.0 │
     #   # │ 8.0 │
     #   # └─────┘
-    def drop(*columns)
-      drop_cols = Utils._expand_selectors(self, *columns)
-      _from_rbldf(_ldf.drop(drop_cols))
+    def drop(*columns, strict: true)
+      selectors = []
+      columns.each do |c|
+        if c.is_a?(Enumerable)
+          selectors += c
+        else
+          selectors += [c]
+        end
+      end
+
+      drop_cols = Utils.parse_list_into_selector(selectors, strict: strict)
+      _from_rbldf(_ldf.drop(drop_cols._rbselector))
     end
 
     # Rename column names.
@@ -3153,9 +3231,11 @@ module Polars
     #   # │ c       ┆ 7       │
     #   # │ c       ┆ 8       │
     #   # └─────────┴─────────┘
-    def explode(columns)
-      columns = Utils.parse_into_list_of_expressions(columns)
-      _from_rbldf(_ldf.explode(columns))
+    def explode(columns, *more_columns)
+      subset = Utils.parse_list_into_selector(columns) | Utils.parse_list_into_selector(
+        more_columns
+      )
+      _from_rbldf(_ldf.explode(subset._rbselector))
     end
 
     # Drop duplicate rows from this DataFrame.
@@ -3220,10 +3300,11 @@ module Polars
     #   # │ 1   ┆ a   ┆ b   │
     #   # └─────┴─────┴─────┘
     def unique(maintain_order: true, subset: nil, keep: "first")
-      if !subset.nil? && !subset.is_a?(::Array)
-        subset = [subset]
+      selector_subset = nil
+      if !subset.nil?
+        selector_subset = Utils.parse_list_into_selector(subset)._rbselector
       end
-      _from_rbldf(_ldf.unique(maintain_order, subset, keep))
+      _from_rbldf(_ldf.unique(maintain_order, selector_subset, keep))
     end
 
     # Drop rows with null values from this LazyFrame.
@@ -3318,11 +3399,16 @@ module Polars
         warn "The `streamable` parameter for `LazyFrame.unpivot` is deprecated"
       end
 
-      on = on.nil? ? [] : Utils.parse_into_list_of_expressions(on)
-      index = index.nil? ? [] : Utils.parse_into_list_of_expressions(index)
+      selector_on = on.nil? ? Selectors.empty : Utils.parse_list_into_selector(on)
+      selector_index = index.nil? ? Selectors.empty : Utils.parse_list_into_selector(index)
 
       _from_rbldf(
-        _ldf.unpivot(on, index, value_name, variable_name)
+        _ldf.unpivot(
+          selector_on._rbselector,
+          selector_index._rbselector,
+          value_name,
+          variable_name
+        )
       )
     end
     alias_method :melt, :unpivot
@@ -3364,8 +3450,10 @@ module Polars
     # The fields will be inserted into the `DataFrame` on the location of the
     # `struct` type.
     #
-    # @param names [Object]
+    # @param columns [Object]
     #   Names of the struct columns that will be decomposed by its fields
+    # @param more_columns [Array]
+    #   Additional columns to unnest, specified as positional arguments.
     #
     # @return [LazyFrame]
     #
@@ -3410,11 +3498,11 @@ module Polars
     #   # │ foo    ┆ 1   ┆ a   ┆ true ┆ [1, 2]    ┆ baz   │
     #   # │ bar    ┆ 2   ┆ b   ┆ null ┆ [3]       ┆ womp  │
     #   # └────────┴─────┴─────┴──────┴───────────┴───────┘
-    def unnest(names)
-      if names.is_a?(::String)
-        names = [names]
-      end
-      _from_rbldf(_ldf.unnest(names))
+    def unnest(columns, *more_columns)
+      subset = Utils.parse_list_into_selector(columns) | Utils.parse_list_into_selector(
+        more_columns
+      )
+      _from_rbldf(_ldf.unnest(subset._rbselector))
     end
 
     # Take two sorted DataFrames and merge them by the sorted key.

data/lib/polars/list_expr.rb

@@ -136,7 +136,7 @@ module Polars
     #   # │ ---       ┆ --- ┆ ---       │
     #   # │ list[i64] ┆ i64 ┆ list[i64] │
     #   # ╞═══════════╪═════╪═══════════╡
-    #   # │ [1, 2, 3] ┆ 2   ┆ [2, 1]    │
+    #   # │ [1, 2, 3] ┆ 2   ┆ [2, 3]    │
     #   # │ [4, 5]    ┆ 1   ┆ [5]       │
     #   # └───────────┴─────┴───────────┘
     def sample(n: nil, fraction: nil, with_replacement: false, shuffle: false, seed: nil)
@@ -245,6 +245,11 @@ module Polars
 
     # Sort the arrays in the list.
     #
+    # @param reverse [Boolean]
+    #   Sort in descending order.
+    # @param nulls_last [Boolean]
+    #   Place null values last.
+    #
     # @return [Expr]
     #
     # @example
@@ -264,8 +269,8 @@ module Polars
     #   # │ [1, 2, 3] │
     #   # │ [1, 2, 9] │
     #   # └───────────┘
-    def sort(reverse: false)
-      Utils.wrap_expr(_rbexpr.list_sort(reverse))
+    def sort(reverse: false, nulls_last: false)
+      Utils.wrap_expr(_rbexpr.list_sort(reverse, nulls_last))
     end
 
     # Reverse the arrays in the list.
@@ -729,9 +734,21 @@ module Polars
     #
     # @param n_field_strategy ["first_non_null", "max_width"]
     #   Strategy to determine the number of fields of the struct.
-    # @param name_generator [Object]
-    #   A custom function that can be used to generate the field names.
-    #   Default field names are `field_0, field_1 .. field_n`
+    # @param fields pArray
+    #   If the name and number of the desired fields is known in advance
+    #   a list of field names can be given, which will be assigned by index.
+    #   Otherwise, to dynamically assign field names, a custom function can be
+    #   used; if neither are set, fields will be `field_0, field_1 .. field_n`.
+    # @param upper_bound [Object]
+    #   A polars `LazyFrame` needs to know the schema at all times, so the
+    #   caller must provide an upper bound of the number of struct fields that
+    #   will be created; if set incorrectly, subsequent operations may fail.
+    #   (For example, an `all.sum` expression will look in the current
+    #   schema to determine which columns to select).
+    #
+    #   When operating on a `DataFrame`, the schema does not need to be
+    #   tracked or pre-determined, as the result will be eagerly evaluated,
+    #   so you can leave this parameter unset.
     #
     # @return [Expr]
     #
@@ -748,9 +765,8 @@ module Polars
     #   # │ {1,2,3}    │
     #   # │ {1,2,null} │
     #   # └────────────┘
-    def to_struct(n_field_strategy: "first_non_null", name_generator: nil, upper_bound: nil)
-      raise Todo if name_generator
-      Utils.wrap_expr(_rbexpr.list_to_struct(n_field_strategy, name_generator, nil))
+    def to_struct(n_field_strategy: "first_non_null", fields: nil, upper_bound: nil)
+      Utils.wrap_expr(_rbexpr.list_to_struct(n_field_strategy, fields, nil))
     end
 
     # Run any polars expression against the lists' elements.
@@ -758,12 +774,6 @@ module Polars
     # @param expr [Expr]
     #   Expression to run. Note that you can select an element with `Polars.first`, or
     #   `Polars.col`
-    # @param parallel [Boolean]
-    #   Run all expression parallel. Don't activate this blindly.
-    #   Parallelism is worth it if there is enough work to do per thread.
-    #
-    #   This likely should not be use in the group by context, because we already
-    #   parallel execution per group
     #
     # @return [Expr]
     #
@@ -783,8 +793,194 @@ module Polars
     #   # │ 8   ┆ 5   ┆ [2.0, 1.0] │
     #   # │ 3   ┆ 2   ┆ [2.0, 1.0] │
     #   # └─────┴─────┴────────────┘
-    def eval(expr, parallel: false)
-      Utils.wrap_expr(_rbexpr.list_eval(expr._rbexpr, parallel))
+    def eval(expr)
+      Utils.wrap_expr(_rbexpr.list_eval(expr._rbexpr))
+    end
+
+    # Filter elements in each list by a boolean expression.
+    #
+    # @param predicate [Object]
+    #   A boolean expression that is evaluated per list element.
+    #   You can refer to the current element with `Polars.element`.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"a" => [1, 8, 3], "b" => [4, 5, 2]})
+    #   df.with_columns(
+    #     evens: Polars.concat_list("a", "b").list.filter(Polars.element % 2 == 0)
+    #   )
+    #   # =>
+    #   # shape: (3, 3)
+    #   # ┌─────┬─────┬───────────┐
+    #   # │ a   ┆ b   ┆ evens     │
+    #   # │ --- ┆ --- ┆ ---       │
+    #   # │ i64 ┆ i64 ┆ list[i64] │
+    #   # ╞═════╪═════╪═══════════╡
+    #   # │ 1   ┆ 4   ┆ [4]       │
+    #   # │ 8   ┆ 5   ┆ [8]       │
+    #   # │ 3   ┆ 2   ┆ [2]       │
+    #   # └─────┴─────┴───────────┘
+    def filter(predicate)
+      Utils.wrap_expr(_rbexpr.list_filter(predicate._rbexpr))
+    end
+
+    # Compute the SET UNION between the elements in this list and the elements of `other`.
+    #
+    # @param other [Object]
+    #   Right hand side of the set operation.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "a" => [[1, 2, 3], [], [nil, 3], [5, 6, 7]],
+    #       "b" => [[2, 3, 4], [3], [3, 4, nil], [6, 8]]
+    #     }
+    #   )
+    #   df.with_columns(
+    #     union: Polars.col("a").list.set_union("b")
+    #   )
+    #   # =>
+    #   # shape: (4, 3)
+    #   # ┌───────────┬──────────────┬──────────────┐
+    #   # │ a         ┆ b            ┆ union        │
+    #   # │ ---       ┆ ---          ┆ ---          │
+    #   # │ list[i64] ┆ list[i64]    ┆ list[i64]    │
+    #   # ╞═══════════╪══════════════╪══════════════╡
+    #   # │ [1, 2, 3] ┆ [2, 3, 4]    ┆ [1, 2, … 4]  │
+    #   # │ []        ┆ [3]          ┆ [3]          │
+    #   # │ [null, 3] ┆ [3, 4, null] ┆ [null, 3, 4] │
+    #   # │ [5, 6, 7] ┆ [6, 8]       ┆ [5, 6, … 8]  │
+    #   # └───────────┴──────────────┴──────────────┘
+    def set_union(other)
+      if other.respond_to?(:each)
+        if !other.is_a?(::Array) && !other.is_a?(Series) && !other.is_a?(DataFrame)
+          other = other.to_a
+        end
+        other = F.lit(other)._rbexpr
+      else
+        other = Utils.parse_into_expression(other)
+      end
+      Utils.wrap_expr(_rbexpr.list_set_operation(other, "union"))
+    end
+
+    # Compute the SET DIFFERENCE between the elements in this list and the elements of `other`.
+    #
+    # @param other [Object]
+    #   Right hand side of the set operation.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "a" => [[1, 2, 3], [], [nil, 3], [5, 6, 7]],
+    #       "b" => [[2, 3, 4], [3], [3, 4, nil], [6, 8]]
+    #     }
+    #   )
+    #   df.with_columns(difference: Polars.col("a").list.set_difference("b"))
+    #   # =>
+    #   # shape: (4, 3)
+    #   # ┌───────────┬──────────────┬────────────┐
+    #   # │ a         ┆ b            ┆ difference │
+    #   # │ ---       ┆ ---          ┆ ---        │
+    #   # │ list[i64] ┆ list[i64]    ┆ list[i64]  │
+    #   # ╞═══════════╪══════════════╪════════════╡
+    #   # │ [1, 2, 3] ┆ [2, 3, 4]    ┆ [1]        │
+    #   # │ []        ┆ [3]          ┆ []         │
+    #   # │ [null, 3] ┆ [3, 4, null] ┆ []         │
+    #   # │ [5, 6, 7] ┆ [6, 8]       ┆ [5, 7]     │
+    #   # └───────────┴──────────────┴────────────┘
+    def set_difference(other)
+      if other.respond_to?(:each)
+        if !other.is_a?(::Array) && !other.is_a?(Series) && !other.is_a?(DataFrame)
+          other = other.to_a
+        end
+        other = F.lit(other)._rbexpr
+      else
+        other = Utils.parse_into_expression(other)
+      end
+      Utils.wrap_expr(_rbexpr.list_set_operation(other, "difference"))
+    end
+
+    # Compute the SET INTERSECTION between the elements in this list and the elements of `other`.
+    #
+    # @param other [Object]
+    #   Right hand side of the set operation.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "a" => [[1, 2, 3], [], [nil, 3], [5, 6, 7]],
+    #       "b" => [[2, 3, 4], [3], [3, 4, nil], [6, 8]]
+    #     }
+    #   )
+    #   df.with_columns(intersection: Polars.col("a").list.set_intersection("b"))
+    #   # =>
+    #   # shape: (4, 3)
+    #   # ┌───────────┬──────────────┬──────────────┐
+    #   # │ a         ┆ b            ┆ intersection │
+    #   # │ ---       ┆ ---          ┆ ---          │
+    #   # │ list[i64] ┆ list[i64]    ┆ list[i64]    │
+    #   # ╞═══════════╪══════════════╪══════════════╡
+    #   # │ [1, 2, 3] ┆ [2, 3, 4]    ┆ [2, 3]       │
+    #   # │ []        ┆ [3]          ┆ []           │
+    #   # │ [null, 3] ┆ [3, 4, null] ┆ [null, 3]    │
+    #   # │ [5, 6, 7] ┆ [6, 8]       ┆ [6]          │
+    #   # └───────────┴──────────────┴──────────────┘
+    def set_intersection(other)
+      if other.respond_to?(:each)
+        if !other.is_a?(::Array) && !other.is_a?(Series) && !other.is_a?(DataFrame)
+          other = other.to_a
+        end
+        other = F.lit(other)._rbexpr
+      else
+        other = Utils.parse_into_expression(other)
+      end
+      Utils.wrap_expr(_rbexpr.list_set_operation(other, "intersection"))
+    end
+
+    # Compute the SET SYMMETRIC DIFFERENCE between the elements in this list and the elements of `other`.
+    #
+    # @param other [Object]
+    #   Right hand side of the set operation.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "a" => [[1, 2, 3], [], [nil, 3], [5, 6, 7]],
+    #       "b" => [[2, 3, 4], [3], [3, 4, nil], [6, 8]]
+    #     }
+    #   )
+    #   df.with_columns(sdiff: Polars.col("b").list.set_symmetric_difference("a"))
+    #   # =>
+    #   # shape: (4, 3)
+    #   # ┌───────────┬──────────────┬───────────┐
+    #   # │ a         ┆ b            ┆ sdiff     │
+    #   # │ ---       ┆ ---          ┆ ---       │
+    #   # │ list[i64] ┆ list[i64]    ┆ list[i64] │
+    #   # ╞═══════════╪══════════════╪═══════════╡
+    #   # │ [1, 2, 3] ┆ [2, 3, 4]    ┆ [4, 1]    │
+    #   # │ []        ┆ [3]          ┆ [3]       │
+    #   # │ [null, 3] ┆ [3, 4, null] ┆ [4]       │
+    #   # │ [5, 6, 7] ┆ [6, 8]       ┆ [8, 5, 7] │
+    #   # └───────────┴──────────────┴───────────┘
+    def set_symmetric_difference(other)
+      if other.respond_to?(:each)
+        if !other.is_a?(::Array) && !other.is_a?(Series) && !other.is_a?(DataFrame)
+          other = other.to_a
+        end
+        other = F.lit(other)._rbexpr
+      else
+        other = Utils.parse_into_expression(other)
+      end
+      Utils.wrap_expr(_rbexpr.list_set_operation(other, "symmetric_difference"))
     end
   end
 end