Enum.split_while did not behave as advertised and provided the wrong API. Provide Enum.split_with instead

Author: José Valim

lib/elixir/lib/enum.ex

@@ -776,20 +776,21 @@ defmodule Enum do
 
   ## Examples
 
-      Enum.split_while [1,2,3,4], fn x -> x == 2 end
-      #=> { [1], [2, 3, 4] }
+      Enum.split_with [1,2,3,4], fn x -> x == 2 end
+      #=> { [1,3,4], [2] }
+
   """
-  @spec split_while(t, (element -> as_boolean(term))) :: {list, list}
-  def split_while(collection, fun) when is_list(collection) do
-    do_split_while(collection, fun, [])
+  @spec split_with(t, (element -> as_boolean(term))) :: {list, list}
+  def split_with(collection, fun) when is_list(collection) do
+    do_split_with(collection, fun, [])
   end
 
-  def split_while(collection, fun) do
+  def split_with(collection, fun) do
     case I.iterator(collection) do
       { iterator, pointer } ->
-        do_split_while(pointer, iterator, fun, [])
+        do_split_with(pointer, iterator, fun, [])
       list when is_list(list) ->
-        do_split_while(list, fun, [])
+        do_split_with(list, fun, [])
     end
   end
 
@@ -1460,29 +1461,29 @@ defmodule Enum do
     { :lists.reverse(acc), [] }
   end
 
-  ## split_while
+  ## split_with
 
-  defp do_split_while([h|t], fun, acc) do
+  defp do_split_with([h|t], fun, acc) do
     if fun.(h) do
-      do_split_while(t, fun, [h|acc])
+      do_split_with(t, fun, [h|acc])
     else
       { :lists.reverse(acc), [h|t] }
     end
   end
 
-  defp do_split_while([], _, acc) do
+  defp do_split_with([], _, acc) do
     { :lists.reverse(acc), [] }
   end
 
-  defp do_split_while({ h, next } = extra, iterator, fun, acc) do
+  defp do_split_with({ h, next } = extra, iterator, fun, acc) do
     if fun.(h) do
-      do_split_while(iterator.(next), iterator, fun, [h|acc])
+      do_split_with(iterator.(next), iterator, fun, [h|acc])
     else
       { :lists.reverse(acc), to_list(extra, iterator) }
     end
   end
 
-  defp do_split_while(:stop, _, _, acc) do
+  defp do_split_with(:stop, _, _, acc) do
     { :lists.reverse(acc), [] }
   end
 

lib/elixir/test/elixir/enum_test.exs

@@ -188,13 +188,13 @@ defmodule EnumTest.List do
     assert Enum.split([1,2,3], -10) == { [], [1,2,3] }
   end
 
-  test :split_while do
-    assert Enum.split_while([1,2,3], fn(_) -> false end) == { [], [1,2,3] }
-    assert Enum.split_while([1,2,3], fn(_) -> true end) == { [1,2,3], [] }
-    assert Enum.split_while([1,2,3], fn(x) -> x > 2 end) == { [], [1,2,3] }
-    assert Enum.split_while([1,2,3], fn(x) -> x > 3 end) == { [], [1,2,3] }
-    assert Enum.split_while([1,2,3], fn(x) -> x < 3 end) == { [1,2], [3] }
-    assert Enum.split_while([], fn(_) -> true end) == { [], [] }
+  test :split_with do
+    assert Enum.split_with([1,2,3], fn(_) -> false end) == { [], [1,2,3] }
+    assert Enum.split_with([1,2,3], fn(_) -> true end) == { [1,2,3], [] }
+    assert Enum.split_with([1,2,3], fn(x) -> x > 2 end) == { [], [1,2,3] }
+    assert Enum.split_with([1,2,3], fn(x) -> x > 3 end) == { [], [1,2,3] }
+    assert Enum.split_with([1,2,3], fn(x) -> x < 3 end) == { [1,2], [3] }
+    assert Enum.split_with([], fn(_) -> true end) == { [], [] }
   end
 
   test :take do
@@ -499,16 +499,16 @@ defmodule EnumTest.Range do
     assert Enum.split(range, 3) == { [1,0], [] }
   end
 
-  test :split_while do
+  test :split_with do
     range = Range.new(first: 1, last: 3)
-    assert Enum.split_while(range, fn(_) -> false end) == { [], [1,2,3] }
-    assert Enum.split_while(range, fn(_) -> true end) == { [1,2,3], [] }
-    assert Enum.split_while(range, fn(x) -> x > 2 end) == { [], [1,2,3] }
-    assert Enum.split_while(range, fn(x) -> x > 3 end) == { [], [1,2,3] }
-    assert Enum.split_while(range, fn(x) -> x < 3 end) == { [1,2], [3] }
+    assert Enum.split_with(range, fn(_) -> false end) == { [], [1,2,3] }
+    assert Enum.split_with(range, fn(_) -> true end) == { [1,2,3], [] }
+    assert Enum.split_with(range, fn(x) -> x > 2 end) == { [], [1,2,3] }
+    assert Enum.split_with(range, fn(x) -> x > 3 end) == { [], [1,2,3] }
+    assert Enum.split_with(range, fn(x) -> x < 3 end) == { [1,2], [3] }
 
     range = Range.new(first: 1, last: 0)
-    assert Enum.split_while(range, fn(_) -> true end) == { [1, 0], [] }
+    assert Enum.split_with(range, fn(_) -> true end) == { [1, 0], [] }
   end
 
   test :take do