Remove Enum.zip_reduce_while, as it is equivalent to Stream.zip+Enum.reduce_while

Author: josevalim

lib/elixir/lib/enum.ex

@@ -3447,7 +3447,7 @@ defmodule Enum do
   def zip([]), do: []
 
   def zip(enumerables) do
-    zip_reduce_while(enumerables, [], &{:cont, [List.to_tuple(&1) | &2]})
+    zip_reduce(enumerables, [], &[List.to_tuple(&1) | &2])
     |> :lists.reverse()
   end
 
@@ -3497,9 +3497,7 @@ defmodule Enum do
   end
 
   def zip_with(enumerable1, enumerable2, zip_fun) when is_function(zip_fun, 2) do
-    reducer = fn l, r, acc -> {:cont, [zip_fun.(l, r) | acc]} end
-
-    zip_reduce_while(enumerable1, enumerable2, [], reducer)
+    zip_reduce(enumerable1, enumerable2, [], fn l, r, acc -> [zip_fun.(l, r) | acc] end)
     |> :lists.reverse()
   end
 
@@ -3529,15 +3527,19 @@ defmodule Enum do
   def zip_with([], _fun), do: []
 
   def zip_with(enumerables, zip_fun) do
-    reducer = fn values, acc -> {:cont, [zip_fun.(values) | acc]} end
-
-    zip_reduce_while(enumerables, [], reducer)
+    zip_reduce(enumerables, [], fn values, acc -> [zip_fun.(values) | acc] end)
     |> :lists.reverse()
   end
 
   @doc """
   Reduces over two enumerables halting as soon as either enumerable is empty.
 
+  In practice, the behaviour provided by this function can be achieved with:
+
+      Enum.reduce(Stream.zip(left, right), acc, reducer)
+
+  But `zip_reduce/4` exists for convenience purposes.
+
   ## Examples
 
       iex> Enum.zip_reduce([1, 2], [3, 4], 0, fn x, y, acc -> x + y + acc end)
@@ -3555,8 +3557,8 @@ defmodule Enum do
   end
 
   def zip_reduce(left, right, acc, reducer) when is_function(reducer, 3) do
-    non_stop_reducer = &{:cont, reducer.(&1, &2, &3)}
-    zip_reduce_while(left, right, acc, non_stop_reducer)
+    reduce = fn [l, r], acc -> {:cont, reducer.(l, r, acc)} end
+    Stream.zip_with([left, right], & &1).({:cont, acc}, reduce) |> elem(1)
   end
 
   @doc """
@@ -3565,6 +3567,12 @@ defmodule Enum do
   The reducer will receive 2 args, a list of elements (one from each enum) and the
   accumulator.
 
+  In practice, the behaviour provided by this function can be achieved with:
+
+      Enum.reduce(Stream.zip(enums), acc, reducer)
+
+  But `zip_reduce/4` exists for convenience purposes.
+
   ## Examples
 
       iex> enums = [[1, 1], [2, 2], [3, 3]]
@@ -3584,80 +3592,7 @@ defmodule Enum do
   def zip_reduce([], acc, reducer) when is_function(reducer, 2), do: acc
 
   def zip_reduce(enums, acc, reducer) when is_function(reducer, 2) do
-    non_stop_reducer = &{:cont, reducer.(&1, &2)}
-    zip_reduce_while(enums, acc, non_stop_reducer)
-  end
-
-  @doc """
-  Reduces over two enumerables halting if the accumulator returns
-  `{:halt, value}` or if either of the enumerables is empty.
-
-  The reducer will receive 3 args, the left enumerable's element,
-  the right enumberable's element and the accumulator. It should
-  return one of:
-
-    * `{:halt, value}` - This will halt the reduction and return `value`
-    * `{:cont, value}` - This will continue with the next step of the reduction
-
-  ## Examples
-
-      iex> reducer = fn left, right, acc -> {:cont, [left + right | acc ]} end
-      ...> Enum.zip_reduce_while([1], [2], [], reducer)
-      [3]
-
-      iex> Enum.zip_reduce_while([1, 2], [2, 2], [], fn left, right, acc ->
-      ...>   if left <= 1, do: {:cont, [left + right | acc]}, else: {:halt, acc}
-      ...> end)
-      [3]
-
-  """
-  @doc since: "1.12.0"
-  @spec zip_reduce_while(t, t, acc, (enum1_elem :: term, enum2_elem :: term, acc -> acc)) ::
-          {:cont | :halt, acc}
-        when acc: term
-  def zip_reduce_while(left, right, acc, reducer)
-      when is_list(left) and is_list(right) and is_function(reducer, 3) do
-    zip_reduce_while_list(left, right, {:cont, acc}, reducer)
-  end
-
-  def zip_reduce_while(left, right, acc, reducer) when is_function(reducer, 3) do
-    reduce = fn [l, r], acc -> reducer.(l, r, acc) end
-    Stream.zip_with([left, right], & &1).({:cont, acc}, reduce) |> elem(1)
-  end
-
-  @doc """
-  Reduces over all enumerables halting if the accumulator returns
-  `{:halt, value}` or if any of the enumerables is empty.
-
-  The reducer will receive 2 args, a list of the yielded elements
-  and the accumulator. It should return one of:
-
-    * `{:halt, value}` - This will halt the reduction and return `value`
-    * `{:cont, value}` - This will continue with the next step of the reduction
-
-  ## Examples
-
-      iex> enums = [[1, 2],[3, 4]]
-      ...> reducer = fn values, acc -> {:cont, Enum.sum(values) + acc} end
-      ...> Enum.zip_reduce_while(enums, 0, reducer)
-      10
-
-      iex> enums = [[1, 2],[3, 4]]
-      ...> reducer = fn values, acc -> {:suspend, [Enum.sum(values) | acc]} end
-      ...> Enum.zip_reduce_while(enums, [], reducer)
-      [4]
-
-      iex> enums = [[1, 2],[3, 4]]
-      ...> reducer = fn values, acc -> {:halt, [Enum.sum(values) | acc]} end
-      ...> Enum.zip_reduce_while(enums, [], reducer)
-      [4]
-  """
-  @doc since: "1.12.0"
-  @spec zip_reduce_while([t], acc, ([term], acc -> acc)) :: {:cont | :halt, acc} when acc: term
-  def zip_reduce_while([], acc, reducer) when is_function(reducer, 2), do: acc
-
-  def zip_reduce_while(enums, acc, reducer) when is_function(reducer, 2) do
-    Stream.zip_with(enums, & &1).({:cont, acc}, reducer) |> elem(1)
+    Stream.zip_with(enums, & &1).({:cont, acc}, &{:cont, reducer.(&1, &2)}) |> elem(1)
   end
 
   ## Helpers
