polars-df 0.8.0-x86_64-linux → 0.9.0-x86_64-linux

data/lib/polars/string_expr.rb

@@ -211,6 +211,49 @@ module Polars
       end
     end
 
+    # Convert a String column into a Decimal column.
+    #
+    # This method infers the needed parameters `precision` and `scale`.
+    #
+    # @param inference_length [Integer]
+    #   Number of elements to parse to determine the `precision` and `scale`.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "numbers": [
+    #         "40.12",
+    #         "3420.13",
+    #         "120134.19",
+    #         "3212.98",
+    #         "12.90",
+    #         "143.09",
+    #         "143.9"
+    #       ]
+    #     }
+    #   )
+    #   df.with_columns(numbers_decimal: Polars.col("numbers").str.to_decimal)
+    #   # =>
+    #   # shape: (7, 2)
+    #   # ┌───────────┬─────────────────┐
+    #   # │ numbers   ┆ numbers_decimal │
+    #   # │ ---       ┆ ---             │
+    #   # │ str       ┆ decimal[*,2]    │
+    #   # ╞═══════════╪═════════════════╡
+    #   # │ 40.12     ┆ 40.12           │
+    #   # │ 3420.13   ┆ 3420.13         │
+    #   # │ 120134.19 ┆ 120134.19       │
+    #   # │ 3212.98   ┆ 3212.98         │
+    #   # │ 12.90     ┆ 12.90           │
+    #   # │ 143.09    ┆ 143.09          │
+    #   # │ 143.9     ┆ 143.90          │
+    #   # └───────────┴─────────────────┘
+    def to_decimal(inference_length = 100)
+      Utils.wrap_expr(_rbexpr.str_to_decimal(inference_length))
+    end
+
     # Get length of the strings as `:u32` (as number of bytes).
     #
     # @return [Expr]
@@ -222,8 +265,8 @@ module Polars
     # @example
     #   df = Polars::DataFrame.new({"s" => ["Café", nil, "345", "東京"]}).with_columns(
     #     [
-    #       Polars.col("s").str.lengths.alias("length"),
-    #       Polars.col("s").str.n_chars.alias("nchars")
+    #       Polars.col("s").str.len_bytes.alias("length"),
+    #       Polars.col("s").str.len_chars.alias("nchars")
     #     ]
     #   )
     #   df
@@ -239,9 +282,10 @@ module Polars
     #   # │ 345  ┆ 3      ┆ 3      │
     #   # │ 東京 ┆ 6      ┆ 2      │
     #   # └──────┴────────┴────────┘
-    def lengths
+    def len_bytes
       Utils.wrap_expr(_rbexpr.str_len_bytes)
     end
+    alias_method :lengths, :len_bytes
 
     # Get length of the strings as `:u32` (as number of chars).
     #
@@ -254,8 +298,8 @@ module Polars
     # @example
     #   df = Polars::DataFrame.new({"s" => ["Café", nil, "345", "東京"]}).with_columns(
     #     [
-    #       Polars.col("s").str.lengths.alias("length"),
-    #       Polars.col("s").str.n_chars.alias("nchars")
+    #       Polars.col("s").str.len_bytes.alias("length"),
+    #       Polars.col("s").str.len_chars.alias("nchars")
     #     ]
     #   )
     #   df
@@ -271,9 +315,10 @@ module Polars
     #   # │ 345  ┆ 3      ┆ 3      │
     #   # │ 東京 ┆ 6      ┆ 2      │
     #   # └──────┴────────┴────────┘
-    def n_chars
+    def len_chars
       Utils.wrap_expr(_rbexpr.str_len_chars)
     end
+    alias_method :n_chars, :len_chars
 
     # Vertically concat the values in the Series to a single string value.
     #
@@ -355,6 +400,30 @@ module Polars
       Utils.wrap_expr(_rbexpr.str_to_lowercase)
     end
 
+    # Transform to titlecase variant.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {"sing": ["welcome to my world", "THERE'S NO TURNING BACK"]}
+    #   )
+    #   df.with_columns(foo_title: Polars.col("sing").str.to_titlecase)
+    #   # =>
+    #   # shape: (2, 2)
+    #   # ┌─────────────────────────┬─────────────────────────┐
+    #   # │ sing                    ┆ foo_title               │
+    #   # │ ---                     ┆ ---                     │
+    #   # │ str                     ┆ str                     │
+    #   # ╞═════════════════════════╪═════════════════════════╡
+    #   # │ welcome to my world     ┆ Welcome To My World     │
+    #   # │ THERE'S NO TURNING BACK ┆ There's No Turning Back │
+    #   # └─────────────────────────┴─────────────────────────┘
+    def to_titlecase
+      raise Todo
+      Utils.wrap_expr(_rbexpr.str_to_titlecase)
+    end
+
     # Remove leading and trailing whitespace.
     #
     # @param characters [String, nil]
