Make split operations consistent with replace

Both String.replace/3 and Regex.replace/3 consider there is
an empty string before and after the subject when doing replacements:

    String.replace("abc", "", "x")
    #=> "xaxbxcx"

This change makes String.split/2 and Regex.split/2 consistent
with this operation by returning empty strings before and after
the split subject:

    String.split("abc", "")
    #=> ["", "a", "b", "c", ""]

Closes #7023

Author: José Valim

lib/elixir/lib/regex.ex

@@ -439,7 +439,7 @@ defmodule Regex do
       ["abc"]
 
       iex> Regex.split(~r{}, "abc")
-      ["a", "b", "c", ""]
+      ["", "a", "b", "c", ""]
 
       iex> Regex.split(~r{a(?<second>b)c}, "abc")
       ["", ""]
@@ -509,25 +509,21 @@ defmodule Regex do
     new_offset = pos + length
     keep = pos - offset
 
-    if keep == 0 and length == 0 do
-      do_split([h | t], string, new_offset, counter, trim, true)
-    else
-      <<_::binary-size(offset), part::binary-size(keep), match::binary-size(length), _::binary>> =
-        string
+    <<_::binary-size(offset), part::binary-size(keep), match::binary-size(length), _::binary>> =
+      string
 
-      if keep == 0 and (length == 0 or trim) do
-        [match | do_split([h | t], string, new_offset, counter - 1, trim, true)]
-      else
-        [part, match | do_split([h | t], string, new_offset, counter - 1, trim, true)]
-      end
+    if keep == 0 and trim do
+      [match | do_split([h | t], string, new_offset, counter - 1, trim, true)]
+    else
+      [part, match | do_split([h | t], string, new_offset, counter - 1, trim, true)]
     end
   end
 
   defp do_split([[{pos, length} | h] | t], string, offset, counter, trim, false) do
     new_offset = pos + length
     keep = pos - offset
 
-    if keep == 0 and (length == 0 or trim) do
+    if keep == 0 and trim do
       do_split([h | t], string, new_offset, counter, trim, false)
     else
       <<_::binary-size(offset), part::binary-size(keep), _::binary>> = string

lib/elixir/lib/string.ex

@@ -341,16 +341,19 @@ defmodule String do
       iex> String.split("abc", ~r{b}, include_captures: true)
       ["a", "b", "c"]
 
-  Splitting on empty patterns returns graphemes:
+  Splitting on empty string returns graphemes:
 
       iex> String.split("abc", "")
-      ["a", "b", "c", ""]
+      ["", "a", "b", "c", ""]
 
       iex> String.split("abc", "", trim: true)
       ["a", "b", "c"]
 
-      iex> String.split("abc", "", parts: 2)
-      ["a", "bc"]
+      iex> String.split("abc", "", parts: 1)
+      ["abc"]
+
+      iex> String.split("abc", "", parts: 3)
+      ["", "a", "bc"]
 
   A precompiled pattern can also be given:
 
@@ -379,7 +382,19 @@ defmodule String do
     Regex.split(pattern, string, options)
   end
 
-  def split(string, pattern, []) when is_binary(string) and pattern != "" do
+  def split(string, "", options) when is_binary(string) do
+    parts = Keyword.get(options, :parts, :infinity)
+    index = parts_to_index(parts)
+    trim = Keyword.get(options, :trim, false)
+
+    if trim == false and index != 1 do
+      ["" | split_empty(string, trim, index - 1)]
+    else
+      split_empty(string, trim, index)
+    end
+  end
+
+  def split(string, pattern, []) when is_tuple(pattern) or is_binary(string) do
     :binary.split(string, pattern, [:global])
   end
 
@@ -393,6 +408,16 @@ defmodule String do
   defp parts_to_index(:infinity), do: 0
   defp parts_to_index(n) when is_integer(n) and n > 0, do: n
 
+  defp split_empty("", true, 1), do: []
+  defp split_empty(string, _, 1), do: [string]
+
+  defp split_empty(string, trim, count) do
+    case next_grapheme(string) do
+      {h, t} -> [h | split_empty(t, trim, count - 1)]
+      nil -> split_empty("", trim, 1)
+    end
+  end
+
   defp split_each("", _pattern, true, 1), do: []
   defp split_each(string, _pattern, _trim, 1) when is_binary(string), do: [string]
 
@@ -424,26 +449,37 @@ defmodule String do
       ["1", "2", "3", "4"]
 
       iex> String.splitter("abcd", "") |> Enum.take(10)
