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

data/lib/polars/selectors.rb

@@ -1,118 +1,5 @@
 module Polars
   module Selectors
-    # @private
-    class SelectorProxy < Expr
-      attr_accessor :_attrs
-      attr_accessor :_repr_override
-
-      def initialize(
-        expr,
-        name:,
-        parameters: nil
-      )
-        self._rbexpr = expr._rbexpr
-        self._attrs = {
-          name: name,
-          params: parameters
-        }
-      end
-
-      def inspect
-        if !_attrs
-          as_expr.inspect
-        elsif _repr_override
-          _repr_override
-        else
-          selector_name = _attrs[:name]
-          params = _attrs[:params] || {}
-          set_ops = {"and" => "&", "or" => "|", "sub" => "-", "xor" => "^"}
-          if set_ops.include?(selector_name)
-            op = set_ops[selector_name]
-            "(#{params.values.map(&:inspect).join(" #{op} ")})"
-          else
-            str_params = params.map { |k, v| k.start_with?("*") ? v.inspect[1..-2] : "#{k}=#{v.inspect}" }.join(", ")
-            "Polars.cs.#{selector_name}(#{str_params})"
-          end
-        end
-      end
-
-      def ~
-        if Utils.is_selector(self)
-          inverted = Selectors.all - self
-          inverted._repr_override = "~#{inspect}"
-        else
-          inverted = ~as_expr
-        end
-        inverted
-      end
-
-      def -(other)
-        if Utils.is_selector(other)
-          SelectorProxy.new(
-            meta._as_selector.meta._selector_sub(other),
-            parameters: {"self" => self, "other" => other},
-            name: "sub"
-          )
-        else
-          as_expr - other
-        end
-      end
-
-      def &(other)
-        if Utils.is_column(other)
-          raise Todo
-        end
-        if Utils.is_selector(other)
-          SelectorProxy.new(
-            meta._as_selector.meta._selector_and(other),
-            parameters: {"self" => self, "other" => other},
-            name: "and"
-          )
-        else
-          as_expr & other
-        end
-      end
-
-      def |(other)
-        if Utils.is_column(other)
-          raise Todo
-        end
-        if Utils.is_selector(other)
-          SelectorProxy.new(
-            meta._as_selector.meta._selector_and(other),
-            parameters: {"self" => self, "other" => other},
-            name: "or"
-          )
-        else
-          as_expr | other
-        end
-      end
-
-      def ^(other)
-        if Utils.is_column(other)
-          raise Todo
-        end
-        if Utils.is_selector(other)
-          SelectorProxy.new(
-            meta._as_selector.meta._selector_and(other),
-            parameters: {"self" => self, "other" => other},
-            name: "xor"
-          )
-        else
-          as_expr ^ other
-        end
-      end
-
-      def as_expr
-        Expr._from_rbexpr(_rbexpr)
-      end
-    end
-
-    # @private
-    def self._selector_proxy_(...)
-      SelectorProxy.new(...)
-    end
-
     # @private
     def self._re_string(string, escape: true)
       if string.is_a?(::String)
@@ -131,9 +18,26 @@ module Polars
       "(#{rx})"
     end
 
+    # Select no columns.
+    #
+    # This is useful for composition with other selectors.
+    #
+    # @return [Selector]
+    #
+    # @example
+    #   Polars::DataFrame.new({"a" => 1, "b" => 2}).select(Polars.cs.empty)
+    #   # =>
+    #   # shape: (0, 0)
+    #   # ┌┐
+    #   # ╞╡
+    #   # └┘
+    def self.empty
+      Selector._from_rbselector(RbSelector.empty)
+    end
+
     # Select all columns.
     #
-    # @return [SelectorProxy]
+    # @return [Selector]
     #
     # @example
     #   df = Polars::DataFrame.new(
@@ -170,7 +74,7 @@ module Polars
     #   # │ 2024-01-01 │
     #   # └────────────┘
     def self.all
-      _selector_proxy_(F.all, name: "all")
+      Selector._from_rbselector(RbSelector.all)
     end
 
     # Select all columns with alphabetic names (eg: only letters).
@@ -182,7 +86,7 @@ module Polars
     #   Indicate whether to ignore the presence of spaces in column names; if so,
     #   only the other (non-space) characters are considered.
     #
-    # @return [SelectorProxy]
+    # @return [Selector]
     #
     # @note
     #   Matching column names cannot contain *any* non-alphabetic characters. Note
@@ -274,20 +178,102 @@ module Polars
       # note that we need to supply a pattern compatible with the *rust* regex crate
       re_alpha = ascii_only ? "a-zA-Z" : "\\p{Alphabetic}"
       re_space = ignore_spaces ? " " : ""
-      _selector_proxy_(
-        F.col("^[#{re_alpha}#{re_space}]+$"),
-        name: "alpha",
-        parameters: {"ascii_only" => ascii_only, "ignore_spaces" => ignore_spaces},
-      )
+      Selector._from_rbselector(RbSelector.matches("^[#{re_alpha}#{re_space}]+$"))
     end
 