@@ -436,113 +505,158 @@ module Polars
     end
     alias_method :rstrip, :strip_chars_end
 
-    # Fills the string with zeroes.
+    # Remove prefix.
     #
-    # Return a copy of the string left filled with ASCII '0' digits to make a string
-    # of length width.
+    # The prefix will be removed from the string exactly once, if found.
     #
-    # A leading sign prefix ('+'/'-') is handled by inserting the padding after the
-    # sign character rather than before. The original string is returned if width is
-    # less than or equal to `s.length`.
+    # @param prefix [String]
+    #   The prefix to be removed.
     #
-    # @param alignment [Integer]
-    #   Fill the value up to this length
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"a" => ["foobar", "foofoobar", "foo", "bar"]})
+    #   df.with_columns(Polars.col("a").str.strip_prefix("foo").alias("stripped"))
+    #   # =>
+    #   # shape: (4, 2)
+    #   # ┌───────────┬──────────┐
+    #   # │ a         ┆ stripped │
+    #   # │ ---       ┆ ---      │
+    #   # │ str       ┆ str      │
+    #   # ╞═══════════╪══════════╡
+    #   # │ foobar    ┆ bar      │
+    #   # │ foofoobar ┆ foobar   │
+    #   # │ foo       ┆          │
+    #   # │ bar       ┆ bar      │
+    #   # └───────────┴──────────┘
+    def strip_prefix(prefix)
+      prefix = Utils.parse_as_expression(prefix, str_as_lit: true)
+      Utils.wrap_expr(_rbexpr.str_strip_prefix(prefix))
+    end
+
+    # Remove suffix.
+    #
+    # The suffix will be removed from the string exactly once, if found.
+    #
+    #
+    # @param suffix [String]
+    #   The suffix to be removed.
     #
     # @return [Expr]
     #
     # @example
-    #   df = Polars::DataFrame.new(
-    #     {
-    #       "num" => [-10, -1, 0, 1, 10, 100, 1000, 10000, 100000, 1000000, nil]
-    #     }
-    #   )
-    #   df.with_column(Polars.col("num").cast(String).str.zfill(5))
+    #   df = Polars::DataFrame.new({"a" => ["foobar", "foobarbar", "foo", "bar"]})
+    #   df.with_columns(Polars.col("a").str.strip_suffix("bar").alias("stripped"))
     #   # =>
-    #   # shape: (11, 1)
-    #   # ┌─────────┐
-    #   # │ num     │
-    #   # │ ---     │
-    #   # │ str     │
-    #   # ╞═════════╡
-    #   # │ -0010   │
-    #   # │ -0001   │
-    #   # │ 00000   │
-    #   # │ 00001   │
-    #   # │ …       │
-    #   # │ 10000   │
-    #   # │ 100000  │
-    #   # │ 1000000 │
-    #   # │ null    │
-    #   # └─────────┘
-    def zfill(alignment)
-      Utils.wrap_expr(_rbexpr.str_zfill(alignment))
+    #   # shape: (4, 2)
+    #   # ┌───────────┬──────────┐
+    #   # │ a         ┆ stripped │
+    #   # │ ---       ┆ ---      │
+    #   # │ str       ┆ str      │
+    #   # ╞═══════════╪══════════╡
+    #   # │ foobar    ┆ foo      │
+    #   # │ foobarbar ┆ foobar   │
+    #   # │ foo       ┆ foo      │
+    #   # │ bar       ┆          │
+    #   # └───────────┴──────────┘
+    def strip_suffix(suffix)
+      suffix = Utils.parse_as_expression(suffix, str_as_lit: true)
+      Utils.wrap_expr(_rbexpr.str_strip_suffix(suffix))
     end
 
-    # Return the string left justified in a string of length `length`.
+    # Pad the start of the string until it reaches the given length.
+    #
+    # @param length [Integer]
+    #   Pad the string until it reaches this length. Strings with length equal to
+    #   or greater than this value are returned as-is.
+    # @param fill_char [String]
+    #   The character to pad the string with.
     #
