Add Enum.concat/1,2 and Stream.concat/1,2

Author: betawaffle

lib/elixir/lib/enum.ex

@@ -221,6 +221,57 @@ defmodule Enum do
     end
   end
 
+  @doc """
+  Given a list of enumerables, concatenate the enumerables into a single list.
+
+  ## Examples
+
+      iex> Enum.concat([1..3, 4..6, 7..9])
+      [1,2,3,4,5,6,7,8,9]
+
+      iex> Enum.concat([[1, [2], 3], [4], [5, 6]])
+      [1,[2],3,4,5,6]
+
+  """
+  @spec concat([t]) :: t
+  def concat(enumerables) when is_list(enumerables) do
+    do_concat(enumerables)
+  end
+
+  @doc """
+  Concatenates the enumerable on the right with the enumerable on the left.
+
+  This function produces the same result the `++` operator for lists.
+
+  ## Examples
+
+      iex> Enum.concat(1..3, 4..6)
+      [1,2,3,4,5,6]
+
+      iex> Enum.concat([1, 2, 3], [4, 5, 6])
+      [1,2,3,4,5,6]
+
+  """
+  @spec concat(t, t) :: t
+  def concat(left, right) when is_list(left) and is_list(right) do
+    left ++ right
+  end
+
+  def concat(left, right) do
+    do_concat([left, right])
+  end
+
+  defp do_concat(enumerables, acc // [])
+
+  defp do_concat([enumerable|enumerables], acc) do
+    acc = Enumerable.reduce(enumerable, acc, &[&1|&2])
+    do_concat(enumerables, acc)
+  end
+
+  defp do_concat([], acc) do
+    :lists.reverse(acc)
+  end
+
   @doc """
   Drops the first `count` items from `collection`.
   Expects an ordered collection.

lib/elixir/lib/stream.ex

@@ -131,6 +131,45 @@ defmodule Stream do
   @type index :: non_neg_integer
   @type default :: any
 
+  @doc """
+  Creates a stream that enumerates each enumerable in a list.
+
+  ## Examples
+
+      iex> stream = Stream.concat([1..3, 4..6, 7..9])
+      iex> Enum.to_list(stream)
+      [1,2,3,4,5,6,7,8,9]
+
+  """
+  @spec concat([Enumerable.t]) :: t
+  def concat(enumerables) do
+    do_concat(enumerables, &1, &2)
+  end
+
+  @doc """
+  Creates a stream that enumerates the first argument, followed by the second.
+
+  ## Examples
+
+      iex> stream = Stream.concat(1..3, 4..6)
+      iex> Enum.to_list(stream)
+      [1,2,3,4,5,6]
+
+  """
+  @spec concat(Enumerable.t, Enumerable.t) :: t
+  def concat(first, second) do
+    do_concat([first, second], &1, &2)
+  end
+
+  defp do_concat([enumerable|enumerables], acc, fun) do
+    acc = Enumerable.reduce(enumerable, acc, fun)
+    do_concat(enumerables, acc, fun)
+  end
+
+  defp do_concat([], acc, _fun) do
+    acc
+  end
+
   @doc """
   Creates a stream that cycles through the given enumerable,
   infinitely.