-    # TODO
-    # def alphanumeric
-    # end
+    # Select all columns with alphanumeric names (eg: only letters and the digits 0-9).
+    #
+    # @param ascii_only [Boolean]
+    #   Indicate whether to consider only ASCII alphabetic characters, or the full
+    #   Unicode range of valid letters (accented, idiographic, etc).
+    # @param ignore_spaces [Boolean]
+    #   Indicate whether to ignore the presence of spaces in column names; if so,
+    #   only the other (non-space) characters are considered.
+    #
+    # @return [Selector]
+    #
+    # @note
+    #   Matching column names cannot contain *any* non-alphabetic or integer characters.
+    #   Note that the definition of "alphabetic" consists of all valid Unicode alphabetic
+    #   characters (`\p{Alphabetic}`) and digit characters (`\d`) by default; this
+    #   can be changed by setting `ascii_only: true`.
+    #
+    # @example Select columns with alphanumeric names:
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "1st_col" => [100, 200, 300],
+    #       "flagged" => [true, false, true],
+    #       "00prefix" => ["01:aa", "02:bb", "03:cc"],
+    #       "last col" => ["x", "y", "z"]
+    #     }
+    #   )
+    #   df.select(Polars.cs.alphanumeric)
+    #   # =>
+    #   # shape: (3, 2)
+    #   # ┌─────────┬──────────┐
+    #   # │ flagged ┆ 00prefix │
+    #   # │ ---     ┆ ---      │
+    #   # │ bool    ┆ str      │
+    #   # ╞═════════╪══════════╡
+    #   # │ true    ┆ 01:aa    │
+    #   # │ false   ┆ 02:bb    │
+    #   # │ true    ┆ 03:cc    │
+    #   # └─────────┴──────────┘
+    #
+    # @example
+    #   df.select(Polars.cs.alphanumeric(ignore_spaces: true))
+    #   # =>
+    #   # shape: (3, 3)
+    #   # ┌─────────┬──────────┬──────────┐
+    #   # │ flagged ┆ 00prefix ┆ last col │
+    #   # │ ---     ┆ ---      ┆ ---      │
+    #   # │ bool    ┆ str      ┆ str      │
+    #   # ╞═════════╪══════════╪══════════╡
+    #   # │ true    ┆ 01:aa    ┆ x        │
+    #   # │ false   ┆ 02:bb    ┆ y        │
+    #   # │ true    ┆ 03:cc    ┆ z        │
+    #   # └─────────┴──────────┴──────────┘
+    #
+    # @example Select all columns *except* for those with alphanumeric names:
+    #   df.select(~Polars.cs.alphanumeric)
+    #   # =>
+    #   # shape: (3, 2)
+    #   # ┌─────────┬──────────┐
+    #   # │ 1st_col ┆ last col │
+    #   # │ ---     ┆ ---      │
+    #   # │ i64     ┆ str      │
+    #   # ╞═════════╪══════════╡
+    #   # │ 100     ┆ x        │
+    #   # │ 200     ┆ y        │
+    #   # │ 300     ┆ z        │
+    #   # └─────────┴──────────┘
+    #
+    # @example
+    #   df.select(~Polars.cs.alphanumeric(ignore_spaces: true))
+    #   # =>
+    #   # shape: (3, 1)
+    #   # ┌─────────┐
+    #   # │ 1st_col │
+    #   # │ ---     │
+    #   # │ i64     │
+    #   # ╞═════════╡
+    #   # │ 100     │
+    #   # │ 200     │
+    #   # │ 300     │
+    #   # └─────────┘
+    def self.alphanumeric(ascii_only: false, ignore_spaces: false)
+      # note that we need to supply patterns compatible with the *rust* regex crate
+      re_alpha = ascii_only ? "a-zA-Z" : "\\p{Alphabetic}"
+      re_digit = ascii_only ? "0-9" : "\\d"
+      re_space = ignore_spaces ? " " : ""
+      return Selector._from_rbselector(
+        RbSelector.matches("^[#{re_alpha}#{re_digit}#{re_space}]+$")
+      )
+    end
 
     # Select all binary columns.
     #
-    # @return [SelectorProxy]
+    # @return [Selector]
     #
     # @example
     #   df = Polars::DataFrame.new({"a" => ["hello".b], "b" => ["world"], "c" => ["!".b], "d" => [":)"]})
@@ -309,12 +295,12 @@ module Polars
     #   df.select(~Polars.cs.binary).to_h(as_series: false)
     #   # => {"b"=>["world"], "d"=>[":)"]}
     def self.binary
-      _selector_proxy_(F.col(Binary), name: "binary")
+      by_dtype([Binary])
     end
 
     # Select all boolean columns.
     #
-    # @return [SelectorProxy]
+    # @return [Selector]
     #
     # @example
     #   df = Polars::DataFrame.new({"n" => 1..4}).with_columns(n_even: Polars.col("n") % 2 == 0)
@@ -361,16 +347,173 @@ module Polars
     #   # │ 4   │
     #   # └─────┘
     def self.boolean
-      _selector_proxy_(F.col(Boolean), name: "boolean")
+      by_dtype([Boolean])
+    end
+
+    # Select all columns matching the given dtypes.
+    #
+    # @return [Selector]
+    #
+    # @example Select all columns with date or string dtypes:
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "dt" => [Date.new(1999, 12, 31), Date.new(2024, 1, 1), Date.new(2010, 7, 5)],
+    #       "value" => [1_234_500, 5_000_555, -4_500_000],
+    #       "other" => ["foo", "bar", "foo"]
+    #     }
+    #   )
+    #   df.select(Polars.cs.by_dtype(Polars::Date, Polars::String))
+    #   # =>
+    #   # shape: (3, 2)
+    #   # ┌────────────┬───────┐
+    #   # │ dt         ┆ other │
+    #   # │ ---        ┆ ---   │
+    #   # │ date       ┆ str   │
+    #   # ╞════════════╪═══════╡
+    #   # │ 1999-12-31 ┆ foo   │
+    #   # │ 2024-01-01 ┆ bar   │
+    #   # │ 2010-07-05 ┆ foo   │
+    #   # └────────────┴───────┘
+    #
+    # @example Select all columns that are not of date or string dtype:
+    #   df.select(~Polars.cs.by_dtype(Polars::Date, Polars::String))
+    #   # =>
+    #   # shape: (3, 1)
+    #   # ┌──────────┐
+    #   # │ value    │
+    #   # │ ---      │
+    #   # │ i64      │
+    #   # ╞══════════╡
+    #   # │ 1234500  │
+    #   # │ 5000555  │
+    #   # │ -4500000 │
+    #   # └──────────┘
+    #
+    # Group by string columns and sum the numeric columns:
+    #   df.group_by(Polars.cs.string).agg(Polars.cs.numeric.sum).sort("other")
+    #   # =>
+    #   # shape: (2, 2)
+    #   # ┌───────┬──────────┐
+    #   # │ other ┆ value    │
+    #   # │ ---   ┆ ---      │
+    #   # │ str   ┆ i64      │
+    #   # ╞═══════╪══════════╡
+    #   # │ bar   ┆ 5000555  │
+    #   # │ foo   ┆ -3265500 │
+    #   # └───────┴──────────┘
+    def self.by_dtype(*dtypes)
+      all_dtypes = []
+      dtypes.each do |tp|
+        if Utils.is_polars_dtype(tp) || tp.is_a?(Class)
+          all_dtypes << tp
+        elsif tp.is_a?(::Array)
+          tp.each do |t|
+            if !(Utils.is_polars_dtype(t) || t.is_a?(Class))
+              msg = "invalid dtype: #{t.inspect}"
+              raise TypeError, msg
+            end
+            all_dtypes << t
+          end
+        else
+          msg = "invalid dtype: #{tp.inspect}"
+          raise TypeError, msg
+        end
+      end
+
+      Selector._by_dtype(all_dtypes)
     end
 