-    # Padding is done using the specified `fillchar`.
-    # The original string is returned if `length` is less than or equal to
-    # `s.length`.
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"a": ["cow", "monkey", "hippopotamus", nil]})
+    #   df.with_columns(padded: Polars.col("a").str.pad_start(8, "*"))
+    #   # =>
+    #   # shape: (4, 2)
+    #   # ┌──────────────┬──────────────┐
+    #   # │ a            ┆ padded       │
+    #   # │ ---          ┆ ---          │
+    #   # │ str          ┆ str          │
+    #   # ╞══════════════╪══════════════╡
+    #   # │ cow          ┆ *****cow     │
+    #   # │ monkey       ┆ **monkey     │
+    #   # │ hippopotamus ┆ hippopotamus │
+    #   # │ null         ┆ null         │
+    #   # └──────────────┴──────────────┘
+    def pad_start(length, fill_char = " ")
+      Utils.wrap_expr(_rbexpr.str_pad_start(length, fill_char))
+    end
+    alias_method :rjust, :pad_start
+
+    # Pad the end of the string until it reaches the given length.
     #
     # @param length [Integer]
-    #   Justify left to this length.
-    # @param fillchar [String]
-    #   Fill with this ASCII character.
+    #   Pad the string until it reaches this length. Strings with length equal to
+    #   or greater than this value are returned as-is.
+    # @param fill_char [String]
+    #   The character to pad the string with.
     #
     # @return [Expr]
     #
     # @example
-    #   df = Polars::DataFrame.new({"a" => ["cow", "monkey", nil, "hippopotamus"]})
-    #   df.select(Polars.col("a").str.ljust(8, "*"))
+    #   df = Polars::DataFrame.new({"a": ["cow", "monkey", "hippopotamus", nil]})
+    #   df.with_columns(padded: Polars.col("a").str.pad_end(8, "*"))
     #   # =>
-    #   # shape: (4, 1)
-    #   # ┌──────────────┐
-    #   # │ a            │
-    #   # │ ---          │
-    #   # │ str          │
-    #   # ╞══════════════╡
-    #   # │ cow*****     │
-    #   # │ monkey**     │
-    #   # │ null         │
-    #   # │ hippopotamus │
-    #   # └──────────────┘
-    def ljust(length, fillchar = " ")
-      Utils.wrap_expr(_rbexpr.str_pad_end(length, fillchar))
+    #   # shape: (4, 2)
+    #   # ┌──────────────┬──────────────┐
+    #   # │ a            ┆ padded       │
+    #   # │ ---          ┆ ---          │
+    #   # │ str          ┆ str          │
+    #   # ╞══════════════╪══════════════╡
+    #   # │ cow          ┆ cow*****     │
+    #   # │ monkey       ┆ monkey**     │
+    #   # │ hippopotamus ┆ hippopotamus │
+    #   # │ null         ┆ null         │
+    #   # └──────────────┴──────────────┘
+    def pad_end(length, fill_char = " ")
+      Utils.wrap_expr(_rbexpr.str_pad_end(length, fill_char))
     end
-    alias_method :pad_end, :ljust
+    alias_method :ljust, :pad_end
 
-    # Return the string right justified in a string of length `length`.
+    # Fills the string with zeroes.
     #
-    # Padding is done using the specified `fillchar`.
-    # The original string is returned if `length` is less than or equal to
-    # `s.length`.
+    # Return a copy of the string left filled with ASCII '0' digits to make a string
+    # of length width.
+    #
+    # A leading sign prefix ('+'/'-') is handled by inserting the padding after the
+    # sign character rather than before. The original string is returned if width is
+    # less than or equal to `s.length`.
     #
     # @param length [Integer]
-    #   Justify right to this length.
-    # @param fillchar [String]
-    #   Fill with this ASCII character.
+    #   Fill the value up to this length
     #
     # @return [Expr]
     #
     # @example
-    #   df = Polars::DataFrame.new({"a" => ["cow", "monkey", nil, "hippopotamus"]})
-    #   df.select(Polars.col("a").str.rjust(8, "*"))
+    #   df = Polars::DataFrame.new({"a" => [-1, 123, 999999, nil]})
+    #   df.with_columns(Polars.col("a").cast(Polars::String).str.zfill(4).alias("zfill"))
     #   # =>