-      ["a", "b", "c", "d", ""]
+      ["", "a", "b", "c", "d", ""]
 
       iex> String.splitter("abcd", "", trim: true) |> Enum.take(10)
       ["a", "b", "c", "d"]
 
   """
   @spec splitter(t, pattern, keyword) :: Enumerable.t()
-  def splitter(string, pattern, options \\ []) do
+  def splitter(string, pattern, options \\ [])
+
+  def splitter(string, "", options) do
+    if Keyword.get(options, :trim, false) do
+      Stream.unfold(string, &next_grapheme/1)
+    else
+      Stream.unfold(:match, &do_empty_splitter(&1, string))
+    end
+  end
+
+  def splitter(string, pattern, options) do
     pattern = maybe_compile_pattern(pattern)
     trim = Keyword.get(options, :trim, false)
     Stream.unfold(string, &do_splitter(&1, pattern, trim))
   end
 
+  defp do_empty_splitter(:match, string), do: {"", string}
+  defp do_empty_splitter(:nomatch, _string), do: nil
+  defp do_empty_splitter("", _), do: {"", :nomatch}
+  defp do_empty_splitter(string, _), do: next_grapheme(string)
+
   defp do_splitter(:nomatch, _pattern, _), do: nil
-  defp do_splitter("", _pattern, true), do: nil
   defp do_splitter("", _pattern, false), do: {"", :nomatch}
-
-  defp do_splitter(bin, "", _trim) do
-    next_grapheme(bin)
-  end
+  defp do_splitter("", _pattern, true), do: nil
 
   defp do_splitter(bin, pattern, trim) do
     case :binary.split(bin, pattern) do
@@ -453,7 +489,6 @@ defmodule String do
     end
   end
 
-  defp maybe_compile_pattern(""), do: ""
   defp maybe_compile_pattern(pattern) when is_tuple(pattern), do: pattern
   defp maybe_compile_pattern(pattern), do: :binary.compile_pattern(pattern)
 

lib/elixir/test/elixir/regex_test.exs

@@ -211,11 +211,17 @@ defmodule RegexTest do
     assert Regex.split(~r/([ln])/, "Erlang", include_captures: true) == ["Er", "l", "a", "n", "g"]
     assert Regex.split(~r/([kw])/, "Elixir", include_captures: true) == ["Elixir"]
 
-    parts = ["Elixir"]
-    assert Regex.split(~r/([Ee]lixir)/, "Elixir", include_captures: true, trim: true) == parts
+    assert Regex.split(~r/([Ee]lixir)/, "Elixir", include_captures: true, trim: true) ==
+             ["Elixir"]
 
-    parts = ["", "Elixir", ""]
-    assert Regex.split(~r/([Ee]lixir)/, "Elixir", include_captures: true, trim: false) == parts
+    assert Regex.split(~r/([Ee]lixir)/, "Elixir", include_captures: true, trim: false) ==
+             ["", "Elixir", ""]
+
+    assert Regex.split(~r//, "abc", include_captures: true) ==
+             ["", "", "a", "", "b", "", "c", "", ""]
+
+    assert Regex.split(~r/a/, "abc", include_captures: true) == ["", "a", "bc"]
+    assert Regex.split(~r/c/, "abc", include_captures: true) == ["ab", "c", ""]
   end
 
   test "replace/3,4" do

lib/elixir/test/elixir/string_test.exs

@@ -56,17 +56,21 @@ defmodule StringTest do
     assert String.split(" a b c ", " ", trim: true, parts: 1) == [" a b c "]
     assert String.split(" a b c ", " ", trim: true, parts: 2) == ["a", "b c "]
 
-    assert String.split("abé", "") == ["a", "b", "é", ""]
-    assert String.split("abé", "", parts: :infinity) == ["a", "b", "é", ""]
+    assert String.split("abé", "") == ["", "a", "b", "é", ""]
+    assert String.split("abé", "", parts: :infinity) == ["", "a", "b", "é", ""]
     assert String.split("abé", "", parts: 1) == ["abé"]
-    assert String.split("abé", "", parts: 2) == ["a", "bé"]
-    assert String.split("abé", "", parts: 10) == ["a", "b", "é", ""]
+    assert String.split("abé", "", parts: 2) == ["", "abé"]
+    assert String.split("abé", "", parts: 3) == ["", "a", "bé"]
+    assert String.split("abé", "", parts: 4) == ["", "a", "b", "é"]
+    assert String.split("abé", "", parts: 5) == ["", "a", "b", "é", ""]
+    assert String.split("abé", "", parts: 10) == ["", "a", "b", "é", ""]
     assert String.split("abé", "", trim: true) == ["a", "b", "é"]
     assert String.split("abé", "", trim: true, parts: :infinity) == ["a", "b", "é"]
     assert String.split("abé", "", trim: true, parts: 2) == ["a", "bé"]
+    assert String.split("abé", "", trim: true, parts: 3) == ["a", "b", "é"]
+    assert String.split("abé", "", trim: true, parts: 4) == ["a", "b", "é"]
 
-    assert String.split("noël", "") == ["n", "o", "ë", "l", ""]
-
+    assert String.split("noël", "") == ["", "n", "o", "ë", "l", ""]
     assert String.split("x-", "-", parts: 2, trim: true) == ["x"]
     assert String.split("x-x-", "-", parts: 3, trim: true) == ["x", "x"]
   end