-    # TODO
-    # def by_dtype
-    # end
+    # Select all columns matching the given indices (or range objects).
+    #
+    # @param indices [Array]
+    #   One or more column indices (or range objects).
+    #   Negative indexing is supported.
+    #
+    # @return [Selector]
+    #
+    # @note
+    #   Matching columns are returned in the order in which their indexes
+    #   appear in the selector, not the underlying schema order.
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "key" => ["abc"],
+    #       **100.times.to_h { |i| ["c%02d" % i, 0.5 * i] }
+    #     }
+    #   )
+    #   # =>
+    #   # shape: (1, 101)
+    #   # ┌─────┬─────┬─────┬─────┬───┬──────┬──────┬──────┬──────┐
+    #   # │ key ┆ c00 ┆ c01 ┆ c02 ┆ … ┆ c96  ┆ c97  ┆ c98  ┆ c99  │
+    #   # │ --- ┆ --- ┆ --- ┆ --- ┆   ┆ ---  ┆ ---  ┆ ---  ┆ ---  │
+    #   # │ str ┆ f64 ┆ f64 ┆ f64 ┆   ┆ f64  ┆ f64  ┆ f64  ┆ f64  │
+    #   # ╞═════╪═════╪═════╪═════╪═══╪══════╪══════╪══════╪══════╡
+    #   # │ abc ┆ 0.0 ┆ 0.5 ┆ 1.0 ┆ … ┆ 48.0 ┆ 48.5 ┆ 49.0 ┆ 49.5 │
+    #   # └─────┴─────┴─────┴─────┴───┴──────┴──────┴──────┴──────┘
+    #
+    # @example Select columns by index ("key" column and the two first/last columns):
+    #   df.select(Polars.cs.by_index(0, 1, 2, -2, -1))
+    #   # =>
+    #   # shape: (1, 5)
+    #   # ┌─────┬─────┬─────┬──────┬──────┐
+    #   # │ key ┆ c00 ┆ c01 ┆ c98  ┆ c99  │
+    #   # │ --- ┆ --- ┆ --- ┆ ---  ┆ ---  │
+    #   # │ str ┆ f64 ┆ f64 ┆ f64  ┆ f64  │
+    #   # ╞═════╪═════╪═════╪══════╪══════╡
+    #   # │ abc ┆ 0.0 ┆ 0.5 ┆ 49.0 ┆ 49.5 │
+    #   # └─────┴─────┴─────┴──────┴──────┘
+    #
+    # @example Select the "key" column and use a `range` object to select various columns.
+    #   df.select(Polars.cs.by_index(0, (1...101).step(20)))
+    #   # =>
+    #   # shape: (1, 6)
+    #   # ┌─────┬─────┬──────┬──────┬──────┬──────┐
+    #   # │ key ┆ c00 ┆ c20  ┆ c40  ┆ c60  ┆ c80  │
+    #   # │ --- ┆ --- ┆ ---  ┆ ---  ┆ ---  ┆ ---  │
+    #   # │ str ┆ f64 ┆ f64  ┆ f64  ┆ f64  ┆ f64  │
+    #   # ╞═════╪═════╪══════╪══════╪══════╪══════╡
+    #   # │ abc ┆ 0.0 ┆ 10.0 ┆ 20.0 ┆ 30.0 ┆ 40.0 │
+    #   # └─────┴─────┴──────┴──────┴──────┴──────┘
+    #
+    # @example
+    #   df.select(Polars.cs.by_index(0, (101...0).step(-25), require_all: false))
+    #   # =>
+    #   # shape: (1, 5)
+    #   # ┌─────┬──────┬──────┬──────┬─────┐
+    #   # │ key ┆ c75  ┆ c50  ┆ c25  ┆ c00 │
+    #   # │ --- ┆ ---  ┆ ---  ┆ ---  ┆ --- │
+    #   # │ str ┆ f64  ┆ f64  ┆ f64  ┆ f64 │
+    #   # ╞═════╪══════╪══════╪══════╪═════╡
+    #   # │ abc ┆ 37.5 ┆ 25.0 ┆ 12.5 ┆ 0.0 │
+    #   # └─────┴──────┴──────┴──────┴─────┘
+    #
+    # @example Select all columns *except* for the even-indexed ones:
+    #   df.select(~Polars.cs.by_index((1...100).step(2)))
+    #   # =>
+    #   # shape: (1, 51)
+    #   # ┌─────┬─────┬─────┬─────┬───┬──────┬──────┬──────┬──────┐
+    #   # │ key ┆ c01 ┆ c03 ┆ c05 ┆ … ┆ c93  ┆ c95  ┆ c97  ┆ c99  │
+    #   # │ --- ┆ --- ┆ --- ┆ --- ┆   ┆ ---  ┆ ---  ┆ ---  ┆ ---  │
+    #   # │ str ┆ f64 ┆ f64 ┆ f64 ┆   ┆ f64  ┆ f64  ┆ f64  ┆ f64  │
+    #   # ╞═════╪═════╪═════╪═════╪═══╪══════╪══════╪══════╪══════╡
+    #   # │ abc ┆ 0.5 ┆ 1.5 ┆ 2.5 ┆ … ┆ 46.5 ┆ 47.5 ┆ 48.5 ┆ 49.5 │
+    #   # └─────┴─────┴─────┴─────┴───┴──────┴──────┴──────┴──────┘
+    def self.by_index(*indices, require_all: true)
+      all_indices = []
+      indices.each do |idx|
+        if idx.is_a?(Enumerable)
+          all_indices.concat(idx.to_a)
+        elsif idx.is_a?(Integer)
+          all_indices << idx
+        else
+          msg = "invalid index value: #{idx.inspect}"
+          raise TypeError, msg
+        end
+      end
 
-    # TODO
-    # def by_index
-    # end
+      Selector._from_rbselector(RbSelector.by_index(all_indices, require_all))
+    end
 
     # Select all columns matching the given names.
     #
