Merge pull request #2414 from christhekeele/empty-range-slice

Ensures Enum.slice always returns a list.

Author: José Valim

lib/elixir/lib/enum.ex

@@ -1417,18 +1417,33 @@ defmodule Enum do
   @doc """
   Returns a subset list of the given collection. Drops elements
   until element position `start`, then takes `count` elements.
+  
+  If the count is greater than collection length, it returns as
+  much as possible. If zero, then it returns `[]`.
 
   ## Examples
 
       iex> Enum.slice(1..100, 5, 10)
       [6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
 
+      iex> Enum.slice(1..10, 5, 100)
+      [6, 7, 8, 9, 10]
+
+      iex> Enum.slice(1..10, 5, 0)
+      []
+
   """
   @spec slice(t, integer, non_neg_integer) :: list
+  
+  def slice(_coll, _start, 0), do: []
 
   def slice(coll, start, count) when start < 0 do
     {list, new_start} = enumerate_and_count(coll, start)
-    if new_start >= 0, do: slice(list, new_start, count)
+    if new_start >= 0 do
+      slice(list, new_start, count)
+    else
+      []
+    end
   end
 
   def slice(coll, start, count) when is_list(coll) and start >= 0 and count > 0 do
@@ -1445,15 +1460,7 @@ defmodule Enum do
         {:halt, {start, count, [entry|list]}}
     end) |> elem(1)
 
-    if start <= 0, do: :lists.reverse(list)
-  end
-
-  def slice(coll, start, 0) do
-    res =
-      Enumerable.reduce(coll, {:cont, start}, fn _, start ->
-        if start > 0, do: {:cont, start-1}, else: {:halt, []}
-      end) |> elem(1)
-    if is_list(res), do: res
+    :lists.reverse(list)
   end
 
   @doc """
@@ -1468,17 +1475,31 @@ defmodule Enum do
   The first position (after adding count to negative positions) must be smaller
   or equal to the last position.
 
+  If the start of the range is not a valid offset for the given
+  collection or if the range is in reverse order, returns `[]`.
+
   ## Examples
 
       iex> Enum.slice(1..100, 5..10)
       [6, 7, 8, 9, 10, 11]
 
+      iex> Enum.slice(1..10, 5..20)
+      [6, 7, 8, 9, 10]
+
+      iex> Enum.slice(1..10, 11..20)
+      []
+
+      iex> Enum.slice(1..10, 6..5)
+      []
+
   """
   @spec slice(t, Range.t) :: list
   def slice(coll, first..last) when first >= 0 and last >= 0 do
     # Simple case, which works on infinite collections
     if last - first >= 0 do
       slice(coll, first, last - first + 1)
+    else
+      []
     end
   end
 
@@ -1489,6 +1510,8 @@ defmodule Enum do
     length = corr_last - corr_first + 1
     if corr_first >= 0 and length > 0 do
       slice(list, corr_first, length)
+    else
+      []
     end
   end
 
@@ -2143,11 +2166,11 @@ defmodule Enum do
   ## slice
 
   defp do_slice([], start, _count) do
-    if start == 0, do: []
+    []
   end
 
   defp do_slice(list, start, 0) do
-    if start < length(list), do: []
+    []
   end
 
   defp do_slice([h|t], 0, count) do

lib/elixir/test/elixir/enum_test.exs

@@ -426,11 +426,12 @@ defmodule EnumTest.List do
     assert Enum.slice([1,2,3,4,5], 1, 2) == [2, 3]
     assert Enum.slice([1,2,3,4,5], 1, 0) == []
     assert Enum.slice([1,2,3,4,5], 2, 5) == [3, 4, 5]
+    assert Enum.slice([1,2,3,4,5], 2, 6) == [3, 4, 5]
     assert Enum.slice([1,2,3,4,5], 5, 5) == []
-    assert Enum.slice([1,2,3,4,5], 6, 5) == nil
-    assert Enum.slice([1,2,3,4,5], 6, 0) == nil
-    assert Enum.slice([1,2,3,4,5], -6, 0) == nil
-    assert Enum.slice([1,2,3,4,5], -6, 5) == nil
+    assert Enum.slice([1,2,3,4,5], 6, 5) == []
+    assert Enum.slice([1,2,3,4,5], 6, 0) == []
+    assert Enum.slice([1,2,3,4,5], -6, 0) == []
+    assert Enum.slice([1,2,3,4,5], -6, 5) == []
     assert Enum.slice([1,2,3,4,5], -2, 5) == [4, 5]
     assert Enum.slice([1,2,3,4,5], -3, 1) == [3]
   end
