Remove iterator references in code

Author: ericmj

lib/elixir/lib/enum.ex

@@ -18,38 +18,6 @@ defprotocol Enum.Iterator do
 
   def reduce(collection, acc, fun)
 
-  @doc """
-  This function must return a tuple of the form `{ iter, step }` where
-  `iter` is a function that yields successive values from the collection
-  each time it is invoked and `step` is the first step of iteration.
-
-  Iteration in Elixir happens with the help of an _iterator function_ (named
-  `iter` in the paragraph above). When it is invoked, it must return a tuple
-  with two elements. The first element is the next successive value from the
-  collection and the second element can be any Elixir term which `iter` is
-  going to receive as its argument the next time it is invoked.
-
-  When there are no more items left to yield, `iter` must return the atom
-  `:stop`.
-
-  As an example, here is the implementation of `iterator` for lists:
-
-      def iterator(list),   do: { iterate(&1), iterate(list) }
-      defp iterate([h|t]),  do: { h, t }
-      defp iterate([]),     do: :stop
-
-  Here, `iterate` is the _iterator function_ and `{ h, t }` is a step of
-  iteration.
-
-  ## Iterating lists
-
-  As a special case, if a data structure needs to be converted to a list in
-  order to be iterated, `iterator` can simply return the list and the `Enum`
-  module will be able to take over the list and produce a proper iterator
-  function for it.
-  """
-  def iterator(collection)
-
   @doc """
   The function used to check if a value exists within the collection.
   """
@@ -1218,10 +1186,6 @@ defmodule Enum do
   defp do_fetch([_|t], n), do: do_fetch(t, n - 1)
   defp do_fetch([], _),    do: :error
 
-  defp do_fetch({ h, _next }, _iterator, 0), do: { :ok, h }
-  defp do_fetch({ _, next }, iterator, n),   do: do_fetch(iterator.(next), iterator, n - 1)
-  defp do_fetch(:stop, _iterator, _),        do: :error
-
   ## drop
 
   defp do_drop([_|t], counter) when counter > 0 do
@@ -1303,12 +1267,6 @@ defmodule Enum do
     acc || ""
   end
 
-  ## map
-
-  defp do_map({ h, next }, iterator, fun) do
-    [fun.(h)|do_map(iterator.(next), iterator, fun)]
-  end
-
   ## map join
 
   defp do_map_join([h|t], mapper, joiner, nil) do
@@ -1338,16 +1296,6 @@ defmodule Enum do
     { :lists.reverse(acc1), :lists.reverse(acc2) }
   end
 
-  ## reverse
-
-  defp do_reverse({ h, next }, iterator, acc) do
-    do_reverse(iterator.(next), iterator, [h|acc])
-  end
-
-  defp do_reverse(:stop, _, acc) do
-    acc
-  end
-
   ## sort
 
   defp sort_reducer(entry, { :split, y, x, r, rs, bool }, fun) do
@@ -1594,8 +1542,6 @@ defimpl Enum.Iterator, for: List do
     acc
   end
 
-  def iterator(list), do: list
-
   def member?([], _),       do: false
   def member?(list, value), do: :lists.member(value, list)
 
@@ -1607,11 +1553,6 @@ defimpl Enum.Iterator, for: Function do
     function.(acc, fun)
   end
 
-  def iterator(function) do
-    { iterator, first } = function.()
-    { iterator, iterator.(first) }
-  end
-
   def member?(function, value) do
     function.(false, fn(entry, _) ->
       if entry === value, do: throw(:function_member?), else: false

lib/elixir/lib/hash_dict.ex

@@ -588,7 +588,6 @@ end
 
 defimpl Enum.Iterator, for: HashDict do
   def reduce(dict, acc, fun),  do: HashDict.reduce(dict, acc, fun)
-  def iterator(dict),          do: HashDict.to_list(dict)
   def member?(dict, { k, v }), do: match?({ :ok, ^v }, HashDict.fetch(dict, k))
   def member?(_dict, _),       do: false
   def count(dict),             do: HashDict.size(dict)

lib/elixir/lib/range.ex

@@ -7,15 +7,6 @@ end
 defprotocol Range.Iterator do
   def reduce(first, range, acc, fun)
 
-  @doc """
-  How to iterate the range, receives the first
-  and range as arguments. It needs to return a
-  function that receives an item and returns
-  a tuple with two elements: the given item
-  and the next item in the iteration.
-  """
-  def iterator(first, range)
-
   @doc """
   Count how many items are in the range.
   """
@@ -26,12 +17,6 @@ defimpl Enum.Iterator, for: Range do
   def reduce(Range[first: first] = range, acc, fun) do
     Range.Iterator.reduce(first, range, acc, fun)
   end
-
-  def iterator(Range[first: first] = range) do
-    iterator = Range.Iterator.iterator(first, range)
-    { iterator, iterator.(first) }
-  end
-
   def member?(Range[first: first, last: last], value) do
     value in first..last
   end
@@ -67,18 +52,6 @@ defimpl Range.Iterator, for: Number do
     end
   end
 
-  def iterator(first, Range[last: last]) when is_integer(first) and is_integer(last) and last >= first do
-    fn(current) ->
-      if current > last, do: :stop, else: { current, current + 1 }
-    end
-  end
-
-  def iterator(first, Range[last: last]) when is_integer(first) and is_integer(last) do
-    fn(current) ->
-      if current < last, do: :stop, else: { current, current - 1 }
-    end
-  end
-
   def count(first, Range[last: last]) when is_integer(first) and is_integer(last) and last >= first do
     last - first + 1
   end