@@ -4281,14 +4216,6 @@ defmodule Enum do
 
   defp zip_reduce_list(_, [], acc, _fun), do: acc
   defp zip_reduce_list([], _, acc, _fun), do: acc
-
-  defp zip_reduce_while_list(_left, _right, {:halt, acc}, _), do: acc
-  defp zip_reduce_while_list([], _right, {:cont, acc}, _), do: acc
-  defp zip_reduce_while_list(_left, [], {:cont, acc}, _), do: acc
-
-  defp zip_reduce_while_list([l_head | l_tail], [r_head | r_tail], {:cont, acc}, reducer) do
-    zip_reduce_while_list(l_tail, r_tail, reducer.(l_head, r_head, acc), reducer)
-  end
 end
 
 defimpl Enumerable, for: List do

lib/elixir/test/elixir/enum_test.exs

@@ -62,84 +62,6 @@ defmodule EnumTest do
     end
   end
 
-  describe "zip_reduce_while/4" do
-    test "lists" do
-      left = [1, 2]
-      right = [3, 4]
-      reducer = fn x, y, acc -> {:cont, x + y + acc} end
-      assert Enum.zip_reduce_while(left, right, 0, reducer) == 10
-
-      left = [1, 2]
-      right = [3, 4]
-      reducer = fn x, y, acc -> {:cont, [x + y | acc]} end
-      assert Enum.zip_reduce_while(left, right, [], reducer) == [6, 4]
-
-      # Halting the reduction
-      left = [1, 2]
-      right = [3, 4]
-      reducer = fn x, y, acc -> {:halt, [x + y | acc]} end
-      assert Enum.zip_reduce_while(left, right, [], reducer) == [4]
-    end
-
-    test "two non lists" do
-      left = %{a: 1}
-      right = %{b: 2}
-      reducer = fn {_, x}, {_, y}, acc -> {:cont, [x + y | acc]} end
-      assert Enum.zip_reduce_while(left, right, [], reducer) == [3]
-    end
-  end
-
-  describe "zip_reduce_while/3" do
-    test "lists" do
-      enums = [[1, 2], [3, 4]]
-      reducer = fn values, acc -> {:cont, Enum.sum(values) + acc} end
-      assert Enum.zip_reduce_while(enums, 0, reducer) == 10
-
-      reducer = fn values, acc -> {:cont, [Enum.sum(values) | acc]} end
-      assert Enum.zip_reduce_while(enums, [], reducer) == [6, 4]
-
-      # Suspending the reduction
-      reducer = fn values, acc -> {:suspend, [Enum.sum(values) | acc]} end
-      result = Enum.zip_reduce_while(enums, [], reducer)
-      assert result == [4]
-
-      # Halting the reduction
-      reducer = fn values, acc -> {:halt, [Enum.sum(values) | acc]} end
-      assert Enum.zip_reduce_while(enums, [], reducer) == [4]
-    end
-
-    test "non lists" do
-      enums = [%{a: 1, b: 2}, %{c: 3, d: 4}]
-
-      reducer = fn values, acc ->
-        {:cont, Enum.sum(Enum.map(values, &elem(&1, 1))) + acc}
-      end
-
-      assert Enum.zip_reduce_while(enums, 0, reducer) == 10
-
-      reducer = fn values, acc ->
-        {:cont, [Enum.sum(Enum.map(values, &elem(&1, 1))) | acc]}
-      end
-
-      assert Enum.zip_reduce_while(enums, [], reducer) == [6, 4]
-
-      # Suspending the reduction
-      reducer = fn values, acc ->
-        {:suspend, [Enum.sum(Enum.map(values, &elem(&1, 1))) | acc]}
-      end
-
-      result = Enum.zip_reduce_while(enums, [], reducer)
-      assert result == [4]
-
-      # Halting the reduction
-      reducer = fn values, acc ->
-        {:halt, [Enum.sum(Enum.map(values, &elem(&1, 1))) | acc]}
-      end
-
-      assert Enum.zip_reduce_while(enums, [], reducer) == [4]
-    end
-  end
-
   test "all?/2" do
     assert Enum.all?([2, 4, 6])
     refute Enum.all?([2, nil, 4])