@@ -440,18 +441,19 @@ defmodule EnumTest.List do
     assert Enum.slice([1,2,3,4,5], 0..1) == [1, 2]
     assert Enum.slice([1,2,3,4,5], 0..2) == [1, 2, 3]
     assert Enum.slice([1,2,3,4,5], 1..2) == [2, 3]
-    assert Enum.slice([1,2,3,4,5], 1..0) == nil
+    assert Enum.slice([1,2,3,4,5], 1..0) == []
     assert Enum.slice([1,2,3,4,5], 2..5) == [3, 4, 5]
+    assert Enum.slice([1,2,3,4,5], 2..6) == [3, 4, 5]
     assert Enum.slice([1,2,3,4,5], 4..4) == [5]
     assert Enum.slice([1,2,3,4,5], 5..5) == []
-    assert Enum.slice([1,2,3,4,5], 6..5) == nil
-    assert Enum.slice([1,2,3,4,5], 6..0) == nil
-    assert Enum.slice([1,2,3,4,5], -6..0) == nil
-    assert Enum.slice([1,2,3,4,5], -6..5) == nil
+    assert Enum.slice([1,2,3,4,5], 6..5) == []
+    assert Enum.slice([1,2,3,4,5], 6..0) == []
+    assert Enum.slice([1,2,3,4,5], -6..0) == []
+    assert Enum.slice([1,2,3,4,5], -6..5) == []
     assert Enum.slice([1,2,3,4,5], -5..-1) == [1, 2, 3, 4, 5]
     assert Enum.slice([1,2,3,4,5], -5..-3) == [1, 2, 3]
-    assert Enum.slice([1,2,3,4,5], -6..-1) == nil
-    assert Enum.slice([1,2,3,4,5], -6..-3) == nil
+    assert Enum.slice([1,2,3,4,5], -6..-1) == []
+    assert Enum.slice([1,2,3,4,5], -6..-3) == []
   end
 end
 
@@ -759,11 +761,12 @@ defmodule EnumTest.Range do
     assert Enum.slice(1..5, 1, 2) == [2, 3]
     assert Enum.slice(1..5, 1, 0) == []
     assert Enum.slice(1..5, 2, 5) == [3, 4, 5]
+    assert Enum.slice(1..5, 2, 6) == [3, 4, 5]
     assert Enum.slice(1..5, 5, 5) == []
-    assert Enum.slice(1..5, 6, 5) == nil
-    assert Enum.slice(1..5, 6, 0) == nil
-    assert Enum.slice(1..5, -6, 0) == nil
-    assert Enum.slice(1..5, -6, 5) == nil
+    assert Enum.slice(1..5, 6, 5) == []
+    assert Enum.slice(1..5, 6, 0) == []
+    assert Enum.slice(1..5, -6, 0) == []
+    assert Enum.slice(1..5, -6, 5) == []
     assert Enum.slice(1..5, -2, 5) == [4, 5]
     assert Enum.slice(1..5, -3, 1) == [3]
   end
@@ -773,18 +776,19 @@ defmodule EnumTest.Range do
     assert Enum.slice(1..5, 0..1) == [1, 2]
     assert Enum.slice(1..5, 0..2) == [1, 2, 3]
     assert Enum.slice(1..5, 1..2) == [2, 3]
-    assert Enum.slice(1..5, 1..0) == nil
+    assert Enum.slice(1..5, 1..0) == []
     assert Enum.slice(1..5, 2..5) == [3, 4, 5]
+    assert Enum.slice(1..5, 2..6) == [3, 4, 5]
     assert Enum.slice(1..5, 4..4) == [5]
     assert Enum.slice(1..5, 5..5) == []
-    assert Enum.slice(1..5, 6..5) == nil
-    assert Enum.slice(1..5, 6..0) == nil
-    assert Enum.slice(1..5, -6..0) == nil
-    assert Enum.slice(1..5, -6..5) == nil
+    assert Enum.slice(1..5, 6..5) == []
+    assert Enum.slice(1..5, 6..0) == []
+    assert Enum.slice(1..5, -6..0) == []
+    assert Enum.slice(1..5, -6..5) == []
     assert Enum.slice(1..5, -5..-1) == [1, 2, 3, 4, 5]
     assert Enum.slice(1..5, -5..-3) == [1, 2, 3]
-    assert Enum.slice(1..5, -6..-1) == nil
-    assert Enum.slice(1..5, -6..-3) == nil
+    assert Enum.slice(1..5, -6..-1) == []
+    assert Enum.slice(1..5, -6..-3) == []
   end
 
   test :sort do