-    #   # shape: (4, 1)
-    #   # ┌──────────────┐
-    #   # │ a            │
-    #   # │ ---          │
-    #   # │ str          │
-    #   # ╞══════════════╡
-    #   # │ *****cow     │
-    #   # │ **monkey     │
-    #   # │ null         │
-    #   # │ hippopotamus │
-    #   # └──────────────┘
-    def rjust(length, fillchar = " ")
-      Utils.wrap_expr(_rbexpr.str_pad_start(length, fillchar))
+    #   # shape: (4, 2)
+    #   # ┌────────┬────────┐
+    #   # │ a      ┆ zfill  │
+    #   # │ ---    ┆ ---    │
+    #   # │ i64    ┆ str    │
+    #   # ╞════════╪════════╡
+    #   # │ -1     ┆ -001   │
+    #   # │ 123    ┆ 0123   │
+    #   # │ 999999 ┆ 999999 │
+    #   # │ null   ┆ null   │
+    #   # └────────┴────────┘
+    def zfill(length)
+      length = Utils.parse_as_expression(length)
+      Utils.wrap_expr(_rbexpr.str_zfill(length))
     end
-    alias_method :pad_start, :rjust
 
     # Check if string contains a substring that matches a regex.
     #
@@ -674,7 +788,7 @@ module Polars
     #     {"json" => ['{"a":1, "b": true}', nil, '{"a":2, "b": false}']}
     #   )
     #   dtype = Polars::Struct.new([Polars::Field.new("a", Polars::Int64), Polars::Field.new("b", Polars::Boolean)])
-    #   df.select(Polars.col("json").str.json_extract(dtype))
+    #   df.select(Polars.col("json").str.json_decode(dtype))
     #   # =>
     #   # shape: (3, 1)
     #   # ┌─────────────┐
@@ -686,12 +800,13 @@ module Polars
     #   # │ {null,null} │
     #   # │ {2,false}   │
     #   # └─────────────┘
-    def json_extract(dtype = nil, infer_schema_length: 100)
+    def json_decode(dtype = nil, infer_schema_length: 100)
       if !dtype.nil?
         dtype = Utils.rb_type_to_dtype(dtype)
       end
-      Utils.wrap_expr(_rbexpr.str_json_extract(dtype, infer_schema_length))
+      Utils.wrap_expr(_rbexpr.str_json_decode(dtype, infer_schema_length))
     end
+    alias_method :json_extract, :json_decode
 
     # Extract the first match of json string with provided JSONPath expression.
     #
@@ -745,15 +860,15 @@ module Polars
     #   df.select(Polars.col("encoded").str.decode("hex"))
     #   # =>
     #   # shape: (3, 1)
-    #   # ┌───────────────┐
-    #   # │ encoded       │
-    #   # │ ---           │
-    #   # │ binary        │
-    #   # ╞═══════════════╡
-    #   # │ [binary data] │
-    #   # │ [binary data] │
-    #   # │ null          │
-    #   # └───────────────┘
+    #   # ┌─────────┐
+    #   # │ encoded │
+    #   # │ ---     │
+    #   # │ binary  │
+    #   # ╞═════════╡
+    #   # │ b"foo"  │
+    #   # │ b"bar"  │
+    #   # │ null    │
+    #   # └─────────┘
     def decode(encoding, strict: true)
       if encoding == "hex"
         Utils.wrap_expr(_rbexpr.str_hex_decode(strict))
@@ -824,6 +939,7 @@ module Polars
     #   # │ 678 │
     #   # └─────┘
     def extract(pattern, group_index: 1)
+      pattern = Utils.parse_as_expression(pattern, str_as_lit: true)
       Utils.wrap_expr(_rbexpr.str_extract(pattern, group_index))
     end
 
@@ -859,6 +975,62 @@ module Polars
       Utils.wrap_expr(_rbexpr.str_extract_all(pattern._rbexpr))
     end
 