@@ -379,7 +522,7 @@ module Polars
     # @param require_all [Boolean]
     #   Whether to match *all* names (the default) or *any* of the names.
     #
-    # @return [SelectorProxy]
+    # @return [Selector]
     #
     # @note
     #   Matching columns are returned in the order in which they are declared in
@@ -413,12 +556,12 @@ module Polars
     #   # =>
     #   # shape: (2, 2)
     #   # ┌─────┬─────┐
-    #   # │ foo ┆ baz │
+    #   # │ baz ┆ foo │
     #   # │ --- ┆ --- │
-    #   # │ str ┆ f64 │
+    #   # │ f64 ┆ str │
     #   # ╞═════╪═════╡
-    #   # │ x   ┆ 2.0 │
-    #   # │ y   ┆ 5.5 │
+    #   # │ 2.0 ┆ x   │
+    #   # │ 5.5 ┆ y   │
     #   # └─────┴─────┘
     #
     # @example Match all columns *except* for those given:
@@ -438,29 +581,316 @@ module Polars
       names.each do |nm|
         if nm.is_a?(::String)
           all_names << nm
+        elsif nm.is_a?(::Array)
+          nm.each do |n|
+            if !n.is_a?(::String)
+              msg = "invalid name: #{n.inspect}"
+              raise TypeError, msg
+            end
+            all_names << n
+          end
         else
           msg = "invalid name: #{nm.inspect}"
           raise TypeError, msg
         end
       end
 
-      selector_params = {"*names" => all_names}
-      match_cols = all_names
-      if !require_all
-        match_cols = "^(#{all_names.map { |nm| Utils.re_escape(nm) }.join("|")})$"
-        selector_params["require_all"] = require_all
-      end
+      Selector._by_name(all_names, strict: require_all)
+    end
 
