Avoid traversing untouched tails in Enum.reverse_slice/3

lib/elixir/lib/enum.ex

@@ -2776,14 +2776,25 @@ defmodule Enum do
   @spec reverse_slice(t, non_neg_integer, non_neg_integer) :: list
   def reverse_slice(enumerable, start_index, count)
       when is_integer(start_index) and start_index >= 0 and is_integer(count) and count >= 0 do
-    list = reverse(enumerable)
-    length = length(list)
-    count = Kernel.min(count, length - start_index)
+    list = to_list(enumerable)
 
-    if count > 0 do
-      reverse_slice(list, length, start_index + count, count, [])
-    else
-      :lists.reverse(list)
+    cond do
+      count <= 1 ->
+        list
+
+      start_index == 0 ->
+        {slice, rest} = head_slice(list, count, [])
+        slice ++ rest
+
+      true ->
+        case head_slice(list, start_index, []) do
+          {_, []} ->
+            list
+
+          {prefix, rest} ->
+            {slice, rest} = head_slice(rest, count, [])
+            :lists.reverse(prefix, slice ++ rest)
+        end
     end
   end
 
@@ -4725,16 +4736,8 @@ defmodule Enum do
 
   ## reverse_slice
 
-  defp reverse_slice(rest, idx, idx, count, acc) do
-    {slice, rest} = head_slice(rest, count, [])
-    :lists.reverse(rest, :lists.reverse(slice, acc))
-  end
-
-  defp reverse_slice([elem | rest], idx, start, count, acc) do
-    reverse_slice(rest, idx - 1, start, count, [elem | acc])
-  end
-
   defp head_slice(rest, 0, acc), do: {acc, rest}
+  defp head_slice([], _count, acc), do: {acc, []}
 
   defp head_slice([elem | rest], count, acc) do
     head_slice(rest, count - 1, [elem | acc])

lib/elixir/test/elixir/enum_test.exs

@@ -948,8 +948,20 @@ defmodule EnumTest do
     assert Enum.reverse_slice([1, 2, 3], 0, 1) == [1, 2, 3]
     assert Enum.reverse_slice([1, 2, 3], 0, 2) == [2, 1, 3]
     assert Enum.reverse_slice([1, 2, 3], 0, 20_000_000) == [3, 2, 1]
+    assert Enum.reverse_slice([1, 2, 3], 1, 2) == [1, 3, 2]
     assert Enum.reverse_slice([1, 2, 3], 100, 2) == [1, 2, 3]
     assert Enum.reverse_slice([1, 2, 3], 10, 10) == [1, 2, 3]
+
+    list = [1, 2, 3, 4, 5]
+
+    for size <- 0..5, start <- 0..(size + 1), count <- 0..(size + 1) do
+      sublist = Enum.take(list, size)
+      {prefix, rest} = Enum.split(sublist, start)
+      {slice, suffix} = Enum.split(rest, count)
+      assert Enum.reverse_slice(sublist, start, count) == prefix ++ Enum.reverse(slice) ++ suffix
+    end
+
+    assert_runs_enumeration_only_once(&Enum.reverse_slice(&1, 1, 2))
   end
 
   describe "slide/3" do