Remove Enum.equal?

There is a branch work refactoring Enum and Enum.equal?
contains some limitations. We are removing it for now
since it was not officially released yet.

Author: José Valim

CHANGELOG.md

@@ -1,7 +1,7 @@
 * enhancements
   * [CLI] Flags `-p` and `-pr` fails if pattern match no files
   * [CLI] Support `--hidden` and `--cookie` flags for distributed Erlang
-  * [Enum] Add `Enum.to_list/1`, `Enum.equal?/2`, `Enum.equal?/3`, `Enum.member?/2`, `Enum.uniq/2`, `Enum.max/1`, `Enum.max/2`, `Enum.min/1` and `Enum.min/2`
+  * [Enum] Add `Enum.to_list/1`, `Enum.member?/2`, `Enum.uniq/2`, `Enum.max/1`, `Enum.max/2`, `Enum.min/1` and `Enum.min/2`
   * [ExUnit] Add `ExUnit.CaptureIO` for IO capturing during tests
   * [ExUnit] Consider load time on ExUnit time reports
   * [IEx] Support `ls` with colored output

lib/elixir/lib/enum.ex

@@ -349,125 +349,6 @@ defmodule Enum do
     end
   end
 
-  @doc """
-  Returns true if the first collection is equal to the second, every element in
-  both collections is iterated through, as soon as an element differs, it
-  returns false.
-
-  ## Examples
-
-      iex> Enum.equal?([], [])
-      true
-      iex> Enum.equal?(1 .. 3, [1, 2, 3])
-      true
-      iex> Enum.equal?(1 .. 3, [])
-      false
-
-  """
-  @spec equal?(t, t) :: boolean
-  def equal?(a, b) when is_list(a) and is_list(b) do
-    a == b
-  end
-
-  def equal?(a, b) when is_list(a) do
-    equal?(b, a)
-  end
-
-  def equal?(a, b) when is_list(b) do
-    case I.iterator(a) do
-      { _, :stop } ->
-        b == []
-
-      { iterator, pointer } ->
-        do_equal?(pointer, iterator, b)
-
-      list ->
-        list == b
-    end
-  end
-
-  def equal?(a, b) do
-    case { I.iterator(a), I.iterator(b) } do
-      { { a_iterator, a_pointer }, { b_iterator, b_pointer } } ->
-        do_equal?(a_pointer, a_iterator, b_pointer, b_iterator)
-
-      { { iterator, pointer }, b } ->
-        do_equal?(pointer, iterator, b)
-
-      { a, { iterator, pointer } } ->
-        do_equal?(pointer, iterator, a)
-
-      { a, b } ->
-        a == b
-    end
-  end
-
-  @doc """
-  Returns true if the first collection is equal to the second, every element in
-  both collections is iterated through and compared with the passed function,
-  as soon as an element differs, it returns false.
-
-  Please note that the first parameter passed to the compare function isn't
-  ensured to be an element from the first collection.
-
-  ## Examples
-
-      iex> Enum.equal?([], [], &1 === &2)
-      true
-      iex> Enum.equal?([1 .. 3], [[1, 2, 3]], Enum.equal?(&1, &2))
-      true
-      iex> Enum.equal?(1 .. 3, [1.0, 2.0, 3.0], &1 === &2)
-      false
-      iex> Enum.equal?(1 .. 3, [], &1 === &2)
-      false
-
-  """
-  @spec equal?(t, t, ((term, term) -> boolean)) :: boolean
-  def equal?([], [], _) do
-    true
-  end
-
-  def equal?(a, b, _) when is_list(a) and is_list(b) and a == [] or b == [] do
-    false
-  end
-
-  def equal?(a, b, fun) when is_list(a) and is_list(b) do
-    do_equal_with?(fun, a, b)
-  end
-
-  def equal?(a, b, fun) when is_list(a) do
-    equal?(b, a, fun)
-  end
-
-  def equal?(a, b, fun) when is_list(b) do
-    case I.iterator(a) do
-      { _, :stop } ->
-        b == []
-
-      { iterator, pointer } ->
-        do_equal_with?(fun, pointer, iterator, b)
-
-      list ->
-        do_equal_with?(fun, list, b)
-    end
-  end
-
-  def equal?(a, b, fun) do
-    case { I.iterator(a), I.iterator(b) } do
-      { { a_iterator, a_pointer }, { b_iterator, b_pointer } } ->
-        do_equal_with?(fun, a_pointer, a_iterator, b_pointer, b_iterator)
-
-      { { iterator, pointer }, b } ->
-        do_equal_with?(fun, pointer, iterator, b)
-
-      { a, { iterator, pointer } } ->
-        do_equal_with?(fun, pointer, iterator, a)
-
-      { a, b } ->
-        do_equal_with?(fun, a, b)
-    end
-  end
-
   @doc """
   Finds the element at the given index (zero-based).
   Returns `{ :ok, element }` if found, otherwise `:error`.
@@ -1424,113 +1305,6 @@ defmodule Enum do
     []
   end
 
-  ## equal?
-
-  # iterator : iterator
-  defp do_equal?(:stop, _, :stop, _) do
-    true
-  end
-
-  defp do_equal?(:stop, _, _, _) do
-    false
-  end
-
-  defp do_equal?(_, _, :stop, _) do
-    false
-  end
-
-  defp do_equal?({ a, _ }, _, { b, _ }, _) when a != b do
-    false
-  end
-
-  defp do_equal?({ _, a_next }, a_iterator, { _, b_next }, b_iterator) do
-    do_equal?(a_iterator.(a_next), a_iterator, b_iterator.(b_next), b_iterator)
-  end
-
-  # iterator : list
-  defp do_equal?({ _, _ }, _, []) do
-    false
-  end
-
-  defp do_equal?(:stop, _, []) do
-    true
-  end
-
-  defp do_equal?(:stop, _, _) do
-    false
-  end
-
-  defp do_equal?({ a, _ }, _, [b | _]) when a != b do
-    false
-  end
-
-  defp do_equal?({ _, a_next }, iterator, [_ | b_next]) do
-    do_equal?(iterator.(a_next), iterator, b_next)
-  end
-
-  # iterator : iterator
-  defp do_equal_with?(_, :stop, _, :stop, _) do
-    true
-  end
-
-  defp do_equal_with?(_, :stop, _, _, _) do
-    false
-  end
-
-  defp do_equal_with?(_, _, _, :stop, _) do
-    false
-  end
-
-  defp do_equal_with?(fun, { a, a_next }, a_iterator, { b, b_next }, b_iterator) do
-    if fun.(a, b) do
-      do_equal_with?(fun, a_iterator.(a_next), a_iterator, b_iterator.(b_next), b_iterator)
-    else
-      false
-    end
-  end
-
-  # iterator : list
-  defp do_equal_with?(_, :stop, _, []) do
-    true
-  end
-
-  defp do_equal_with?(_, :stop, _, _) do
-    false
-  end
-
-  defp do_equal_with?(_, { _, _ }, _, []) do
-    false
-  end
-
-  defp do_equal_with?(fun, { a, a_next }, iterator, [b | b_next]) do
-    if fun.(a, b) do
-      do_equal_with?(fun, iterator.(a_next), iterator, b_next)
-    else
-      false
-    end
-  end
-
-  # list : list
-  defp do_equal_with?(_, [], []) do
-    true
-  end
-
-  defp do_equal_with?(_, [], _) do
-    false
-  end
-
-  defp do_equal_with?(_, _, []) do
-    false
-  end
-
-  defp do_equal_with?(fun, [a | a_next], [b | b_next]) do
-    if fun.(a, b) do
-      do_equal_with?(fun, a_next, b_next)
-    else
-      false
-    end
-  end
-
   ## find
 
   defp do_find([h|t], ifnone, fun) do

lib/elixir/test/elixir/enum_test.exs

@@ -96,28 +96,6 @@ defmodule EnumTest.List do
     assert Enum.find_index([2,3,4], fn(x) -> rem(x, 2) == 1 end) == 1
   end
 
-  test :equal? do
-    assert Enum.equal?([], [])
-    refute Enum.equal?([], [1])
-
-    assert Enum.equal?(1 .. 3, [1, 2, 3])
-    assert Enum.equal?(1 .. 3, 1 .. 3)
-    refute Enum.equal?(1 .. 3, 1 .. 10)
-    refute Enum.equal?(1 .. 3, [])
-    assert Enum.equal?([1, 2, 3], 1 .. 3)
-    assert Enum.equal?(1 .. 3, 1 .. 3)
-    refute Enum.equal?(1 .. 3, 1 .. 10)
-    refute Enum.equal?(1 .. 3, [])
-    refute Enum.equal?([], 1 .. 3)
-
-    refute Enum.equal?(1 .. 3, [1.0, 2.0, 3.0], &1 === &2)
-    refute Enum.equal?(1 .. 3, [], &1 === &2)
-    refute Enum.equal?([], 1 .. 3, &1 === &2)
-    refute Enum.equal?(1 .. 3, 1 .. 5, &1 == &2)
-    assert Enum.equal?(1 .. 3, [1, 2, 3], &1 === &2)
-    assert Enum.equal?([1, 2, 3], [1, 2, 3], &1 === &2)
-  end
-
   test :each do
     try do
       assert Enum.each([], fn(x) -> x end) == :ok