polars-df 0.21.0 → 0.21.1

data/lib/polars/string_name_space.rb

@@ -184,86 +184,77 @@ module Polars
       super
     end
 
-    # Get length of the string values in the Series (as number of bytes).
+    # Convert a String column into a Decimal column.
     #
-    # @return [Series]
+    # This method infers the needed parameters `precision` and `scale`.
     #
-    # @note
-    #   The returned lengths are equal to the number of bytes in the UTF8 string. If you
-    #   need the length in terms of the number of characters, use `n_chars` instead.
+    # @param inference_length [Integer]
+    #   Number of elements to parse to determine the `precision` and `scale`
+    #
+    # @return [Series]
     #
     # @example
-    #   s = Polars::Series.new(["Café", nil, "345", "東京"])
-    #   s.str.lengths
+    #   s = Polars::Series.new(
+    #     ["40.12", "3420.13", "120134.19", "3212.98", "12.90", "143.09", "143.9"]
+    #   )
+    #   s.str.to_decimal
     #   # =>
-    #   # shape: (4,)
-    #   # Series: '' [u32]
+    #   # shape: (7,)
+    #   # Series: '' [decimal[*,2]]
     #   # [
-    #   #         5
-    #   #         null
-    #   #         3
-    #   #         6
+    #   #         40.12
+    #   #         3420.13
+    #   #         120134.19
+    #   #         3212.98
+    #   #         12.90
+    #   #         143.09
+    #   #         143.90
     #   # ]
-    def lengths
+    def to_decimal(inference_length = 100)
       super
     end
 
-    # Get length of the string values in the Series (as number of chars).
+    # Return the length of each string as the number of bytes.
     #
     # @return [Series]
     #
-    # @note
-    #   If you know that you are working with ASCII text, `lengths` will be
-    #   equivalent, and faster (returns length in terms of the number of bytes).
-    #
     # @example
-    #   s = Polars::Series.new(["Café", nil, "345", "東京"])
-    #   s.str.n_chars
+    #   s = Polars::Series.new(["Café", "345", "東京", nil])
+    #   s.str.len_bytes
     #   # =>
     #   # shape: (4,)
     #   # Series: '' [u32]
     #   # [
-    #   #         4
-    #   #         null
+    #   #         5
     #   #         3
-    #   #         2
+    #   #         6
+    #   #         null
     #   # ]
-    def n_chars
+    def len_bytes
       super
     end
+    alias_method :lengths, :len_bytes
 
-    # Vertically concat the values in the Series to a single string value.
-    #
-    # @param delimiter [String]
-    #   The delimiter to insert between consecutive string values.
-    # @param ignore_nulls [Boolean]
-    #   Ignore null values (default).
-    #   If set to `False`, null values will be propagated. This means that
-    #   if the column contains any null values, the output is null.
+    # Return the length of each string as the number of characters.
     #
     # @return [Series]
     #
     # @example
-    #   Polars::Series.new([1, nil, 2]).str.join("-")
+    #   s = Polars::Series.new(["Café", "345", "東京", nil])
+    #   s.str.len_chars
     #   # =>
-    #   # shape: (1,)
-    #   # Series: '' [str]
-    #   # [
-    #   #         "1-2"
-    #   # ]
-    #
-    # @example
-    #   Polars::Series.new([1, nil, 2]).str.join("-", ignore_nulls: false)
-    #   # =>
-    #   # shape: (1,)
-    #   # Series: '' [str]
+    #   # shape: (4,)
+    #   # Series: '' [u32]
     #   # [
+    #   #         4
+    #   #         3
+    #   #         2
     #   #         null
     #   # ]
-    def join(delimiter = "-", ignore_nulls: true)
+    def len_chars
       super
     end
-    alias_method :concat, :join
+    alias_method :n_chars, :len_chars
 
     # Check if strings in Series contain a substring that matches a regex.
     #
@@ -302,6 +293,65 @@ module Polars
       super
     end
 