-      _selector_proxy_(
-        F.col(match_cols),
-        name: "by_name",
-        parameters: selector_params
-      )
+    # Select all enum columns.
+    #
+    # @return [Selector]
+    #
+    # @note
+    #   This functionality is considered **unstable**. It may be changed
+    #   at any point without it being considered a breaking change.
+    #
+    # @example Select all enum columns:
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "foo" => ["xx", "yy"],
+    #       "bar" => [123, 456],
+    #       "baz" => [2.0, 5.5],
+    #     },
+    #     schema_overrides: {"foo" => Polars::Enum.new(["xx", "yy"])}
+    #   )
+    #   df.select(Polars.cs.enum)
+    #   # =>
+    #   # shape: (2, 1)
+    #   # ┌──────┐
+    #   # │ foo  │
+    #   # │ ---  │
+    #   # │ enum │
+    #   # ╞══════╡
+    #   # │ xx   │
+    #   # │ yy   │
+    #   # └──────┘
+    #
+    # @example Select all columns *except* for those that are enum:
+    #   df.select(~Polars.cs.enum())
+    #   # =>
+    #   # shape: (2, 2)
+    #   # ┌─────┬─────┐
+    #   # │ bar ┆ baz │
+    #   # │ --- ┆ --- │
+    #   # │ i64 ┆ f64 │
+    #   # ╞═════╪═════╡
+    #   # │ 123 ┆ 2.0 │
+    #   # │ 456 ┆ 5.5 │
+    #   # └─────┴─────┘
+    def self.enum
+      Selector._from_rbselector(RbSelector.enum_)
+    end
+
+    # Select all list columns.
+    #
+    # @return [Selector]
+    #
+    # @note
+    #   This functionality is considered **unstable**. It may be changed
+    #   at any point without it being considered a breaking change.
+    #
+    # @example Select all list columns:
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "foo" => [["xx", "yy"], ["x"]],
+    #       "bar" => [123, 456],
+    #       "baz" => [2.0, 5.5]
+    #     }
+    #   )
+    #   df.select(Polars.cs.list)
+    #   # =>
+    #   # shape: (2, 1)
+    #   # ┌──────────────┐
+    #   # │ foo          │
+    #   # │ ---          │
+    #   # │ list[str]    │
+    #   # ╞══════════════╡
+    #   # │ ["xx", "yy"] │
+    #   # │ ["x"]        │
+    #   # └──────────────┘
+    #
+    # @example Select all columns *except* for those that are list:
+    #   df.select(~Polars.cs.list)
+    #   # =>
+    #   # shape: (2, 2)
+    #   # ┌─────┬─────┐
+    #   # │ bar ┆ baz │
+    #   # │ --- ┆ --- │
+    #   # │ i64 ┆ f64 │
+    #   # ╞═════╪═════╡
+    #   # │ 123 ┆ 2.0 │
+    #   # │ 456 ┆ 5.5 │
+    #   # └─────┴─────┘
+    #
+    # @example Select all list columns with a certain matching inner type:
+    #   df.select(Polars.cs.list(Polars.cs.string))
+    #   # =>
+    #   # shape: (2, 1)
+    #   # ┌──────────────┐
+    #   # │ foo          │
+    #   # │ ---          │
+    #   # │ list[str]    │
+    #   # ╞══════════════╡
+    #   # │ ["xx", "yy"] │
+    #   # │ ["x"]        │
+    #   # └──────────────┘
+    #
+    # @example
+    #   df.select(Polars.cs.list(Polars.cs.integer))
+    #   # =>
+    #   # shape: (0, 0)
+    #   # ┌┐
+    #   # ╞╡
+    #   # └┘
+    def self.list(inner = nil)
+      inner_s = !inner.nil? ? inner._rbselector : nil
+      Selector._from_rbselector(RbSelector.list(inner_s))
+    end
+
+    # Select all array columns.
+    #
+    # @return [Selector]
+    #
+    # @note
+    #   This functionality is considered **unstable**. It may be changed
+    #   at any point without it being considered a breaking change.
+    #
+    # @example Select all array columns:
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "foo" => [["xx", "yy"], ["x", "y"]],
+    #       "bar" => [123, 456],
+    #       "baz" => [2.0, 5.5]
+    #     },
+    #     schema_overrides: {"foo" => Polars::Array.new(Polars::String, 2)}
+    #   )
+    #   df.select(Polars.cs.array)
+    #   # =>
+    #   # shape: (2, 1)
+    #   # ┌───────────────┐
+    #   # │ foo           │
+    #   # │ ---           │
+    #   # │ array[str, 2] │
+    #   # ╞═══════════════╡
+    #   # │ ["xx", "yy"]  │
+    #   # │ ["x", "y"]    │
+    #   # └───────────────┘
+    #
+    # @example Select all columns *except* for those that are array:
+    #   df.select(~Polars.cs.array)
+    #   # =>
+    #   # shape: (2, 2)
+    #   # ┌─────┬─────┐
+    #   # │ bar ┆ baz │
+    #   # │ --- ┆ --- │
+    #   # │ i64 ┆ f64 │
+    #   # ╞═════╪═════╡
+    #   # │ 123 ┆ 2.0 │
+    #   # │ 456 ┆ 5.5 │
+    #   # └─────┴─────┘
+    #
+    # @example Select all array columns with a certain matching inner type:
+    #   df.select(Polars.cs.array(Polars.cs.string))
+    #   # =>
+    #   # shape: (2, 1)
+    #   # ┌───────────────┐
+    #   # │ foo           │
+    #   # │ ---           │
+    #   # │ array[str, 2] │
+    #   # ╞═══════════════╡
+    #   # │ ["xx", "yy"]  │
+    #   # │ ["x", "y"]    │
+    #   # └───────────────┘
+    #
+    # @example
+    #   df.select(Polars.cs.array(Polars.cs.integer))
+    #   # =>
+    #   # shape: (0, 0)
+    #   # ┌┐
+    #   # ╞╡
+    #   # └┘
+    #
+    # @example
+    #   df.select(Polars.cs.array(width: 2))
+    #   # =>
+    #   # shape: (2, 1)
+    #   # ┌───────────────┐
+    #   # │ foo           │
+    #   # │ ---           │
+    #   # │ array[str, 2] │
+    #   # ╞═══════════════╡
+    #   # │ ["xx", "yy"]  │
+    #   # │ ["x", "y"]    │
+    #   # └───────────────┘
+    #
+    # @example
+    #   df.select(Polars.cs.array(width: 3))
+    #   # =>
+    #   # shape: (0, 0)
+    #   # ┌┐
+    #   # ╞╡
+    #   # └┘
+    def self.array(inner = nil, width: nil)
+      inner_s = !inner.nil? ? inner._rbselector : nil
+      Selector._from_rbselector(RbSelector.array(inner_s, width))
+    end
+
+    # Select all struct columns.
+    #
+    # @return [Selector]
+    #
+    # @note
+    #   This functionality is considered **unstable**. It may be changed
+    #   at any point without it being considered a breaking change.
+    #
+    # @example Select all struct columns:
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "foo" => [{"a": "xx", "b": "z"}, {"a": "x", "b": "y"}],
+    #       "bar" => [123, 456],
+    #       "baz" => [2.0, 5.5]
+    #     }
+    #   )
+    #   df.select(Polars.cs.struct)
+    #   # =>
+    #   # shape: (2, 1)
+    #   # ┌────────────┐
+    #   # │ foo        │
+    #   # │ ---        │
+    #   # │ struct[2]  │
+    #   # ╞════════════╡
+    #   # │ {"xx","z"} │
+    #   # │ {"x","y"}  │
+    #   # └────────────┘
+    #
+    # @example Select all columns *except* for those that are struct:
+    #   df.select(~Polars.cs.struct)
+    #   # =>
+    #   # shape: (2, 2)
+    #   # ┌─────┬─────┐
+    #   # │ bar ┆ baz │
+    #   # │ --- ┆ --- │
+    #   # │ i64 ┆ f64 │
+    #   # ╞═════╪═════╡
+    #   # │ 123 ┆ 2.0 │
+    #   # │ 456 ┆ 5.5 │
+    #   # └─────┴─────┘
+    def self.struct
+      Selector._from_rbselector(RbSelector.struct_)
+    end
+
+    # Select all nested columns.
+    #
+    # A nested column is a list, array or struct.
+    #
+    # @return [Selector]
+    #
+    # @note
+    #   This functionality is considered **unstable**. It may be changed
+    #   at any point without it being considered a breaking change.
+    #
+    # @example Select all nested columns:
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "foo" => [{"a" => "xx", "b" => "z"}, {"a" => "x", "b" => "y"}],
+    #       "bar" => [123, 456],
+    #       "baz" => [2.0, 5.5],
+    #       "wow" => [[1, 2], [3]]
+    #     }
+    #   )
+    #   df.select(Polars.cs.nested)
+    #   # =>
+    #   # shape: (2, 2)
+    #   # ┌────────────┬───────────┐
+    #   # │ foo        ┆ wow       │
+    #   # │ ---        ┆ ---       │
+    #   # │ struct[2]  ┆ list[i64] │
+    #   # ╞════════════╪═══════════╡
+    #   # │ {"xx","z"} ┆ [1, 2]    │
+    #   # │ {"x","y"}  ┆ [3]       │
+    #   # └────────────┴───────────┘
+    #
+    # @example Select all columns *except* for those that are nested:
+    #   df.select(~Polars.cs.nested)
+    #   # =>
+    #   # shape: (2, 2)
+    #   # ┌─────┬─────┐
+    #   # │ bar ┆ baz │
+    #   # │ --- ┆ --- │
+    #   # │ i64 ┆ f64 │
+    #   # ╞═════╪═════╡
+    #   # │ 123 ┆ 2.0 │
+    #   # │ 456 ┆ 5.5 │
+    #   # └─────┴─────┘
+    def self.nested
+      Selector._from_rbselector(RbSelector.nested)
     end
 
     # Select all categorical columns.
     #
-    # @return [SelectorProxy]
+    # @return [Selector]
     #
     # @example
     #   df = Polars::DataFrame.new(
@@ -498,7 +928,7 @@ module Polars
     #   # │ 456 ┆ 5.5 │
     #   # └─────┴─────┘
     def self.categorical
-      _selector_proxy_(F.col(Categorical), name: "categorical")
+      Selector._from_rbselector(RbSelector.categorical())
     end
 
     # Select columns whose names contain the given literal substring(s).
@@ -506,7 +936,7 @@ module Polars
     # @param substring [Object]
     #   Substring(s) that matching column names should contain.
     #
-    # @return [SelectorProxy]
+    # @return [Selector]
     #
     # @example
     #   df = Polars::DataFrame.new(