+    # Extract all capture groups for the given regex pattern.
+    #
+    # @param pattern [String]
+    #   A valid regular expression pattern containing at least one capture group,
+    #   compatible with the [regex crate](https://docs.rs/regex/latest/regex/).
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "url": [
+    #         "http://vote.com/ballon_dor?candidate=messi&ref=python",
+    #         "http://vote.com/ballon_dor?candidate=weghorst&ref=polars",
+    #         "http://vote.com/ballon_dor?error=404&ref=rust"
+    #       ]
+    #     }
+    #   )
+    #   pattern = /candidate=(?<candidate>\w+)&ref=(?<ref>\w+)/.to_s
+    #   df.select(captures: Polars.col("url").str.extract_groups(pattern)).unnest(
+    #     "captures"
+    #   )
+    #   # =>
+    #   # shape: (3, 2)
+    #   # ┌───────────┬────────┐
+    #   # │ candidate ┆ ref    │
+    #   # │ ---       ┆ ---    │
+    #   # │ str       ┆ str    │
+    #   # ╞═══════════╪════════╡
+    #   # │ messi     ┆ python │
+    #   # │ weghorst  ┆ polars │
+    #   # │ null      ┆ null   │
+    #   # └───────────┴────────┘
+    #
+    # @example Unnamed groups have their numerical position converted to a string:
+    #   pattern = /candidate=(\w+)&ref=(\w+)/.to_s
+    #   (
+    #     df.with_columns(
+    #       captures: Polars.col("url").str.extract_groups(pattern)
+    #     ).with_columns(name: Polars.col("captures").struct["1"].str.to_uppercase)
+    #   )
+    #   # =>
+    #   # shape: (3, 3)
+    #   # ┌───────────────────────────────────┬───────────────────────┬──────────┐
+    #   # │ url                               ┆ captures              ┆ name     │
+    #   # │ ---                               ┆ ---                   ┆ ---      │
+    #   # │ str                               ┆ struct[2]             ┆ str      │
+    #   # ╞═══════════════════════════════════╪═══════════════════════╪══════════╡
+    #   # │ http://vote.com/ballon_dor?candi… ┆ {"messi","python"}    ┆ MESSI    │
+    #   # │ http://vote.com/ballon_dor?candi… ┆ {"weghorst","polars"} ┆ WEGHORST │
+    #   # │ http://vote.com/ballon_dor?error… ┆ {null,null}           ┆ null     │
+    #   # └───────────────────────────────────┴───────────────────────┴──────────┘
+    def extract_groups(pattern)
+      Utils.wrap_expr(_rbexpr.str_extract_groups(pattern))
+    end
+
     # Count all successive non-overlapping regex matches.
     #
     # @param pattern [String]
@@ -1059,6 +1231,28 @@ module Polars
       Utils.wrap_expr(_rbexpr.str_replace_all(pattern._rbexpr, value._rbexpr, literal))
     end
 
+    # Returns string values in reversed order.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"text" => ["foo", "bar", "man\u0303ana"]})
+    #   df.with_columns(Polars.col("text").str.reverse.alias("reversed"))
+    #   # =>
+    #   # shape: (3, 2)
+    #   # ┌────────┬──────────┐
+    #   # │ text   ┆ reversed │
+    #   # │ ---    ┆ ---      │
+    #   # │ str    ┆ str      │
+    #   # ╞════════╪══════════╡
+    #   # │ foo    ┆ oof      │
+    #   # │ bar    ┆ rab      │
+    #   # │ mañana ┆ anañam   │
+    #   # └────────┴──────────┘
+    def reverse
+      Utils.wrap_expr(_rbexpr.str_reverse)
+    end
+
     # Create subslices of the string values of a Utf8 Series.
     #
     # @param offset [Integer]
@@ -1087,6 +1281,8 @@ module Polars
     #   # │ dragonfruit ┆ uit      │
     #   # └─────────────┴──────────┘
     def slice(offset, length = nil)
+      offset = Utils.parse_as_expression(offset)
+      length = Utils.parse_as_expression(length)
       Utils.wrap_expr(_rbexpr.str_slice(offset, length))
     end
 
@@ -1193,6 +1389,126 @@ module Polars
       to_integer(base: 2, strict: strict).cast(Int32, strict: strict)
     end
 
+    # Use the aho-corasick algorithm to find matches.
+    #
+    # This version determines if any of the patterns find a match.
+    #
+    # @param patterns [String]
+    #   String patterns to search.
+    # @param ascii_case_insensitive [Boolean]
+    #   Enable ASCII-aware case insensitive matching.
+    #   When this option is enabled, searching will be performed without respect
+    #   to case for ASCII letters (a-z and A-Z) only.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "lyrics": [
+    #         "Everybody wants to rule the world",
+    #         "Tell me what you want, what you really really want",
+    #         "Can you feel the love tonight"
+    #       ]
+    #     }
+    #   )
+    #   df.with_columns(
+    #     Polars.col("lyrics").str.contains_any(["you", "me"]).alias("contains_any")
+    #   )
+    #   # =>
+    #   # shape: (3, 2)
+    #   # ┌───────────────────────────────────┬──────────────┐
+    #   # │ lyrics                            ┆ contains_any │
+    #   # │ ---                               ┆ ---          │
+    #   # │ str                               ┆ bool         │
+    #   # ╞═══════════════════════════════════╪══════════════╡
+    #   # │ Everybody wants to rule the worl… ┆ false        │
+    #   # │ Tell me what you want, what you … ┆ true         │
+    #   # │ Can you feel the love tonight     ┆ true         │
+    #   # └───────────────────────────────────┴──────────────┘
+    def contains_any(patterns, ascii_case_insensitive: false)
+      patterns = Utils.parse_as_expression(patterns, str_as_lit: false, list_as_lit: false)
+      Utils.wrap_expr(
+        _rbexpr.str_contains_any(patterns, ascii_case_insensitive)
+      )
+    end
+
+    # Use the aho-corasick algorithm to replace many matches.
+    #
+    # @param patterns [String]
+    #   String patterns to search and replace.
+    # @param replace_with [String]
+    #   Strings to replace where a pattern was a match.
+    #   This can be broadcasted. So it supports many:one and many:many.
+    # @param ascii_case_insensitive [Boolean]
+    #   Enable ASCII-aware case insensitive matching.
+    #   When this option is enabled, searching will be performed without respect
+    #   to case for ASCII letters (a-z and A-Z) only.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "lyrics": [
+    #         "Everybody wants to rule the world",
+    #         "Tell me what you want, what you really really want",
+    #         "Can you feel the love tonight"
+    #       ]
+    #     }
+    #   )
+    #   df.with_columns(
+    #     Polars.col("lyrics")
+    #     .str.replace_many(
+    #       ["me", "you", "they"],
+    #       ""
+    #     )
+    #     .alias("removes_pronouns")
+    #   )
+    #   # =>
+    #   # shape: (3, 2)
+    #   # ┌───────────────────────────────────┬───────────────────────────────────┐
+    #   # │ lyrics                            ┆ removes_pronouns                  │
+    #   # │ ---                               ┆ ---                               │
+    #   # │ str                               ┆ str                               │
+    #   # ╞═══════════════════════════════════╪═══════════════════════════════════╡
+    #   # │ Everybody wants to rule the worl… ┆ Everybody wants to rule the worl… │
+    #   # │ Tell me what you want, what you … ┆ Tell  what  want, what  really r… │
+    #   # │ Can you feel the love tonight     ┆ Can  feel the love tonight        │
+    #   # └───────────────────────────────────┴───────────────────────────────────┘
+    #
+    # @example
+    #   df.with_columns(
+    #     Polars.col("lyrics")
+    #     .str.replace_many(
+    #       ["me", "you"],
+    #       ["you", "me"]
+    #     )
+    #     .alias("confusing")
+    #   )
+    #   # =>
+    #   # shape: (3, 2)
+    #   # ┌───────────────────────────────────┬───────────────────────────────────┐
+    #   # │ lyrics                            ┆ confusing                         │
+    #   # │ ---                               ┆ ---                               │
+    #   # │ str                               ┆ str                               │
+    #   # ╞═══════════════════════════════════╪═══════════════════════════════════╡
+    #   # │ Everybody wants to rule the worl… ┆ Everybody wants to rule the worl… │
+    #   # │ Tell me what you want, what you … ┆ Tell you what me want, what me r… │
+    #   # │ Can you feel the love tonight     ┆ Can me feel the love tonight      │
+    #   # └───────────────────────────────────┴───────────────────────────────────┘
+    def replace_many(patterns, replace_with, ascii_case_insensitive: false)
+      patterns = Utils.parse_as_expression(patterns, str_as_lit: false, list_as_lit: false)
+      replace_with = Utils.parse_as_expression(
+        replace_with, str_as_lit: true, list_as_lit: false
+      )
+      Utils.wrap_expr(
+        _rbexpr.str_replace_many(
+          patterns, replace_with, ascii_case_insensitive
+        )
+      )
+    end
+
     private
 
     def _validate_format_argument(format)

data/lib/polars/string_name_space.rb

@@ -353,8 +353,8 @@ module Polars
     #   # shape: (3,)
     #   # Series: '' [binary]
     #   # [
-    #   #         [binary data]
-    #   #         [binary data]
+    #   #         b"foo"
+    #   #         b"bar"
     #   #         null
     #   # ]
     def decode(encoding, strict: false)
@@ -690,11 +690,11 @@ module Polars
     # sign character rather than before. The original string is returned if width is
     # less than or equal to `s.length`.
     #
-    # @param alignment [Integer]
+    # @param length [Integer]
     #   Fill the value up to this length.
     #
     # @return [Series]
-    def zfill(alignment)
+    def zfill(length)
       super
     end