+    # Return the bytes offset of the first substring matching a pattern.
+    #
+    # If the pattern is not found, returns nil.
+    #
+    # @param pattern
+    #   A valid regular expression pattern, compatible with the [regex crate](https://docs.rs/regex/latest/regex/).
+    # @param literal
+    #   Treat `pattern` as a literal string, not as a regular expression.
+    # @param strict
+    #   Raise an error if the underlying pattern is not a valid regex,
+    #   otherwise mask out with a null value.
+    #
+    # @return [Series]
+    #
+    # @note
+    #   To modify regular expression behaviour (such as case-sensitivity) with
+    #   flags, use the inline `(?iLmsuxU)` syntax.
+    #
+    # @example Find the index of the first substring matching a regex pattern:
+    #   s = Polars::Series.new("txt", ["Crab", "Lobster", nil, "Crustacean"])
+    #   s.str.find("a|e").rename("idx_rx")
+    #   # =>
+    #   # shape: (4,)
+    #   # Series: 'idx_rx' [u32]
+    #   # [
+    #   #         2
+    #   #         5
+    #   #         null
+    #   #         5
+    #   # ]
+    #
+    # @example Find the index of the first substring matching a literal pattern:
+    #   s.str.find("e", literal: true).rename("idx_lit")
+    #   # =>
+    #   # shape: (4,)
+    #   # Series: 'idx_lit' [u32]
+    #   # [
+    #   #         null
+    #   #         5
+    #   #         null
+    #   #         7
+    #   # ]
+    #
+    # @example Match against a pattern found in another column or (expression):
+    #   p = Polars::Series.new("pat", ["a[bc]", "b.t", "[aeiuo]", "(?i)A[BC]"])
+    #   s.str.find(p).rename("idx")
+    #   # =>
+    #   # shape: (4,)
+    #   # Series: 'idx' [u32]
+    #   # [
+    #   #         2
+    #   #         2
+    #   #         null
+    #   #         5
+    #   # ]
+    def find(pattern, literal: false, strict: true)
+      super
+    end
+
     # Check if string values end with a substring.
     #
     # @param sub [String]
@@ -395,6 +445,34 @@ module Polars
       super
     end
 
+    # Parse string values as JSON.
+    #
+    # Throws an error if invalid JSON strings are encountered.
+    #
+    # @param dtype [Object]
+    #   The dtype to cast the extracted value to. If None, the dtype will be
+    #   inferred from the JSON value.
+    # @param infer_schema_length [Integer]
+    #   The maximum number of rows to scan for schema inference.
+    #   If set to `nil`, the full data may be scanned *(this is slow)*.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("json", ['{"a":1, "b": true}', nil, '{"a":2, "b": false}'])
+    #   s.str.json_decode
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'json' [struct[2]]
+    #   # [
+    #   #         {1,true}
+    #   #         null
+    #   #         {2,false}
+    #   # ]
+    def json_decode(dtype = nil, infer_schema_length: 100)
+      super
+    end
+
     # Extract the first match of json string with provided JSONPath expression.
     #
     # Throw errors if encounter invalid json strings.
@@ -479,6 +557,39 @@ module Polars
       super
     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 [Series]
+    #
+    # @note
+    #   All group names are **strings**.
+    #
+    # @example
+    #   s = Polars::Series.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"
+    #     ]
+    #   )
+    #   s.str.extract_groups("candidate=(?<candidate>\\w+)&ref=(?<ref>\\w+)")
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'url' [struct[2]]
+    #   # [
+    #   #         {"messi","python"}
+    #   #         {"weghorst","polars"}
+    #   #         {null,null}
+    #   # ]
+    def extract_groups(pattern)
+      super
+    end
+
     # Count all successive non-overlapping regex matches.
     #
     # @param pattern [String]
@@ -488,7 +599,7 @@ module Polars
     #
     # @example
     #   s = Polars::Series.new("foo", ["123 bla 45 asd", "xyz 678 910t"])
-    #   s.str.count_match('\d')
+    #   s.str.count_matches('\d')
     #   # =>
     #   # shape: (2,)
     #   # Series: 'foo' [u32]