@@ -560,16 +990,12 @@ module Polars
       escaped_substring = _re_string(substring)
       raw_params = "^.*#{escaped_substring}.*$"
 
-      _selector_proxy_(
-        F.col(raw_params),
-        name: "contains",
-        parameters: {"*substring" => escaped_substring}
-      )
+      Selector._from_rbselector(RbSelector.matches(raw_params))
     end
 
     # Select all date columns.
     #
-    # @return [SelectorProxy]
+    # @return [Selector]
     #
     # @example
     #   df = Polars::DataFrame.new(
@@ -605,16 +1031,23 @@ module Polars
     #   # │ 2031-12-31 00:30:00 │
     #   # └─────────────────────┘
     def self.date
-      _selector_proxy_(F.col(Date), name: "date")
+      by_dtype([Date])
     end
 
-    # TODO
-    # def datetime
-    # end
+    # Select all datetime columns, optionally filtering by time unit/zone.
+    #
+    # @return [Selector]
+    def self.datetime
+      time_unit = ["ms", "us", "ns"]
+
+      time_zone = [nil]
+
+      Selector._from_rbselector(RbSelector.datetime(time_unit, time_zone))
+    end
 
     # Select all decimal columns.
     #
-    # @return [SelectorProxy]
+    # @return [Selector]
     #
     # @example
     #   df = Polars::DataFrame.new(
@@ -654,7 +1087,104 @@ module Polars
     #   # └─────┘
     def self.decimal
       # TODO: allow explicit selection by scale/precision?
-      _selector_proxy_(F.col(Decimal), name: "decimal")
+      Selector._from_rbselector(RbSelector.decimal)
+    end
+
+    # Select all columns having names consisting only of digits.
+    #
+    # @return [Selector]
+    #
+    # @note
+    #   Matching column names cannot contain *any* non-digit characters. Note that the
+    #   definition of "digit" consists of all valid Unicode digit characters (`\d`)
+    #   by default; this can be changed by setting `ascii_only: true`.
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "key" => ["aaa", "bbb", "aaa", "bbb", "bbb"],
+    #       "year" => [2001, 2001, 2025, 2025, 2001],
+    #       "value" => [-25, 100, 75, -15, -5]
+    #     }
+    #   ).pivot(
+    #     "year",
+    #     values: "value",
+    #     index: "key",
+    #     aggregate_function: "sum"
+    #   )
+    #   # =>
+    #   # shape: (2, 3)
+    #   # ┌─────┬──────┬──────┐
+    #   # │ key ┆ 2001 ┆ 2025 │
+    #   # │ --- ┆ ---  ┆ ---  │
+    #   # │ str ┆ i64  ┆ i64  │
+    #   # ╞═════╪══════╪══════╡
+    #   # │ aaa ┆ -25  ┆ 75   │
+    #   # │ bbb ┆ 95   ┆ -15  │
+    #   # └─────┴──────┴──────┘
+    #
+    # @example Select columns with digit names:
+    #   df.select(Polars.cs.digit)
+    #   # =>
+    #   # shape: (2, 2)
+    #   # ┌──────┬──────┐
+    #   # │ 2001 ┆ 2025 │
+    #   # │ ---  ┆ ---  │
+    #   # │ i64  ┆ i64  │
+    #   # ╞══════╪══════╡
+    #   # │ -25  ┆ 75   │
+    #   # │ 95   ┆ -15  │
+    #   # └──────┴──────┘
+    #
+    # @example Select all columns *except* for those with digit names:
+    #   df.select(~Polars.cs.digit)
+    #   # =>
+    #   # shape: (2, 1)
+    #   # ┌─────┐
+    #   # │ key │
+    #   # │ --- │
+    #   # │ str │
+    #   # ╞═════╡
+    #   # │ aaa │
+    #   # │ bbb │
+    #   # └─────┘
+    #
+    # @example Demonstrate use of `ascii_only` flag (by default all valid unicode digits are considered, but this can be constrained to ascii 0-9):
+    #   df = Polars::DataFrame.new({"१९९९" => [1999], "२०७७" => [2077], "3000": [3000]})
+    #   df.select(Polars.cs.digit)
+    #   # =>
+    #   # shape: (1, 3)
+    #   # ┌──────┬──────┬──────┐
+    #   # │ १९९९ ┆ २०७७ ┆ 3000 │
+    #   # │ ---  ┆ ---  ┆ ---  │
+    #   # │ i64  ┆ i64  ┆ i64  │
+    #   # ╞══════╪══════╪══════╡
+    #   # │ 1999 ┆ 2077 ┆ 3000 │
+    #   # └──────┴──────┴──────┘
+    #
+    # @example
+    #   df.select(Polars.cs.digit(ascii_only: true))
+    #   # =>
+    #   # shape: (1, 1)
+    #   # ┌──────┐
+    #   # │ 3000 │
+    #   # │ ---  │
+    #   # │ i64  │
+    #   # ╞══════╡
+    #   # │ 3000 │
+    #   # └──────┘
+    def self.digit(ascii_only: false)
+      re_digit = ascii_only ? "[0-9]" : "\\d"
+      Selector._from_rbselector(RbSelector.matches("^#{re_digit}+$"))
+    end
+
+    # Select all duration columns, optionally filtering by time unit.
+    #
+    # @return [Selector]
+    def self.duration
+      time_unit = ["ms", "us", "ns"]
+
+      Selector._from_rbselector(RbSelector.duration(time_unit))
     end
 
     # Select columns that end with the given substring(s).
@@ -662,7 +1192,7 @@ module Polars
     # @param suffix [Object]
     #   Substring(s) that matching column names should end with.
     #
-    # @return [SelectorProxy]
+    # @return [Selector]
     #
     # @example
     #   df = Polars::DataFrame.new(
@@ -716,16 +1246,64 @@ module Polars
       escaped_suffix = _re_string(suffix)
       raw_params = "^.*#{escaped_suffix}$"
 