@@ -496,9 +607,10 @@ module Polars
     #   #         5
     #   #         6
     #   # ]
-    def count_match(pattern)
+    def count_matches(pattern)
       super
     end
+    alias_method :count_match, :count_matches
 
     # Split the string by a substring.
     #
@@ -728,6 +840,108 @@ module Polars
     end
     alias_method :rstrip, :strip_chars_end
 
+    # Remove prefix.
+    #
+    # The prefix will be removed from the string exactly once, if found.
+    #
+    # @param prefix [String]
+    #   The prefix to be removed.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new(["foobar", "foofoobar", "foo", "bar"])
+    #   s.str.strip_prefix("foo")
+    #   # =>
+    #   # shape: (4,)
+    #   # Series: '' [str]
+    #   # [
+    #   #         "bar"
+    #   #         "foobar"
+    #   #         ""
+    #   #         "bar"
+    #   # ]
+    def strip_prefix(prefix)
+      super
+    end
+
+    # Remove suffix.
+    #
+    # The suffix will be removed from the string exactly once, if found.
+    #
+    # @param suffix [String]
+    #   The suffix to be removed.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new(["foobar", "foobarbar", "foo", "bar"])
+    #   s.str.strip_suffix("bar")
+    #   # =>
+    #   # shape: (4,)
+    #   # Series: '' [str]
+    #   # [
+    #   #         "foo"
+    #   #         "foobar"
+    #   #         "foo"
+    #   #         ""
+    #   # ]
+    def strip_suffix(suffix)
+      super
+    end
+
+    # 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.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", ["cow", "monkey", "hippopotamus", nil])
+    #   s.str.pad_start(8, "*")
+    #   # =>
+    #   # shape: (4,)
+    #   # Series: 'a' [str]
+    #   # [
+    #   #         "*****cow"
+    #   #         "**monkey"
+    #   #         "hippopotamus"
+    #   #         null
+    #   # ]
+    def pad_start(length, fill_char = " ")
+      super
+    end
+
+    # Pad the end 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.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new(["cow", "monkey", "hippopotamus", nil])
+    #   s.str.pad_end(8, "*")
+    #   # =>
+    #   # shape: (4,)
+    #   # Series: '' [str]
+    #   # [
+    #   #         "cow*****"
+    #   #         "monkey**"
+    #   #         "hippopotamus"
+    #   #         null
+    #   # ]
+    def pad_end(length, fill_char = " ")
+      super
+    end
+
     # Fills the string with zeroes.
     #
     # Return a copy of the string left filled with ASCII '0' digits to make a string
@@ -850,6 +1064,25 @@ module Polars
       super
     end
 
+    # Returns string values in reversed order.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("text", ["foo", "bar", "man\u0303ana"])
+    #   s.str.reverse
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'text' [str]
+    #   # [
+    #   #         "oof"
+    #   #         "rab"
+    #   #         "anañam"
+    #   # ]
+    def reverse
+      super
+    end
+
     # Create subslices of the string values of a Utf8 Series.
     #
     # @param offset [Integer]
@@ -888,5 +1121,445 @@ module Polars
       s = Utils.wrap_s(_s)
       s.to_frame.select(Polars.col(s.name).str.slice(offset, length)).to_series
     end