-      _selector_proxy_(
-        F.col(raw_params),
-        name: "ends_with",
-        parameters: {"*suffix" => escaped_suffix},
-      )
+      Selector._from_rbselector(RbSelector.matches(raw_params))
+    end
+
+    # Select all columns except those matching the given columns, datatypes, or selectors.
+    #
+    # @param columns [Object]
+    #   One or more columns (col or name), datatypes, columns, or selectors representing
+    #   the columns to exclude.
+    # @param more_columns [Array]
+    #   Additional columns, datatypes, or selectors to exclude, specified as positional
+    #   arguments.
+    #
+    # @return [Selector]
+    #
+    # @note
+    #   If excluding a single selector it is simpler to write as `~selector` instead.
+    #
+    # @example Exclude by column name(s):
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "aa" => [1, 2, 3],
+    #       "ba" => ["a", "b", nil],
+    #       "cc" => [nil, 2.5, 1.5]
+    #     }
+    #   )
+    #   df.select(Polars.cs.exclude("ba", "xx"))
+    #   # =>
+    #   # shape: (3, 2)
+    #   # ┌─────┬──────┐
+    #   # │ aa  ┆ cc   │
+    #   # │ --- ┆ ---  │
+    #   # │ i64 ┆ f64  │
+    #   # ╞═════╪══════╡
+    #   # │ 1   ┆ null │
+    #   # │ 2   ┆ 2.5  │
+    #   # │ 3   ┆ 1.5  │
+    #   # └─────┴──────┘
+    #
+    # @example Exclude using a column name, a selector, and a dtype:
+    #   df.select(Polars.cs.exclude("aa", Polars.cs.string, Polars::UInt32))
+    #   # =>
+    #   # shape: (3, 1)
+    #   # ┌──────┐
+    #   # │ cc   │
+    #   # │ ---  │
+    #   # │ f64  │
+    #   # ╞══════╡
+    #   # │ null │
+    #   # │ 2.5  │
+    #   # │ 1.5  │
+    #   # └──────┘
+    def self.exclude(columns, *more_columns)
+      ~_combine_as_selector(columns, *more_columns)
     end
 
     # Select the first column in the current scope.
     #
-    # @return [SelectorProxy]
+    # @return [Selector]
     #
     # @example
     #   df = Polars::DataFrame.new(
@@ -762,13 +1340,13 @@ module Polars
     #   # │ 123 ┆ 2.0 ┆ 0   │
     #   # │ 456 ┆ 5.5 ┆ 1   │
     #   # └─────┴─────┴─────┘
-    def self.first
-      _selector_proxy_(F.first, name: "first")
+    def self.first(strict: true)
+      Selector._from_rbselector(RbSelector.first(strict))
     end
 
     # Select all float columns.
     #
-    # @return [SelectorProxy]
+    # @return [Selector]
     #
     # @example
     #   df = Polars::DataFrame.new(
@@ -807,12 +1385,12 @@ module Polars
     #   # │ y   ┆ 456 │
     #   # └─────┴─────┘
     def self.float
-      _selector_proxy_(F.col(FLOAT_DTYPES), name: "float")
+      Selector._from_rbselector(RbSelector.float)
     end
 
     # Select all integer columns.
     #
-    # @return [SelectorProxy]
+    # @return [Selector]
     #
     # @example
     #   df = Polars::DataFrame.new(
@@ -850,12 +1428,12 @@ module Polars
     #   # │ y   ┆ 5.5 │
     #   # └─────┴─────┘
     def self.integer
-      _selector_proxy_(F.col(INTEGER_DTYPES), name: "integer")
+      Selector._from_rbselector(RbSelector.integer)
     end
 
     # Select all signed integer columns.
     #
-    # @return [SelectorProxy]
+    # @return [Selector]
     #
     # @example
     #   df = Polars::DataFrame.new(
@@ -907,12 +1485,12 @@ module Polars
     #   # │ -456 ┆ 6789 ┆ 4321 │
     #   # └──────┴──────┴──────┘
     def self.signed_integer
-      _selector_proxy_(F.col(SIGNED_INTEGER_DTYPES), name: "signed_integer")
+      Selector._from_rbselector(RbSelector.signed_integer)
     end
 
     # Select all unsigned integer columns.
     #
-    # @return [SelectorProxy]
+    # @return [Selector]
     #
     # @example
     #   df = Polars::DataFrame.new(
@@ -964,12 +1542,12 @@ module Polars
     #   # │ -456 ┆ 6789 ┆ 4321 │
     #   # └──────┴──────┴──────┘
     def self.unsigned_integer
-      _selector_proxy_(F.col(UNSIGNED_INTEGER_DTYPES), name: "unsigned_integer")
+      Selector._from_rbselector(RbSelector.unsigned_integer)
     end
 
     # Select the last column in the current scope.
     #
-    # @return [SelectorProxy]
+    # @return [Selector]
     #
     # @example
     #   df = Polars::DataFrame.new(
@@ -1006,13 +1584,71 @@ module Polars
     #   # │ x   ┆ 123 ┆ 2.0 │
     #   # │ y   ┆ 456 ┆ 5.5 │
     #   # └─────┴─────┴─────┘
-    def self.last
-      _selector_proxy_(F.last, name: "last")
+    def self.last(strict: true)
+      Selector._from_rbselector(RbSelector.last(strict))
+    end
+
+    # Select all columns that match the given regex pattern.
+    #
+    # @param pattern [String]
+    #   A valid regular expression pattern, compatible with the [regex crate](https://docs.rs/regex/latest/regex/).
+    #
+    # @return [Selector]
+    #
+    # @example Match column names containing an 'a', preceded by a character that is not 'z':
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "foo" => ["x", "y"],
+    #       "bar" => [123, 456],
+    #       "baz" => [2.0, 5.5],
+    #       "zap" => [0, 1]
+    #     }
+    #   )
+    #   df.select(Polars.cs.matches("[^z]a"))
+    #   # =>
+    #   # shape: (2, 2)
+    #   # ┌─────┬─────┐
+    #   # │ bar ┆ baz │
+    #   # │ --- ┆ --- │
+    #   # │ i64 ┆ f64 │
+    #   # ╞═════╪═════╡
+    #   # │ 123 ┆ 2.0 │
+    #   # │ 456 ┆ 5.5 │
+    #   # └─────┴─────┘
+    #
+    # @example Do not match column names ending in 'R' or 'z' (case-insensitively):
+    #   df.select(~Polars.cs.matches("(?i)R|z$"))
+    #   # =>
+    #   # shape: (2, 2)
+    #   # ┌─────┬─────┐
+    #   # │ foo ┆ zap │
+    #   # │ --- ┆ --- │
+    #   # │ str ┆ i64 │
+    #   # ╞═════╪═════╡
+    #   # │ x   ┆ 0   │
+    #   # │ y   ┆ 1   │
+    #   # └─────┴─────┘
+    def self.matches(pattern)
+      if pattern == ".*"
+        all
+      else
+        if pattern.start_with?(".*")
+          pattern = pattern[2..]
+        elsif pattern.end_with?(".*")
+          pattern = pattern[..-3]
+        end
+
+        pfx = !pattern.start_with?("^") ? "^.*" : ""
+        sfx = !pattern.end_with?("$") ? ".*$" : ""
+        raw_params = "#{pfx}#{pattern}#{sfx}"
+
+        Selector._from_rbselector(RbSelector.matches(raw_params))
+      end
     end
 
     # Select all numeric columns.
     #
-    # @return [SelectorProxy]
+    # @return [Selector]
     #
     # @example
     #   df = Polars::DataFrame.new(
@@ -1051,7 +1687,14 @@ module Polars
     #   # │ y   │
     #   # └─────┘
     def self.numeric
-      _selector_proxy_(F.col(NUMERIC_DTYPES), name: "numeric")
+      Selector._from_rbselector(RbSelector.numeric)
+    end
+
+    # Select all object columns.
+    #
+    # @return [Selector]
+    def self.object
+      Selector._from_rbselector(RbSelector.object)
     end
 
     # Select columns that start with the given substring(s).
@@ -1059,7 +1702,7 @@ module Polars
     # @param prefix [Object]
     #   Substring(s) that matching column names should start with.
     #
-    # @return [SelectorProxy]
+    # @return [Selector]
     #
     # @example
     #   df = Polars::DataFrame.new(
@@ -1113,16 +1756,12 @@ module Polars
       escaped_prefix = _re_string(prefix)
       raw_params = "^#{escaped_prefix}.*$"
 
-      _selector_proxy_(
-        F.col(raw_params),
-        name: "starts_with",
-        parameters: {"*prefix" => prefix}
-      )
+      Selector._from_rbselector(RbSelector.matches(raw_params))
     end
 
     # Select all String (and, optionally, Categorical) string columns.
     #
-    # @return [SelectorProxy]
+    # @return [Selector]
     #
     # @example
     #   df = Polars::DataFrame.new(
@@ -1169,16 +1808,66 @@ module Polars
         string_dtypes << Categorical
       end
 
-      _selector_proxy_(
-        F.col(string_dtypes),
-        name: "string",
-        parameters: {"include_categorical" => include_categorical},
-      )
+      by_dtype(string_dtypes)
+    end
+
+    # Select all temporal columns.
+    #
+    # @return [Selector]
+    #
+    # @example Match all temporal columns:
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "dt" => [Date.new(2021, 1, 1), Date.new(2021, 1, 2)],
+    #       "tm" => [DateTime.new(2000, 1, 1, 12, 0, 0), DateTime.new(2000, 1, 1, 20, 30, 45)],
+    #       "value" => [1.2345, 2.3456],
+    #     },
+    #     schema_overrides: {"tm" => Polars::Time}
+    #   )
+    #   df.select(Polars.cs.temporal)
+    #   # =>
+    #   # shape: (2, 2)
+    #   # ┌────────────┬──────────┐
+    #   # │ dt         ┆ tm       │
+    #   # │ ---        ┆ ---      │
+    #   # │ date       ┆ time     │
+    #   # ╞════════════╪══════════╡
+    #   # │ 2021-01-01 ┆ 12:00:00 │
+    #   # │ 2021-01-02 ┆ 20:30:45 │
+    #   # └────────────┴──────────┘
+    #
+    # @example Match all temporal columns *except* for time columns:
+    #   df.select(Polars.cs.temporal - Polars.cs.time)
+    #   # =>
+    #   # shape: (2, 1)
+    #   # ┌────────────┐
+    #   # │ dt         │
+    #   # │ ---        │
+    #   # │ date       │
+    #   # ╞════════════╡
+    #   # │ 2021-01-01 │
+    #   # │ 2021-01-02 │
+    #   # └────────────┘
+    #
+    # @example Match all columns *except* for temporal columns:
+    #   df.select(~Polars.cs.temporal)
+    #   # =>
+    #   # shape: (2, 1)
+    #   # ┌────────┐
+    #   # │ value  │
+    #   # │ ---    │
+    #   # │ f64    │
+    #   # ╞════════╡
+    #   # │ 1.2345 │
+    #   # │ 2.3456 │
+    #   # └────────┘
+    def self.temporal
+      Selector._from_rbselector(RbSelector.temporal)
     end
 
     # Select all time columns.
     #
-    # @return [SelectorProxy]
+    # @return [Selector]
     #
     # @example
     #   df = Polars::DataFrame.new(
@@ -1216,11 +1905,51 @@ module Polars
     #   # │ 2031-12-31 00:30:00 ┆ 2024-08-09 │
     #   # └─────────────────────┴────────────┘
     def self.time
-      _selector_proxy_(F.col(Time), name: "time")
+      by_dtype([Time])
+    end
+
+    # @private
+    def self._combine_as_selector(items, *more_items)
+      names, regexes, dtypes = [], [], []
+      selectors = []
+      ((items.is_a?(::Array) ? items : [items]) + more_items).each do |item|
+        if Utils.is_selector(item)
+          selectors << item
+        elsif item.is_a?(::String)
+          if item.start_with?("^") && item.end_with?("$")
+            regexes << item
+          else
+            names << item
+          end
+        elsif Utils.is_polars_dtype(item)
+          dtypes << item
+        elsif Utils.is_column(item)
+          names << item.meta.output_name
+        else
+          msg = "expected one or more `str`, `DataType` or selector; found #{item.inspect} instead."
+          raise TypeError, msg
+        end
+      end
+
+      selected = []
+      if names.any?
+        selected << by_name(*names, require_all: false)
+      end
+      if dtypes.any?
+        selected << by_dtype(*dtypes)
+      end
+      if regexes.any?
+        raise Todo
+      end
+      if selectors.any?
+        selected.concat(selectors)
+      end
+
+      selected.reduce(empty, :|)
     end
   end
 
   def self.cs
-    Polars::Selectors
+    Selectors
   end
 end