+
+    # Return the first n characters of each string in a String Series.
+    #
+    # @param n [Object]
+    #   Length of the slice (integer or expression). Negative indexing is supported;
+    #   see note (2) below.
+    #
+    # @return [Series]
+    #
+    # @example Return up to the first 5 characters.
+    #   s = Polars::Series.new(["pear", nil, "papaya", "dragonfruit"])
+    #   s.str.head(5)
+    #   # =>
+    #   # shape: (4,)
+    #   # Series: '' [str]
+    #   # [
+    #   #         "pear"
+    #   #         null
+    #   #         "papay"
+    #   #         "drago"
+    #   # ]
+    #
+    # @example Return up to the 3rd character from the end.
+    #   s = Polars::Series.new(["pear", nil, "papaya", "dragonfruit"])
+    #   s.str.head(-3)
+    #   # =>
+    #   # shape: (4,)
+    #   # Series: '' [str]
+    #   # [
+    #   #         "p"
+    #   #         null
+    #   #         "pap"
+    #   #         "dragonfr"
+    #   # ]
+    def head(n)
+      super
+    end
+
+    # Return the last n characters of each string in a String Series.
+    #
+    # @param n [Object]
+    #   Length of the slice (integer or expression). Negative indexing is supported;
+    #   see note (2) below.
+    #
+    # @return [Series]
+    #
+    # @example Return up to the last 5 characters:
+    #   s = Polars::Series.new(["pear", nil, "papaya", "dragonfruit"])
+    #   s.str.tail(5)
+    #   # =>
+    #   # shape: (4,)
+    #   # Series: '' [str]
+    #   # [
+    #   #         "pear"
+    #   #         null
+    #   #         "apaya"
+    #   #         "fruit"
+    #   # ]
+    #
+    # @example Return from the 3rd character to the end:
+    #   s = Polars::Series.new(["pear", nil, "papaya", "dragonfruit"])
+    #   s.str.tail(-3)
+    #   # =>
+    #   # shape: (4,)
+    #   # Series: '' [str]
+    #   # [
+    #   #         "r"
+    #   #         null
+    #   #         "aya"
+    #   #         "gonfruit"
+    #   # ]
+    def tail(n)
+      super
+    end
+
+    # Convert an String column into a column of dtype with base radix.
+    #
+    # @param base [Integer]
+    #   Positive integer or expression which is the base of the string
+    #   we are parsing.
+    #   Default: 10.
+    # @param dtype [Object]
+    #   Polars integer type to cast to.
+    #   Default: `Int64`.
+    # @param strict [Object]
+    #   Bool, Default=true will raise any ParseError or overflow as ComputeError.
+    #   false silently convert to Null.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("bin", ["110", "101", "010", "invalid"])
+    #   s.str.to_integer(base: 2, dtype: Polars::Int32, strict: false)
+    #   # =>
+    #   # shape: (4,)
+    #   # Series: 'bin' [i32]
+    #   # [
+    #   #         6
+    #   #         5
+    #   #         2
+    #   #         null
+    #   # ]
+    #
+    # @example
+    #   s = Polars::Series.new("hex", ["fa1e", "ff00", "cafe", nil])
+    #   s.str.to_integer(base: 16)
+    #   # =>
+    #   # shape: (4,)
+    #   # Series: 'hex' [i64]
+    #   # [
+    #   #         64030
+    #   #         65280
+    #   #         51966
+    #   #         null
+    #   # ]
+    def to_integer(
+      base: 10,
+      dtype: Int64,
+      strict: true
+    )
+      super
+    end
+
+    # Use the Aho-Corasick algorithm to find matches.
+    #
+    # Determines if any of the patterns are contained in the string.
+    #
+    # @param patterns [Object]
+    #   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 [Series]
+    #
+    # @note
+    #   This method supports matching on string literals only, and does not support
+    #   regular expression matching.
+    #
+    # @example
+    #   s = Polars::Series.new(
+    #     "lyrics",
+    #     [
+    #       "Everybody wants to rule the world",
+    #       "Tell me what you want, what you really really want",
+    #       "Can you feel the love tonight"
+    #     ]
+    #   )
+    #   s.str.contains_any(["you", "me"])
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'lyrics' [bool]
+    #   # [
+    #   #         false
+    #   #         true
+    #   #         true
+    #   # ]
+    def contains_any(
+      patterns,
+      ascii_case_insensitive: false
+    )
+      super
+    end
+
+    # Use the Aho-Corasick algorithm to replace many matches.
+    #
+    # @param patterns
+    #   String patterns to search and replace.
+    #   Also accepts a mapping of patterns to their replacement as syntactic sugar
+    #   for `replace_many(Polars::Series.new(mapping.keys), Polars::Series.new(mapping.values))`.
+    # @param replace_with
+    #   Strings to replace where a pattern was a match.
+    #   Length must match the length of `patterns` or have length 1. This can be
+    #   broadcasted, so it supports many:one and many:many.
+    # @param ascii_case_insensitive
+    #   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 [Series]
+    #
+    # @note
+    #   This method supports matching on string literals only, and does not support
+    #   regular expression matching.
+    #
+    # @example Replace many patterns by passing lists of equal length to the `patterns` and `replace_with` parameters.
+    #   s = Polars::Series.new(
+    #     "lyrics",
+    #     [
+    #       "Everybody wants to rule the world",
+    #       "Tell me what you want, what you really really want",
+    #       "Can you feel the love tonight"
+    #     ]
+    #   )
+    #   s.str.replace_many(["you", "me"], ["me", "you"])
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'lyrics' [str]
+    #   # [
+    #   #         "Everybody wants to rule the wo…
+    #   #         "Tell you what me want, what me…
+    #   #         "Can me feel the love tonight"
+    #   # ]
+    #
+    # @example Broadcast a replacement for many patterns by passing a sequence of length 1 to the `replace_with` parameter.
+    #   s = Polars::Series.new(
+    #     "lyrics",
+    #     [
+    #       "Everybody wants to rule the world",
+    #       "Tell me what you want, what you really really want",
+    #       "Can you feel the love tonight",
+    #     ]
+    #   )
+    #   s.str.replace_many(["me", "you", "they"], [""])
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'lyrics' [str]
+    #   # [
+    #   #         "Everybody wants to rule the wo…
+    #   #         "Tell  what  want, what  really…
+    #   #         "Can  feel the love tonight"
+    #   # ]
+    #
+    # @example Passing a mapping with patterns and replacements is also supported as syntactic sugar.
+    #   s = Polars::Series.new(
+    #     "lyrics",
+    #     [
+    #       "Everybody wants to rule the world",
+    #       "Tell me what you want, what you really really want",
+    #       "Can you feel the love tonight"
+    #     ]
+    #   )
+    #   mapping = {"me" => "you", "you" => "me", "want" => "need"}
+    #   s.str.replace_many(mapping)
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'lyrics' [str]
+    #   # [
+    #   #         "Everybody needs to rule the wo…
+    #   #         "Tell you what me need, what me…
+    #   #         "Can me feel the love tonight"
+    #   # ]
+    def replace_many(
+      patterns,
+      replace_with = Expr::NO_DEFAULT,
+      ascii_case_insensitive: false
+    )
+      super
+    end
+
+    # Use the Aho-Corasick algorithm to extract many matches.
+    #
+    # @param patterns [Object]
+    #   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.
+    # @param overlapping [Boolean]
+    #   Whether matches may overlap.
+    #
+    # @return [Series]
+    #
+    # @note
+    #   This method supports matching on string literals only, and does not support
+    #   regular expression matching.
+    #
+    # @example
+    #   s = Polars::Series.new("values", ["discontent"])
+    #   patterns = ["winter", "disco", "onte", "discontent"]
+    #   s.str.extract_many(patterns, overlapping: true)
+    #   # =>
+    #   # shape: (1,)
+    #   # Series: 'values' [list[str]]
+    #   # [
+    #   #         ["disco", "onte", "discontent"]
+    #   # ]
+    def extract_many(
+      patterns,
+      ascii_case_insensitive: false,
+      overlapping: false
+    )
+      super
+    end
+
+    # Use the Aho-Corasick algorithm to find all matches.
+    #
+    # The function returns the byte offset of the start of each match.
+    # The return type will be `List<UInt32>`
+    #
+    # @param patterns [Object]
+    #   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.
+    # @param overlapping [Boolean]
+    #   Whether matches may overlap.
+    #
+    # @return [Series]
+    #
+    # @note
+    #   This method supports matching on string literals only, and does not support
+    #   regular expression matching.
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"values" => ["discontent"]})
+    #   patterns = ["winter", "disco", "onte", "discontent"]
+    #   df.with_columns(
+    #     Polars.col("values")
+    #     .str.extract_many(patterns, overlapping: false)
+    #     .alias("matches"),
+    #     Polars.col("values")
+    #     .str.extract_many(patterns, overlapping: true)
+    #     .alias("matches_overlapping")
+    #   )
+    #   # =>
+    #   # shape: (1, 3)
+    #   # ┌────────────┬───────────┬─────────────────────────────────┐
+    #   # │ values     ┆ matches   ┆ matches_overlapping             │
+    #   # │ ---        ┆ ---       ┆ ---                             │
+    #   # │ str        ┆ list[str] ┆ list[str]                       │
+    #   # ╞════════════╪═══════════╪═════════════════════════════════╡
+    #   # │ discontent ┆ ["disco"] ┆ ["disco", "onte", "discontent"… │
+    #   # └────────────┴───────────┴─────────────────────────────────┘
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "values" => ["discontent", "rhapsody"],
+    #       "patterns" => [
+    #         ["winter", "disco", "onte", "discontent"],
+    #         ["rhap", "ody", "coalesce"]
+    #       ]
+    #     }
+    #   )
+    #   df.select(Polars.col("values").str.find_many("patterns"))
+    #   # =>
+    #   # shape: (2, 1)
+    #   # ┌───────────┐
+    #   # │ values    │
+    #   # │ ---       │
+    #   # │ list[u32] │
+    #   # ╞═══════════╡
+    #   # │ [0]       │
+    #   # │ [0, 5]    │
+    #   # └───────────┘
+    def find_many(
+      patterns,
+      ascii_case_insensitive: false,
+      overlapping: false
+    )
+      super
+    end
+
+    # Vertically concat the values in the Series to a single string value.
+    #
+    # @param delimiter [String]
+    #   The delimiter to insert between consecutive string values.
+    # @param ignore_nulls [Boolean]
+    #   Ignore null values (default).
+    #   If set to `False`, null values will be propagated. This means that
+    #   if the column contains any null values, the output is null.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   Polars::Series.new([1, nil, 2]).str.join("-")
+    #   # =>
+    #   # shape: (1,)
+    #   # Series: '' [str]
+    #   # [
+    #   #         "1-2"
+    #   # ]
+    #
+    # @example
+    #   Polars::Series.new([1, nil, 2]).str.join("-", ignore_nulls: false)
+    #   # =>
+    #   # shape: (1,)
+    #   # Series: '' [str]
+    #   # [
+    #   #         null
+    #   # ]
+    def join(delimiter = "-", ignore_nulls: true)
+      super
+    end
+    alias_method :concat, :join
+
+    # Returns string values with all regular expression meta characters escaped.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   Polars::Series.new(["abc", "def", nil, "abc(\\w+)"]).str.escape_regex
+    #   # =>
+    #   # shape: (4,)
+    #   # Series: '' [str]
+    #   # [
+    #   #         "abc"
+    #   #         "def"
+    #   #         null
+    #   #         "abc\(\\w\+\)"
+    #   # ]
+    def escape_regex
+      super
+    end
+
+    # Returns the Unicode normal form of the string values.
+    #
+    # This uses the forms described in Unicode Standard Annex 15: <https://www.unicode.org/reports/tr15/>.
+    #
+    # @param form ['NFC', 'NFKC', 'NFD', 'NFKD']
+    #   Unicode form to use.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new(["01²", "ＫＡＤＯＫＡＷＡ"])
+    #   s.str.normalize("NFC")
+    #   # =>
+    #   # shape: (2,)
+    #   # Series: '' [str]
+    #   # [
+    #   #         "01²"
+    #   #         "ＫＡＤＯＫＡＷＡ"
+    #   # ]
+    #
+    # @example
+    #   s.str.normalize("NFKC")
+    #   # =>
+    #   # shape: (2,)
+    #   # Series: '' [str]
+    #   # [
+    #   #         "012"
+    #   #         "KADOKAWA"
+    #   # ]
+    def normalize(form = "NFC")
+      super
+    end
   end
 end